@Override public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) { if (((access & Opcodes.ACC_PUBLIC) | (access & Opcodes.ACC_PROTECTED) | (access & Opcodes.ACC_PRIVATE)) == 0) { shortSyntax = true; // specifying "class <MyClass>" rather than "public class <MyClass>" means using short syntax access |= Opcodes.ACC_PUBLIC; // force the public modifier on the btrace class } className = name; super.visit(version, access, name, signature, superName, interfaces); }
public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) { desc = desc.replace(oldNameDesc, newNameDesc); if (signature != null) { signature = signature.replace(oldNameDesc, newNameDesc); } return super.visitField(access, name, desc, signature, value); }
private MethodVisitor addMethod(int access, String name, String desc, String signature, String[] exceptions) { return super.visitMethod(access, name, desc, signature, exceptions); }
public void visitEnd() { fromClass.accept(new ClassVisitor(Opcodes.ASM4) { public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { MethodInfo mi = getMethodInfo(name, desc); if (mi != null) { return addMethod(mi.newAccess, mi.newName, desc, signature, exceptions); } else { return null; } } }, 0); super.visitEnd(); }
@Override public void visitEnd() { if (cycleDetector.hasCycle()) { reportError("execution.loop.danger"); } super.visitEnd(); }
public AnnotationVisitor visitAnnotation(String desc, boolean visible) { if (desc.equals(BTRACE_DESC)) { seenBTrace = true; } return super.visitAnnotation(desc, visible); }
public static void main(String[] args) throws Exception { if (args.length == 0) { usage("java net.java.btrace.runtime.Verifier <.class file>"); } args[0] = args[0].replace('.', '/'); File file = new File(args[0] + ".class"); if (! file.exists()) { usage("file '" + args[0] + ".class' does not exist"); } FileInputStream fis = new FileInputStream(file); ClassReader reader = new ClassReader(new BufferedInputStream(fis)); Verifier verifier = new Verifier(new ClassVisitor(Opcodes.ASM4){}); reader.accept(verifier, 0); } }
@Override public void visitEnd() { if (!clinitFound) { MethodVisitor mv = visitMethod(Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC, CLINIT, "()V", null, null); // NOI18N // this will call this method's visitMethod method, effectively generating the clinit content mv.visitCode(); // need to call visitMaxs explicitely mv.visitMaxs(0, 0); // properly close the method body mv.visitEnd(); } super.visitEnd(); }
public AnnotationVisitor visitAnnotation(String desc, boolean visible) { final AnnotationVisitor zupr = super.visitAnnotation(desc, visible); if ("Lnet/java/btrace/annotations/BTrace;".equals(desc)) { return new AnnotationVisitor(Opcodes.ASM4) { public void visit(String string, Object o) { if ("name".equals(string)) { externalClassName = (String)o; } zupr.visit(string, o); } public void visitEnum(String string, String string1, String string2) { zupr.visitEnum(string, string1, string2); } public AnnotationVisitor visitAnnotation(String string, String string1) { // do nothing return zupr.visitAnnotation(string, string1); } public AnnotationVisitor visitArray(String string) { // do nothing return zupr.visitArray(string); } public void visitEnd() { zupr.visitEnd(); } }; } return zupr; }
public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions); return new ObjectAllocInstrumentor(mv, args[0], args[0], access, name, desc) { @Override protected void afterObjectNew(String desc) { println("after allocating an object of " + desc); } @Override protected void beforeObjectNew(String desc) { println("before allocating an object of " + desc); } }; } });
@Override public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) { if (((access & Opcodes.ACC_PUBLIC) | (access & Opcodes.ACC_PROTECTED) | (access & Opcodes.ACC_PRIVATE)) == 0) { shortSyntax = true; // specifying "class <MyClass>" rather than "public class <MyClass>" means using short syntax access |= Opcodes.ACC_PUBLIC; // force the public modifier on the btrace class } className = name; super.visit(version, access, name, signature, superName, interfaces); }
@Override public FieldVisitor visitField(final int access, final String name, final String desc, final String signature, final Object value) { if (!shortSyntax) return super.visitField(access, name, desc, signature, value); final List<Attribute> attrs = new ArrayList<Attribute>(); final List<String> annNames = new ArrayList<String>(); return new FieldVisitor(Opcodes.ASM4) { public void visitAttribute(Attribute atrbt) { attrs.add(atrbt); } @Override public AnnotationVisitor visitAnnotation(String desc, boolean visible) { if (visible) { annNames.add(desc); } return super.visitAnnotation(desc, visible); } public void visitEnd() { FieldDescriptor fd = new FieldDescriptor(access, name, desc, signature, value, attrs, annNames); fields.add(fd); } }; }
public void visitEnd() { int size = applicableOnMethods.size(); List<MethodCopier.MethodInfo> mi = new ArrayList<MethodCopier.MethodInfo>(size); for (OnMethod om : calledOnMethods) { mi.add(new MethodCopier.MethodInfo(om.getTargetName(), om.getTargetDescriptor(), getActionMethodName(om.getTargetName()), ACC_STATIC | ACC_PRIVATE)); } introduceTimeStampHelper(); MethodCopier copier = new MethodCopier(btraceClass, cv, mi, (version & 0x0000ffff) >= Opcodes.V1_6) { @Override protected MethodVisitor addMethod(int access, String name, String desc, String signature, String[] exceptions) { desc = desc.replace(ANYTYPE_DESC, OBJECT_DESC); if (signature != null) { signature = signature.replace(ANYTYPE_DESC, OBJECT_DESC); } return super.addMethod(access, name, desc, signature, exceptions); } }; copier.visitEnd(); super.visitEnd(); }
public AnnotationVisitor visitAnnotation(String desc, boolean visible) { AnnotationVisitor av = super.visitAnnotation(desc, visible); String extName = Type.getType(desc).getClassName(); for (OnMethod om : onMethods) { String probeClazz = om.getClazz(); if (probeClazz.length() > 0 && probeClazz.charAt(0) == '@') { probeClazz = probeClazz.substring(1); if (probeClazz.length() == 0) { continue; } if (REGEX_SPECIFIER.matcher(probeClazz).matches()) { probeClazz = probeClazz.substring(1, probeClazz.length() - 1); try { if (extName.matches(probeClazz)) { applicableOnMethods.add(om); } } catch (PatternSyntaxException pse) { reportPatternSyntaxException(probeClazz); } } else if (probeClazz.equals(extName)) { applicableOnMethods.add(om); } } } return av; }
@Override public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] throwables) { return new MethodVisitor(Opcodes.ASM4, super.visitMethod(access, name, desc, signature, throwables)) { @Override public void visitTypeInsn(int opcode, String type) { if (opcode == Opcodes.NEW && "java/lang/StringBuilder".equals(type)) { visitMethodInsn(Opcodes.INVOKESTATIC, Verifier.INLINED_INSTR_MARKER, Verifier.INLINED_INSTR_START, "()V"); } super.visitTypeInsn(opcode, type); } @Override public void visitMethodInsn(int opcode, String owner, String name, String desc) { super.visitMethodInsn(opcode, owner, name, desc); if ("java/lang/StringBuilder".equals(owner) && "toString".equals(name)) { visitMethodInsn(Opcodes.INVOKESTATIC, Verifier.INLINED_INSTR_MARKER, Verifier.INLINED_INSTR_END, "()V"); } } }; }
public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) { super.visit(version, access, name, signature, superName, interfaces); className = name; }
@Override public FieldVisitor visitField(final int access, final String name, final String desc, final String signature, final Object value) { if (!shortSyntax) return super.visitField(access, name, desc, signature, value); final List<Attribute> attrs = new ArrayList<Attribute>(); final List<String> annNames = new ArrayList<String>(); return new FieldVisitor(Opcodes.ASM4) { public void visitAttribute(Attribute atrbt) { attrs.add(atrbt); } @Override public AnnotationVisitor visitAnnotation(String desc, boolean visible) { if (visible) { annNames.add(desc); } return super.visitAnnotation(desc, visible); } public void visitEnd() { FieldDescriptor fd = new FieldDescriptor(access, name, desc, signature, value, attrs, annNames); fields.add(fd); } }; }
public void visitEnd() { if (! classInitializerFound) { // add a dummy <clinit> method that just returns. MethodVisitor clinit = visitMethod(ACC_STATIC|ACC_PUBLIC, CLASS_INITIALIZER, "()V", null, null); clinit.visitCode(); clinit.visitInsn(RETURN); clinit.visitMaxs(0, 0); clinit.visitEnd(); } addFields(); super.visitEnd(); }
protected MethodVisitor addMethod(int access, String name, String desc, String signature, String[] exceptions) { MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions); return new MethodVisitor(Opcodes.ASM4, mv) { @Override public AnnotationVisitor visitAnnotation(String string, boolean bln) { return null; } @Override public AnnotationVisitor visitAnnotationDefault() { return null; } @Override public void visitFrame(int i, int i1, Object[] os, int i2, Object[] os1) { if (keepStackMap) super.visitFrame(i, i1, os, i2, os1); } }; }
public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) { oldName = name; oldNameDesc = "L" + oldName + ";"; if (signature != null) { signature = signature.replace(oldNameDesc, newNameDesc); } super.visit(version, access, newName, signature, superName, interfaces); }