List of usage examples for org.objectweb.asm ClassVisitor visitEnd
public void visitEnd()
From source file:jaspex.stm.ExternalAccessHelper.java
License:Open Source License
public static byte[] generateClass(Type extAccessType) throws java.io.IOException { // Obter tipo original Type originalType = Type.fromCommon(extAccessType.commonName().replace(EXTERNALACCESS_CLASS_PREFIX, "")); Class<?> javaClass = null; try {// ww w .j a v a 2 s . com javaClass = Class.forName(originalType.commonName()); } catch (ClassNotFoundException e) { throw new Error(e); } Log.trace(color("[ ExternalAccessHelper ]", "31") + " Generating wrapper for {}", originalType); // Criar classe ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS); ClassVisitor cv = cw; List<InfoField> fieldList = InfoClass.fromType(originalType).fields(); // Adicionar inicializao de offsets usados pela unsafetrans ao clinit da classe // Nota: Visitor tem que estar *depois* do FieldTransactifierClassVisitor cv = new GenericMethodVisitorAdapter(cv, ChangeClinitMethodVisitor.class, originalType, extAccessType, fieldList); // Visitor que cria os campos offset e o staticfieldbase cv = new FieldTransactifierClassVisitor(cv, false); cv.visit(V1_6, ACC_PUBLIC | ACC_FINAL, extAccessType.asmName(), null, Type.OBJECT.asmName(), null); cv.visitSource(color("JaSPEx Generated External Access Class", "31"), null); // Visitar campos, para serem apanhados pelos visitors Iterator<InfoField> it = fieldList.iterator(); while (it.hasNext()) { InfoField f = it.next(); // Alguns campos (como o java.lang.System.security) no so visveis por reflection, // e portanto no geramos entradas para eles (hopefully nunca sero necessrias) try { Transaction.getFieldOffset(javaClass, f.name()); } catch (SecurityException e) { it.remove(); continue; } cv.visitField(f.access(), f.name(), f.desc().bytecodeName(), null, null); } cv.visitEnd(); byte[] newClass = cw.toByteArray(); if (Options.WRITECLASS) { try { new java.io.File("output" + java.io.File.separatorChar).mkdir(); java.io.FileOutputStream fos = new java.io.FileOutputStream( "output" + java.io.File.separatorChar + extAccessType.commonName() + ".class"); fos.write(newClass); fos.close(); } catch (java.io.FileNotFoundException e) { throw new Error(e); } catch (java.io.IOException e) { throw new Error(e); } } return newClass; }
From source file:jnr.ffi.provider.jffi.AsmLibraryLoader.java
License:Apache License
private <T> T generateInterfaceImpl(final NativeLibrary library, Class<T> interfaceClass, Map<LibraryOption, ?> libraryOptions, AsmClassLoader classLoader) { boolean debug = DEBUG && !interfaceClass.isAnnotationPresent(NoTrace.class); ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES); ClassVisitor cv = debug ? AsmUtil.newCheckClassAdapter(cw) : cw; AsmBuilder builder = new AsmBuilder(runtime, p(interfaceClass) + "$jnr$ffi$" + nextClassID.getAndIncrement(), cv, classLoader); cv.visit(V1_6, ACC_PUBLIC | ACC_FINAL, builder.getClassNamePath(), null, p(AbstractAsmLibraryInterface.class), new String[] { p(interfaceClass) }); FunctionMapper functionMapper = libraryOptions.containsKey(LibraryOption.FunctionMapper) ? (FunctionMapper) libraryOptions.get(LibraryOption.FunctionMapper) : IdentityFunctionMapper.getInstance(); SignatureTypeMapper typeMapper;//from ww w. ja va2s . c o m if (libraryOptions.containsKey(LibraryOption.TypeMapper)) { Object tm = libraryOptions.get(LibraryOption.TypeMapper); if (tm instanceof SignatureTypeMapper) { typeMapper = (SignatureTypeMapper) tm; } else if (tm instanceof TypeMapper) { typeMapper = new SignatureTypeMapperAdapter((TypeMapper) tm); } else { throw new IllegalArgumentException("TypeMapper option is not a valid TypeMapper instance"); } } else { typeMapper = new NullTypeMapper(); } typeMapper = new CompositeTypeMapper(typeMapper, new CachingTypeMapper( new InvokerTypeMapper(new NativeClosureManager(runtime, typeMapper, classLoader), classLoader, NativeLibraryLoader.ASM_ENABLED)), new CachingTypeMapper(new AnnotationTypeMapper())); CallingConvention libraryCallingConvention = getCallingConvention(interfaceClass, libraryOptions); StubCompiler compiler = StubCompiler.newCompiler(runtime); final MethodGenerator[] generators = { !interfaceClass.isAnnotationPresent(NoX86.class) ? new X86MethodGenerator(compiler) : new NotImplMethodGenerator(), new FastIntMethodGenerator(), new FastLongMethodGenerator(), new FastNumericMethodGenerator(), new BufferMethodGenerator() }; InterfaceScanner scanner = new InterfaceScanner(interfaceClass, typeMapper, libraryCallingConvention); for (NativeFunction function : scanner.functions()) { String functionName = functionMapper.mapFunctionName(function.name(), new NativeFunctionMapperContext(library, function.annotations())); try { long functionAddress = library.findSymbolAddress(functionName); FromNativeContext resultContext = new MethodResultContext(runtime, function.getMethod()); SignatureType signatureType = DefaultSignatureType.create(function.getMethod().getReturnType(), resultContext); ResultType resultType = getResultType(runtime, function.getMethod().getReturnType(), resultContext.getAnnotations(), typeMapper.getFromNativeType(signatureType, resultContext), resultContext); ParameterType[] parameterTypes = getParameterTypes(runtime, typeMapper, function.getMethod()); Function jffiFunction = new Function(functionAddress, getCallContext(resultType, parameterTypes, function.convention(), function.isErrnoRequired())); for (MethodGenerator g : generators) { if (g.isSupported(resultType, parameterTypes, function.convention())) { g.generate(builder, function.getMethod().getName(), jffiFunction, resultType, parameterTypes, !function.isErrnoRequired()); break; } } } catch (SymbolNotFoundError ex) { String errorFieldName = "error_" + uniqueId.incrementAndGet(); cv.visitField(ACC_PRIVATE | ACC_FINAL | ACC_STATIC, errorFieldName, ci(String.class), null, ex.getMessage()); generateFunctionNotFound(cv, builder.getClassNamePath(), errorFieldName, functionName, function.getMethod().getReturnType(), function.getMethod().getParameterTypes()); } } // generate global variable accessors VariableAccessorGenerator variableAccessorGenerator = new VariableAccessorGenerator(runtime); for (NativeVariable v : scanner.variables()) { Method m = v.getMethod(); java.lang.reflect.Type variableType = ((ParameterizedType) m.getGenericReturnType()) .getActualTypeArguments()[0]; if (!(variableType instanceof Class)) { throw new IllegalArgumentException("unsupported variable class: " + variableType); } String functionName = functionMapper.mapFunctionName(m.getName(), null); try { variableAccessorGenerator.generate(builder, interfaceClass, m.getName(), library.findSymbolAddress(functionName), (Class) variableType, sortedAnnotationCollection(m.getAnnotations()), typeMapper, classLoader); } catch (SymbolNotFoundError ex) { String errorFieldName = "error_" + uniqueId.incrementAndGet(); cv.visitField(ACC_PRIVATE | ACC_FINAL | ACC_STATIC, errorFieldName, ci(String.class), null, ex.getMessage()); generateFunctionNotFound(cv, builder.getClassNamePath(), errorFieldName, functionName, m.getReturnType(), m.getParameterTypes()); } } // Create the constructor to set the instance fields SkinnyMethodAdapter init = new SkinnyMethodAdapter(cv, ACC_PUBLIC, "<init>", sig(void.class, jnr.ffi.Runtime.class, NativeLibrary.class, Object[].class), null, null); init.start(); // Invoke the super class constructor as super(Library) init.aload(0); init.aload(1); init.aload(2); init.invokespecial(p(AbstractAsmLibraryInterface.class), "<init>", sig(void.class, jnr.ffi.Runtime.class, NativeLibrary.class)); builder.emitFieldInitialization(init, 3); init.voidreturn(); init.visitMaxs(10, 10); init.visitEnd(); cv.visitEnd(); try { byte[] bytes = cw.toByteArray(); if (debug) { ClassVisitor trace = AsmUtil.newTraceClassVisitor(new PrintWriter(System.err)); new ClassReader(bytes).accept(trace, 0); } Class<T> implClass = classLoader.defineClass(builder.getClassNamePath().replace("/", "."), bytes); Constructor<T> cons = implClass.getDeclaredConstructor(jnr.ffi.Runtime.class, NativeLibrary.class, Object[].class); T result = cons.newInstance(runtime, library, builder.getObjectFieldValues()); // Attach any native method stubs - we have to delay this until the // implementation class is loaded for it to work. System.err.flush(); System.out.flush(); compiler.attach(implClass); return result; } catch (Throwable ex) { throw new RuntimeException(ex); } }
From source file:jnr.ffi.provider.jffi.NativeClosureFactory.java
License:Apache License
static <T extends Object> NativeClosureFactory newClosureFactory(NativeRuntime runtime, Class<T> closureClass) { final long classIdx = nextClassID.getAndIncrement(); final String closureInstanceClassName = p(NativeClosureFactory.class) + "$ClosureInstance"; final ClassWriter closureClassWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES); final ClassVisitor closureClassVisitor = DEBUG ? AsmUtil.newCheckClassAdapter(closureClassWriter) : closureClassWriter;// w w w . j a va 2 s. co m closureClassVisitor.visit(V1_5, ACC_PUBLIC | ACC_FINAL, closureInstanceClassName, null, p(NativeClosure.class), new String[] { p(com.kenai.jffi.Closure.class) }); SkinnyMethodAdapter closureInit = new SkinnyMethodAdapter(closureClassVisitor.visitMethod(ACC_PUBLIC, "<init>", sig(void.class, NativeRuntime.class, Object.class, ReferenceQueue.class, Integer.class), null, null)); closureInit.start(); closureInit.aload(0); closureInit.aload(1); closureInit.aload(2); closureInit.aload(3); closureInit.aload(4); closureInit.invokespecial(p(NativeClosure.class), "<init>", sig(void.class, NativeRuntime.class, Object.class, ReferenceQueue.class, Integer.class)); closureInit.voidreturn(); closureInit.visitMaxs(10, 10); closureInit.visitEnd(); Method callMethod = null; for (Method m : closureClass.getMethods()) { if (m.isAnnotationPresent(Delegate.class) && Modifier.isPublic(m.getModifiers()) && !Modifier.isStatic(m.getModifiers())) { callMethod = m; break; } } if (callMethod == null) { throw new NoSuchMethodError( "no public non-static delegate method defined in " + closureClass.getName()); } SkinnyMethodAdapter closureInvoke = new SkinnyMethodAdapter(closureClassVisitor.visitMethod(ACC_PUBLIC, "invoke", sig(void.class, com.kenai.jffi.Closure.Buffer.class, Object.class), null, null)); closureInvoke.start(); if (void.class != callMethod.getReturnType() && Void.class != callMethod.getReturnType()) { // If the Callable returns a value, push the Callable.Buffer on the stack // for the call to Callable.Buffer#set<Foo>Return() closureInvoke.aload(1); } // Cast the Callable instance to the Callable subclass closureInvoke.aload(2); closureInvoke.checkcast(p(closureClass)); // Construct callback method Class[] parameterTypes = callMethod.getParameterTypes(); for (int i = 0; i < parameterTypes.length; ++i) { Class parameterType = parameterTypes[i]; if (!isParameterTypeSupported(parameterType)) { throw new IllegalArgumentException("unsupported closure parameter type " + parameterType); } // Load the Callable.Buffer for the parameter set call closureInvoke.aload(1); // Load the parameter index closureInvoke.pushInt(i); Class type = parameterType.isPrimitive() ? parameterType : AsmUtil.unboxedType(parameterType); if (byte.class == type) { closureInvoke.invokeinterface(p(com.kenai.jffi.Closure.Buffer.class), "getByte", sig(type, int.class)); } else if (char.class == type) { closureInvoke.invokeinterface(p(com.kenai.jffi.Closure.Buffer.class), "getShort", sig(short.class, int.class)); } else if (short.class == type) { closureInvoke.invokeinterface(p(com.kenai.jffi.Closure.Buffer.class), "getShort", sig(type, int.class)); } else if (int.class == type) { closureInvoke.invokeinterface(p(com.kenai.jffi.Closure.Buffer.class), "getInt", sig(type, int.class)); } else if (long.class == type && (long.class == parameterType || Long.class == parameterType)) { // Handle native long if (isLong32(parameterType, callMethod.getParameterAnnotations()[i])) { closureInvoke.invokeinterface(p(com.kenai.jffi.Closure.Buffer.class), "getInt", sig(int.class, int.class)); widen(closureInvoke, int.class, long.class); } else { closureInvoke.invokeinterface(p(com.kenai.jffi.Closure.Buffer.class), "getLong", sig(long.class, int.class)); } } else if (long.class == type) { // This long type is used by Pointer/Struct/String, etc closureInvoke.invokeinterface(p(com.kenai.jffi.Closure.Buffer.class), "getLong", sig(long.class, int.class)); } else if (float.class == type) { closureInvoke.invokeinterface(p(com.kenai.jffi.Closure.Buffer.class), "getFloat", sig(type, int.class)); } else if (double.class == type) { closureInvoke.invokeinterface(p(com.kenai.jffi.Closure.Buffer.class), "getDouble", sig(type, int.class)); } else { throw new IllegalArgumentException("unsupported closure parameter type " + parameterType); } AsmUtil.boxValue(closureInvoke, parameterType, type); } // dispatch to java method if (callMethod.getDeclaringClass().isInterface()) { closureInvoke.invokeinterface(p(closureClass), callMethod.getName(), sig(callMethod.getReturnType(), callMethod.getParameterTypes())); } else { closureInvoke.invokevirtual(p(closureClass), callMethod.getName(), sig(callMethod.getReturnType(), callMethod.getParameterTypes())); } Class returnType = callMethod.getReturnType(); if (!isReturnTypeSupported(returnType)) { throw new IllegalArgumentException("unsupported closure return type " + returnType.getName()); } Annotation[] returnAnnotations = callMethod.getAnnotations(); Class nativeReturnType = AsmUtil.unboxedType(returnType); if (isLong32(returnType, returnAnnotations)) { nativeReturnType = int.class; } if (Number.class.isAssignableFrom(returnType)) { AsmUtil.unboxNumber(closureInvoke, returnType, nativeReturnType); } else if (Boolean.class.isAssignableFrom(returnType)) { AsmUtil.unboxBoolean(closureInvoke, nativeReturnType); } else if (Pointer.class.isAssignableFrom(returnType)) { AsmUtil.unboxPointer(closureInvoke, nativeReturnType); } else if (Enum.class.isAssignableFrom(returnType)) { AsmUtil.unboxEnum(closureInvoke, nativeReturnType); } if (void.class == nativeReturnType || Void.class == nativeReturnType) { // No return value to set, so no call to set<Foo>Return() } else if (byte.class == nativeReturnType) { closureInvoke.invokeinterface(p(com.kenai.jffi.Closure.Buffer.class), "setByteReturn", sig(void.class, byte.class)); } else if (short.class == nativeReturnType || char.class == nativeReturnType) { closureInvoke.invokeinterface(p(com.kenai.jffi.Closure.Buffer.class), "setShortReturn", sig(void.class, short.class)); } else if (int.class == nativeReturnType) { closureInvoke.invokeinterface(p(com.kenai.jffi.Closure.Buffer.class), "setIntReturn", sig(void.class, int.class)); } else if (long.class == nativeReturnType) { closureInvoke.invokeinterface(p(com.kenai.jffi.Closure.Buffer.class), "setLongReturn", sig(void.class, long.class)); } else if (float.class == nativeReturnType) { closureInvoke.invokeinterface(p(com.kenai.jffi.Closure.Buffer.class), "setFloatReturn", sig(void.class, float.class)); } else if (double.class == nativeReturnType) { closureInvoke.invokeinterface(p(com.kenai.jffi.Closure.Buffer.class), "setDoubleReturn", sig(void.class, double.class)); } else if (boolean.class == nativeReturnType) { closureInvoke.invokeinterface(p(com.kenai.jffi.Closure.Buffer.class), "setIntReturn", sig(void.class, int.class)); } closureInvoke.voidreturn(); closureInvoke.visitMaxs(10, 10); closureInvoke.visitEnd(); closureClassVisitor.visitEnd(); try { byte[] closureImpBytes = closureClassWriter.toByteArray(); if (DEBUG) { ClassVisitor trace = AsmUtil.newTraceClassVisitor(new PrintWriter(System.err)); new ClassReader(closureImpBytes).accept(trace, 0); trace.visitEnd(); } ClassLoader cl = NativeClosureFactory.class.getClassLoader(); if (cl == null) { cl = Thread.currentThread().getContextClassLoader(); } if (cl == null) { cl = ClassLoader.getSystemClassLoader(); } AsmClassLoader asm = new AsmClassLoader(cl); Class<? extends NativeClosure> nativeClosureClass = asm.defineClass(c(closureInstanceClassName), closureImpBytes); Constructor<? extends NativeClosure> nativeClosureConstructor = nativeClosureClass .getConstructor(NativeRuntime.class, Object.class, ReferenceQueue.class, Integer.class); return new NativeClosureFactory(runtime, getCallContext(callMethod), nativeClosureConstructor); } catch (Throwable ex) { throw new RuntimeException(ex); } }
From source file:jnr.ffi.provider.jffi.VariableAccessorGenerator.java
License:Apache License
Variable buildVariableAccessor(jnr.ffi.Runtime runtime, long address, Class interfaceClass, Class javaType, Collection<Annotation> annotations, ToNativeConverter toNativeConverter, FromNativeConverter fromNativeConverter, AsmClassLoader classLoader) { boolean debug = AsmLibraryLoader.DEBUG && !hasAnnotation(annotations, NoTrace.class); ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES); ClassVisitor cv = debug ? AsmUtil.newCheckClassAdapter(cw) : cw; AsmBuilder builder = new AsmBuilder(runtime, p(interfaceClass) + "$VariableAccessor$$" + nextClassID.getAndIncrement(), cv, classLoader); cv.visit(V1_6, ACC_PUBLIC | ACC_FINAL, builder.getClassNamePath(), null, p(Object.class), new String[] { p(Variable.class) }); SkinnyMethodAdapter set = new SkinnyMethodAdapter(builder.getClassVisitor(), ACC_PUBLIC | ACC_FINAL, "set", sig(void.class, Object.class), null, null); Class boxedType = toNativeConverter != null ? toNativeConverter.nativeType() : javaType; NativeType nativeType = Types.getType(runtime, boxedType, annotations).getNativeType(); jnr.ffi.provider.ToNativeType toNativeType = new jnr.ffi.provider.ToNativeType(javaType, nativeType, annotations, toNativeConverter, null); jnr.ffi.provider.FromNativeType fromNativeType = new jnr.ffi.provider.FromNativeType(javaType, nativeType, annotations, fromNativeConverter, null); PointerOp pointerOp = pointerOperations.get(nativeType); if (pointerOp == null) { throw new IllegalArgumentException("global variable type not supported: " + javaType); }// www. ja va 2 s.com set.start(); set.aload(0); Pointer pointer = DirectMemoryIO.wrap(runtime, address); set.getfield(builder.getClassNamePath(), builder.getObjectFieldName(pointer, Pointer.class), ci(Pointer.class)); set.lconst_0(); set.aload(1); set.checkcast(javaType); emitToNativeConversion(builder, set, toNativeType); ToNativeOp toNativeOp = ToNativeOp.get(toNativeType); if (toNativeOp != null && toNativeOp.isPrimitive()) { toNativeOp.emitPrimitive(set, pointerOp.nativeIntClass, toNativeType.getNativeType()); } else if (Pointer.class.isAssignableFrom(toNativeType.effectiveJavaType())) { pointerOp = POINTER_OP_POINTER; } else { throw new IllegalArgumentException("global variable type not supported: " + javaType); } pointerOp.put(set); set.voidreturn(); set.visitMaxs(10, 10); set.visitEnd(); SkinnyMethodAdapter get = new SkinnyMethodAdapter(builder.getClassVisitor(), ACC_PUBLIC | ACC_FINAL, "get", sig(Object.class), null, null); get.start(); get.aload(0); get.getfield(builder.getClassNamePath(), builder.getObjectFieldName(pointer, Pointer.class), ci(Pointer.class)); get.lconst_0(); pointerOp.get(get); emitFromNativeConversion(builder, get, fromNativeType, pointerOp.nativeIntClass); get.areturn(); get.visitMaxs(10, 10); get.visitEnd(); SkinnyMethodAdapter init = new SkinnyMethodAdapter(cv, ACC_PUBLIC, "<init>", sig(void.class, Object[].class), null, null); init.start(); init.aload(0); init.invokespecial(p(Object.class), "<init>", sig(void.class)); builder.emitFieldInitialization(init, 1); init.voidreturn(); init.visitMaxs(10, 10); init.visitEnd(); cv.visitEnd(); try { byte[] bytes = cw.toByteArray(); if (debug) { ClassVisitor trace = AsmUtil.newTraceClassVisitor(new PrintWriter(System.err)); new ClassReader(bytes).accept(trace, 0); } Class<Variable> implClass = classLoader.defineClass(builder.getClassNamePath().replace("/", "."), bytes); Constructor<Variable> cons = implClass.getDeclaredConstructor(Object[].class); return cons.newInstance(new Object[] { builder.getObjectFieldValues() }); } catch (Throwable ex) { throw new RuntimeException(ex); } }
From source file:jnr.invoke.DefaultMethodHandleGenerator.java
License:Apache License
@Override public MethodHandle createBoundHandle(Signature signature, CodeAddress nativeAddress) { AsmClassLoader classLoader = new AsmClassLoader(Native.class.getClassLoader()); ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES); ClassVisitor cv = DEBUG ? AsmUtil.newCheckClassAdapter(cw) : cw; AsmBuilder builder = new AsmBuilder(p(Native.class) + "$jnr$ffi$" + nextClassID.getAndIncrement(), cv, classLoader);//from w ww . j a v a 2 s . com cv.visit(V1_7, ACC_PUBLIC | ACC_FINAL, builder.getClassNamePath(), null, p(java.lang.Object.class), new String[0]); ResultType resultType = signature.getResultType().asPrimitiveType(); generate(builder, STUB_NAME, signature.getNativeCallContext(), nativeAddress.address(), resultType, signature.parameterTypeArray()); // Stash a strong ref to the library, so it doesn't get garbage collected. builder.getObjectField(nativeAddress); emitDefaultConstructor(cv); emitStaticFieldInitialization(builder, cv); cv.visitEnd(); try { Class implClass = classLoader.defineClass(builder.getClassNamePath().replace("/", "."), cw.toByteArray(), DEBUG ? new OutputStreamWriter(System.err) : null); return LOOKUP.findStatic(implClass, STUB_NAME, signature.methodType()); } catch (Throwable ex) { throw new RuntimeException(ex); } }
From source file:jpcsp.Allegrex.compiler.CodeBlock.java
License:Open Source License
private Class<IExecutable> interpret(CompilerContext context) { Class<IExecutable> compiledClass = null; context.setCodeBlock(this); String className = getInternalClassName(); if (log.isInfoEnabled()) { log.info("Compiling for Interpreter " + className); }//from w ww .j a v a2 s. c o m int computeFlag = ClassWriter.COMPUTE_FRAMES; if (context.isAutomaticMaxLocals() || context.isAutomaticMaxStack()) { computeFlag |= ClassWriter.COMPUTE_MAXS; } ClassWriter cw = new ClassWriter(computeFlag); ClassVisitor cv = cw; if (log.isDebugEnabled()) { cv = new CheckClassAdapter(cv); } StringWriter debugOutput = null; if (log.isDebugEnabled()) { debugOutput = new StringWriter(); PrintWriter debugPrintWriter = new PrintWriter(debugOutput); cv = new TraceClassVisitor(cv, debugPrintWriter); } cv.visit(Opcodes.V1_6, Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER, className, null, objectInternalName, interfacesForExecutable); context.startClass(cv); addConstructor(cv); addNonStaticMethods(context, cv); MethodVisitor mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, context.getStaticExecMethodName(), context.getStaticExecMethodDesc(), null, exceptions); mv.visitCode(); context.setMethodVisitor(mv); context.startMethod(); context.compileExecuteInterpreter(getStartAddress()); mv.visitMaxs(context.getMaxStack(), context.getMaxLocals()); mv.visitEnd(); cv.visitEnd(); if (debugOutput != null) { log.debug(debugOutput.toString()); } compiledClass = loadExecutable(context, className, cw.toByteArray()); return compiledClass; }
From source file:jpcsp.Allegrex.compiler.CodeBlock.java
License:Open Source License
private Class<IExecutable> compile(CompilerContext context) throws ClassFormatError { Class<IExecutable> compiledClass = null; context.setCodeBlock(this); String className = getInternalClassName(); if (log.isDebugEnabled()) { String functionName = Utilities.getFunctionNameByAddress(getStartAddress()); if (functionName != null) { log.debug(String.format("Compiling %s (%s)", className, functionName)); } else {//from w w w . j av a2 s . c om log.debug(String.format("Compiling %s", className)); } } prepare(context, context.getMethodMaxInstructions()); currentSequence = null; int computeFlag = ClassWriter.COMPUTE_FRAMES; if (context.isAutomaticMaxLocals() || context.isAutomaticMaxStack()) { computeFlag |= ClassWriter.COMPUTE_MAXS; } ClassWriter cw = new ClassWriter(computeFlag); ClassVisitor cv = cw; if (log.isDebugEnabled()) { cv = new CheckClassAdapter(cv); } StringWriter debugOutput = null; if (log.isTraceEnabled()) { debugOutput = new StringWriter(); PrintWriter debugPrintWriter = new PrintWriter(debugOutput); cv = new TraceClassVisitor(cv, debugPrintWriter); } cv.visit(Opcodes.V1_6, Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER, className, null, objectInternalName, interfacesForExecutable); context.startClass(cv); addConstructor(cv); addNonStaticMethods(context, cv); MethodVisitor mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, context.getStaticExecMethodName(), context.getStaticExecMethodDesc(), null, exceptions); mv.visitCode(); context.setMethodVisitor(mv); context.startMethod(); // Jump to the block start if other instructions have been inserted in front if (!codeInstructions.isEmpty() && codeInstructions.getFirst().getAddress() != getStartAddress()) { mv.visitJumpInsn(Opcodes.GOTO, getCodeInstruction(getStartAddress()).getLabel()); } compile(context, mv, codeInstructions); mv.visitMaxs(context.getMaxStack(), context.getMaxLocals()); mv.visitEnd(); for (SequenceCodeInstruction sequenceCodeInstruction : sequenceCodeInstructions) { if (log.isDebugEnabled()) { log.debug("Compiling Sequence " + sequenceCodeInstruction.getMethodName(context)); } currentSequence = sequenceCodeInstruction; mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, sequenceCodeInstruction.getMethodName(context), "()V", null, exceptions); mv.visitCode(); context.setMethodVisitor(mv); context.startSequenceMethod(); compile(context, mv, sequenceCodeInstruction.getCodeSequence().getInstructions()); context.endSequenceMethod(); mv.visitMaxs(context.getMaxStack(), context.getMaxLocals()); mv.visitEnd(); } currentSequence = null; cv.visitEnd(); if (debugOutput != null) { log.trace(debugOutput.toString()); } try { compiledClass = loadExecutable(context, className, cw.toByteArray()); } catch (NullPointerException e) { log.error("Error while compiling " + className + ": " + e); } return compiledClass; }
From source file:kilim.analysis.ClassWeaver.java
License:Open Source License
private void accept(final ClassVisitor cv) { ClassFlow cf = classFlow;//from ww w . j a va 2 s . com // visits header String[] interfaces = toStringArray(cf.interfaces); cv.visit(cf.version, cf.access, cf.name, cf.signature, cf.superName, interfaces); // visits source if (cf.sourceFile != null || cf.sourceDebug != null) { cv.visitSource(cf.sourceFile, cf.sourceDebug); } // visits outer class if (cf.outerClass != null) { cv.visitOuterClass(cf.outerClass, cf.outerMethod, cf.outerMethodDesc); } // visits attributes and annotations int i, n; AnnotationNode an; n = cf.visibleAnnotations == null ? 0 : cf.visibleAnnotations.size(); for (i = 0; i < n; ++i) { an = (AnnotationNode) cf.visibleAnnotations.get(i); an.accept(cv.visitAnnotation(an.desc, true)); } n = cf.invisibleAnnotations == null ? 0 : cf.invisibleAnnotations.size(); for (i = 0; i < n; ++i) { an = (AnnotationNode) cf.invisibleAnnotations.get(i); an.accept(cv.visitAnnotation(an.desc, false)); } n = cf.attrs == null ? 0 : cf.attrs.size(); for (i = 0; i < n; ++i) { cv.visitAttribute((Attribute) cf.attrs.get(i)); } // visits inner classes for (i = 0; i < cf.innerClasses.size(); ++i) { ((InnerClassNode) cf.innerClasses.get(i)).accept(cv); } // visits fields for (i = 0; i < cf.fields.size(); ++i) { ((FieldNode) cf.fields.get(i)).accept(cv); } /* * Mark this class as "processed" by adding a dummy field, so that * we don't weave an already woven file */ cv.visitField(ACC_PUBLIC | ACC_STATIC | ACC_FINAL, WOVEN_FIELD, "Z", "Z", Boolean.TRUE); // visits methods for (i = 0; i < cf.methods.size(); ++i) { MethodFlow m = (MethodFlow) cf.methods.get(i); if (needsWeaving(m)) { MethodWeaver mw = new MethodWeaver(this, m); mw.accept(cv); mw.makeNotWovenMethod(cv, m); } else { m.accept(cv); } } // visits end cv.visitEnd(); }
From source file:mt.swift.Deserializer.java
License:Apache License
private <T> StructureDeserializer<T> compileDeserializer(StructureType type, Class<T> clazz) { ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES); // TODO: compute this ourselves? ClassVisitor writer = classWriter; if (debug) {/* ww w . ja va 2 s . com*/ writer = new CheckClassAdapter(classWriter); // writer = new TraceClassVisitor(writer, new PrintWriter(System.out)); } String targetClassName = Util.getInternalName(clazz); String deserializerClassName = "mt/swift/generated/Deserializer" + clazz.getSimpleName() + "_" + sequence.incrementAndGet(); // class metadata writer.visit(V1_6, ACC_PUBLIC + ACC_SUPER, deserializerClassName, "Ljava/lang/Object;L" + Util.getInternalName(StructureDeserializer.class) + "<L" + targetClassName + ";>;", "java/lang/Object", new String[] { Util.getInternalName(StructureDeserializer.class) }); compileConstructor(writer); compileDeserializeMethod(type, writer, targetClassName, clazz); compileBridgeMethod(writer, targetClassName, deserializerClassName); writer.visitEnd(); if (debug) { ClassReader reader = new ClassReader(classWriter.toByteArray()); reader.accept(new TraceClassVisitor(new PrintWriter(System.out)), 0); } ByteArrayClassLoader loader = new ByteArrayClassLoader(); try { return (StructureDeserializer<T>) loader .defineClass(deserializerClassName.replace('/', '.'), classWriter.toByteArray()).newInstance(); } catch (InstantiationException e) { throw new RuntimeException(e); } catch (IllegalAccessException e) { throw new RuntimeException(e); } }
From source file:mt.swift.Serializer.java
License:Apache License
private StructureSerializer compileSerializer(StructureType type, Class clazz) { ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES); // TODO: compute this ourselves? // ClassWriter classWriter = new ClassWriter(0); // TODO: compute this ourselves? ClassVisitor writer = classWriter; if (debug) {/*from w ww . ja va2s .c o m*/ // writer = new CheckClassAdapter(classWriter); // writer = new TraceClassVisitor(writer, new PrintWriter(System.out)); } String targetClassName = Util.getInternalName(clazz); String serializerClassName = "mt/swift/generated/Serializer" + clazz.getSimpleName() + "_" + sequence.incrementAndGet(); // class metadata writer.visit(V1_6, ACC_PUBLIC + ACC_SUPER, serializerClassName, null, "java/lang/Object", new String[] { Util.getInternalName(StructureSerializer.class) }); compileConstructor(writer); compileSerializeMethod(type, writer, targetClassName, clazz); writer.visitEnd(); if (debug) { ClassReader reader = new ClassReader(classWriter.toByteArray()); reader.accept(new TraceClassVisitor(new PrintWriter(System.out)), 0); } ByteArrayClassLoader loader = new ByteArrayClassLoader(); try { return (StructureSerializer) loader .defineClass(serializerClassName.replace('/', '.'), classWriter.toByteArray()).newInstance(); } catch (InstantiationException e) { throw new RuntimeException(e); } catch (IllegalAccessException e) { throw new RuntimeException(e); } }