Refine search
public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { return cv.visitMethod(access, name, desc, signature, exceptions); }
@Override protected void startClass(ClassVisitor classWriter, String className, Type superType) { String[] interfaces = getImplementedInterfaceInternalNames(); classWriter.visit(V1_8, ACC_PUBLIC, className, null, !isInterface ? superType.getInternalName() : null, interfaces); classWriter.visitField(ACC_FINAL | ACC_PRIVATE, FIELD_INTERCEPTORS, FIELD_TYPE_INTERCEPTORS.getDescriptor(), null, null); classWriter.visitField(ACC_FINAL | ACC_PRIVATE, FIELD_PROXY_METHODS, FIELD_TYPE_PROXY_METHODS.getDescriptor(), null, null); }
@Override public void visitEnd() { if (transformedState.transformationsMade()) { cv.visitField(ACC_PUBLIC + ACC_STATIC, markerAlreadyTransformed, "Z", null, null).visitEnd(); } super.visitEnd(); }
@Override public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) { super.visit(version, access, name, signature, superName, interfaces); if (exist == false) { super.visitField(ACC_PUBLIC, field, Type.getDescriptor(Object.class), null, null).visitEnd(); } } @Override
public String buildInvocationClz(ClassVisitor cw) { String typeName = getCurrentInvocationName(); cw.visit(V1_6, ACC_PUBLIC, typeName, null, "java/lang/Object", new String[]{ toInternal(invocationInterfaceDesc)}); cw.visitField(ACC_PRIVATE | ACC_FINAL, "thiz", "Ljava/lang/Object;", null, null).visitEnd(); cw.visitField(ACC_PRIVATE | ACC_FINAL, "args", "[Ljava/lang/Object;", null, null).visitEnd(); cw.visitField(ACC_PRIVATE | ACC_FINAL, "idx", "I", null, null).visitEnd(); MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "<init>", "(Ljava/lang/Object;[Ljava/lang/Object;I)V", null, null); mv.visitCode(); mv.visitVarInsn(ALOAD, 0); mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V"); mv.visitVarInsn(ALOAD, 0); mv.visitVarInsn(ALOAD, 1); MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "getArguments", "()[Ljava/lang/Object;", null, null); mv.visitCode(); mv.visitVarInsn(ALOAD, 0); MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "getThis", "()Ljava/lang/Object;", null, null); mv.visitCode(); mv.visitVarInsn(ALOAD, 0); MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "proceed", "()Ljava/lang/Object;", null, new String[]{"java/lang/Throwable"}); mv.visitCode(); mv.visitMethodInsn(INVOKESTATIC, toInternal(m.owner), m.name, m.desc);
String generatedName) { MethodVisitor methodVisitor = classVisitor.visitMethod(Opcodes.ACC_PUBLIC, "process", methodDescriptor(int.class, iFace, int.class), null, null); methodVisitor.visitCode(); methodVisitor.visitLabel(localScopeStart); methodVisitor.visitInsn(Opcodes.ICONST_0); methodVisitor.visitVarInsn(Opcodes.ISTORE, localIndexOfLoopIndex); methodVisitor.visitMethodInsn(Opcodes.INVOKEINTERFACE, Type.getInternalName(iFace), method.getName(), Type.getMethodDescriptor(method), true); methodVisitor.visitLocalVariable("this", "L" + generatedName + ";", null, localScopeStart, localScopeEnd, 0); methodVisitor.visitLocalVariable("impl", Type.getType(iFace).getDescriptor(), null, localScopeStart, localScopeEnd, localIndexOfImpl); methodVisitor.visitLocalVariable("limit", Type.getType(int.class).getDescriptor(), null, localScopeStart, localScopeEnd, localIndexOfLimit); methodVisitor.visitLocalVariable("loopIndex", Type.getType(int.class).getDescriptor(), null, localScopeStart, localScopeEnd, localIndexOfLoopIndex);
private void genSwitchMethod(ClassVisitor cw, String typeName, String methodName, CB callback) { MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, methodName, "()Ljava/lang/String;", null, null); mv.visitCode(); mv.visitVarInsn(ALOAD, 0); mv.visitFieldInsn(GETFIELD, typeName, "idx", "I"); Label def = new Label(); Label[] labels = new Label[callbacks.size()];
private static void addOriginalClassName(ClassVisitor cv, String owner, String originalClassName) { cv.visitField(ACC_PRIVATE | ACC_STATIC | ACC_SYNTHETIC | ACC_FINAL, "__originalClassName", Type.getDescriptor(String.class), "", originalClassName); MethodVisitor mv = cv.visitMethod(ACC_PUBLIC, "getOriginalClassName", Type.getMethodDescriptor(Type.getType(String.class)), null, null); mv.visitCode(); mv.visitFieldInsn(GETSTATIC, owner, "__originalClassName", Type.getDescriptor(String.class)); mv.visitInsn(ARETURN); mv.visitMaxs(1, 1); mv.visitEnd(); }
int primitiveMessageSize, int referenceMessageSize) { MethodVisitor methodVisitor = classVisitor.visitMethod(Opcodes.ACC_PUBLIC, "<init>", methodDescriptor(void.class, null, null); methodVisitor.visitCode(); int localIndexOfWaitStrategy = locals.newLocal(WaitStrategy.class); methodVisitor.visitVarInsn(Opcodes.ALOAD, LOCALS_INDEX_THIS); methodVisitor.visitVarInsn(Opcodes.ILOAD, localIndexOfCapacity); methodVisitor.visitLdcInsn(primitiveMessageSize); methodVisitor.visitLdcInsn(referenceMessageSize); methodVisitor.visitMethodInsn(Opcodes.INVOKESPECIAL, Type.getInternalName(parentType), "<init>", methodDescriptor(void.class, methodVisitor.visitVarInsn(Opcodes.ALOAD, LOCALS_INDEX_THIS); methodVisitor.visitVarInsn(Opcodes.ALOAD, localIndexOfWaitStrategy); methodVisitor.visitFieldInsn(Opcodes.PUTFIELD, generatedName, "waitStrategy", Type.getDescriptor(WaitStrategy.class)); methodVisitor.visitInsn(Opcodes.RETURN);
MethodVisitor methodVisitor = classVisitor.visitMethod(Opcodes.ACC_BRIDGE | Opcodes.ACC_SYNTHETIC | Opcodes.ACC_PUBLIC, methodName, methodDescriptor(bridgeMethodReturnType, bridgeMethodParameterTypes), null); methodVisitor.visitCode(); methodVisitor.visitVarInsn(Opcodes.ALOAD, LOCALS_INDEX_THIS); for (Class<?> parameterType : parameterTypes) { int localIndexOfParameter = locals.newLocal(parameterType); int loadOpCode = Type.getType(parameterType).getOpcode(Opcodes.ILOAD); methodVisitor.visitVarInsn(loadOpCode, localIndexOfParameter); methodVisitor.visitTypeInsn(Opcodes.CHECKCAST, Type.getInternalName(parameterType));
n.desc = "(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;"; MethodVisitor mv = cv.visitMethod(opcode == INVOKESPECIAL ? ACC_PUBLIC : ACC_PUBLIC | ACC_STATIC, n.name, n.desc, null, null); mv.visitCode(); int start; if (opcode != INVOKESTATIC) { mv.visitVarInsn(ALOAD, 0); if (opcode != INVOKESPECIAL) { mv.visitTypeInsn(CHECKCAST, toInternal(t.owner)); start = 0; Type[] args = Type.getArgumentTypes(t.desc); mv.visitMethodInsn(opcode, toInternal(t.owner), t.name, t.desc); Type ret = Type.getReturnType(t.desc); box(ret, mv); mv.visitInsn(ARETURN);
int index = 0; for (Class<?> exceptionType : method.getExceptionTypes()) { exceptions[index++] = Type.getInternalName(exceptionType); MethodVisitor methodVisitor = classVisitor.visitMethod(Opcodes.ACC_PUBLIC, method.getName(), Type.getMethodDescriptor(method), null, exceptions.length == 0 ? null : exceptions); methodVisitor.visitCode(); methodVisitor.visitVarInsn(Opcodes.LSTORE, localIndexOfWOffset); methodVisitor.visitVarInsn(Opcodes.LSTORE, localIndexOfArrayReferenceBaseIndex); varOffset, backendType); varOffset += Type.getType(parameterType).getSize(); arrayReferenceBaseIndexDelta++;
if ((access & Opcodes.ACC_NATIVE) != 0) { MethodVisitor mv = super.visitMethod(access & ~Opcodes.ACC_NATIVE, name, desc, signature, exceptions); if (mv != null) { mv.visitCode(); String exceptionName = Type.getInternalName(RuntimeException.class); mv.visitTypeInsn(Opcodes.NEW, exceptionName); mv.visitInsn(Opcodes.DUP); mv.visitLdcInsn(NATIVE_METHOD_ERROR); for (Type t : Type.getArgumentTypes(desc)) { numSlots += t.getSize(); return super.visitMethod(access, name, desc, signature, exceptions);
AnnotationVisitor interceptorTypeAnn = constructorWriter.visitParameterAnnotation( interceptorArgumentIndex, Type.getDescriptor(io.micronaut.context.annotation.Type.class), true ).visitArray("value"); for (Type interceptorType : interceptorTypes) { proxyBeanDefinitionWriter.visitBeanDefinitionInterface(ProxyBeanDefinition.class); ClassVisitor pcw = proxyBeanDefinitionWriter.getClassWriter(); targetDefinitionGenerator = new GeneratorAdapter(pcw.visitMethod(ACC_PUBLIC, METHOD_PROXY_TARGET_TYPE.getName(), METHOD_PROXY_TARGET_TYPE.getDescriptor(), targetTypeGenerator = new GeneratorAdapter(pcw.visitMethod(ACC_PUBLIC, METHOD_PROXY_TARGET_CLASS.getName(), METHOD_PROXY_TARGET_CLASS.getDescriptor(), ACC_PRIVATE | ACC_FINAL, FIELD_BEAN_LOCATOR, TYPE_BEAN_LOCATOR.getDescriptor(), null, null constructorWriter.visitInsn(RETURN); constructorWriter.visitMaxs(DEFAULT_MAX_STACK, 1); this.constructorWriter.visitEnd();
private static void implementProxy(ClassVisitor classVisitor, Class<?> iFace, String generatedName) { MethodVisitor methodVisitor = classVisitor.visitMethod(Opcodes.ACC_PUBLIC, "proxy", methodDescriptor(iFace), null, null); methodVisitor.visitCode(); methodVisitor.visitVarInsn(Opcodes.ALOAD, LOCALS_INDEX_THIS); methodVisitor.visitInsn(Opcodes.ARETURN); methodVisitor.visitMaxs(-1, -1); methodVisitor.visitEnd(); implementBridgeMethod(classVisitor, generatedName, "proxy", iFace); }
private MtdInfo newMethodA(int opcode, MtdInfo t, MtdInfo mapTo) { MtdInfo n = toCreate.get(t); if (n != null) { return n; } n = new MtdInfo(); n.owner = t.owner; n.name = buildMethodAName(t.name); boolean hasThis = opcode != INVOKESTATIC; if (hasThis) { Type[] args = Type.getArgumentTypes(t.desc); Type ret = Type.getReturnType(t.desc); List<Type> ts = new ArrayList<>(args.length + 1); ts.add(Type.getType(t.owner)); ts.addAll(Arrays.asList(args)); n.desc = Type.getMethodDescriptor(ret, ts.toArray(new Type[ts.size()])); } else { n.desc = t.desc; } toCreate.put(t, n); MethodVisitor mv = cv.visitMethod(ACC_SYNTHETIC | ACC_PRIVATE | ACC_STATIC, n.name, n.desc, null, null); mv.visitCode(); genMethodACode(opcode, t, mapTo, mv, t); return n; }
@Override public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) { MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions); Type target = Type.getType(meta.type.getInternalName() + "$Mutator_" + fd.name); return new MethodBodyTransplanter(sourceClassReader.getClassName(), target, mv); } };
context.currentMethodAccessFlags = readUnsignedShort(currentOffset); context.currentMethodName = readUTF8(currentOffset + 2, charBuffer); context.currentMethodDescriptor = readUTF8(currentOffset + 4, charBuffer); currentOffset += 6; classVisitor.visitMethod( context.currentMethodAccessFlags, context.currentMethodName, while (parametersCount-- > 0) { methodVisitor.visitParameter( readUTF8(currentParameterOffset, charBuffer), readUnsignedShort(currentParameterOffset + 2)); AnnotationVisitor annotationVisitor = methodVisitor.visitAnnotationDefault(); readElementValue(annotationVisitor, annotationDefaultOffset, null, charBuffer); if (annotationVisitor != null) { readElementValues( methodVisitor.visitAnnotation(annotationDescriptor, /* visible = */ true), currentAnnotationOffset, /* named = */ true,
public void begin_class(int version, final int access, String className, final Type superType, final Type[] interfaces, String source) { final Type classType = Type.getType("L" + className.replace('.', '/') + ";"); classInfo = new ClassInfo() { public Type getType() { return classType; } public Type getSuperType() { return (superType != null) ? superType : Constants.TYPE_OBJECT; } public Type[] getInterfaces() { return interfaces; } public int getModifiers() { return access; } }; cv.visit(version, access, classInfo.getType().getInternalName(), null, classInfo.getSuperType().getInternalName(), TypeUtils.toInternalNames(interfaces)); if (source != null) cv.visitSource(source, null); init(); }
classVisitor.visit( classVisitor.visitSource(sourceFile, sourceDebugExtension); classVisitor.visitNestHost(nestHostClass); classVisitor.visitOuterClass(className, name, type); classVisitor.visitAnnotation(annotationDescriptor, /* visible = */ true), currentAnnotationOffset, /* named = */ true, classVisitor.visitAnnotation(annotationDescriptor, /* visible = */ false), currentAnnotationOffset, /* named = */ true, classVisitor.visitTypeAnnotation( context.currentTypeAnnotationTarget, context.currentTypeAnnotationTargetPath, classVisitor.visitTypeAnnotation( context.currentTypeAnnotationTarget, context.currentTypeAnnotationTargetPath, classVisitor.visitAttribute(attributes); attributes = nextAttribute; int currentNestMemberOffset = nestMembersOffset + 2; while (numberOfNestMembers-- > 0) {