Java ResolvedJavaMethod.getCode方法代码示例

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
/**
 * Starts a new group of graphs with the given name, short name and method byte code index (BCI)
 * as properties.
 */
@Override
public void beginGroup(DebugContext debug, String name, String shortName, ResolvedJavaMethod method, int bci, Map<Object, Object> properties) {
    beginGroup();
    beginProperties();
    printProperty("name", name);
    if (properties != null) {
        for (Entry<Object, Object> entry : properties.entrySet()) {
            printProperty(entry.getKey().toString(), entry.getValue().toString());
        }
    }
    endProperties();
    beginMethod(name, shortName, bci);
    if (method != null && method.getCode() != null) {
        printBytecodes(new BytecodeDisassembler(false).disassemble(method));
    }
    endMethod();
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
/**
 * Tries to inline {@code targetMethod} if it is an instance field accessor. This avoids the
 * overhead of creating and using a nested {@link BytecodeParser} object.
 */
private boolean tryFastInlineAccessor(ValueNode[] args, ResolvedJavaMethod targetMethod) {
    byte[] bytecode = targetMethod.getCode();
    if (bytecode != null && bytecode.length == ACCESSOR_BYTECODE_LENGTH &&
                    Bytes.beU1(bytecode, 0) == ALOAD_0 &&
                    Bytes.beU1(bytecode, 1) == GETFIELD) {
        int b4 = Bytes.beU1(bytecode, 4);
        if (b4 >= IRETURN && b4 <= ARETURN) {
            int cpi = Bytes.beU2(bytecode, 2);
            JavaField field = targetMethod.getConstantPool().lookupField(cpi, targetMethod, GETFIELD);
            if (field instanceof ResolvedJavaField) {
                ValueNode receiver = invocationPluginReceiver.init(targetMethod, args).get();
                ResolvedJavaField resolvedField = (ResolvedJavaField) field;
                genGetField(resolvedField, receiver);
                notifyBeforeInline(targetMethod);
                printInlining(targetMethod, targetMethod, true, "inline accessor method (bytecode parsing)");
                notifyAfterInline(targetMethod);
                return true;
            }
        }
    }
    return false;
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
/**
 * @see ResolvedJavaMethod#getCode()
 */
@Test
public void getCodeTest() {
    for (Map.Entry<Method, ResolvedJavaMethod> e : methods.entrySet()) {
        ResolvedJavaMethod m = e.getValue();
        byte[] code = m.getCode();
        if (code == null) {
            assertTrue(m.getCodeSize() == 0);
        } else {
            if (m.isAbstract()) {
                assertTrue(code.length == 0);
            } else if (!m.isNative()) {
                assertTrue(code.length > 0);
            }
        }
    }
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
private static boolean checkSize(ResolvedJavaMethod method, ValueNode[] args, StructuredGraph graph) {
    int bonus = 1;
    for (ValueNode v : args) {
        if (v.isConstant()) {
            bonus++;
        }
    }
    return method.getCode().length <= TrivialInliningSize.getValue(graph.getOptions()) * bonus;
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
@Test
public void testGetBytecodes() throws NoSuchMethodException {
    Method reflectionMethod = String.class.getDeclaredMethod("hashCode");
    ResolvedJavaMethod method = metaAccess.lookupJavaMethod(reflectionMethod);

    /*
     * ResolvedJavaMethod provides all information that you want about a method, for example,
     * the bytecodes.
     */
    byte[] bytecodes = method.getCode();

    /*
     * BytecodeDisassembler shows you how to iterate bytecodes, how to access type information,
     * and more.
     */
    String disassembly = new BytecodeDisassembler().disassemble(method);

    /*
     * We don't want test cases to print any output, so we check the validity of the output
     * instead.
     */
    Pattern disassemblyLineRE = Pattern.compile(" *\\d+: [a-z][\\w_]+");
    for (String line : disassembly.split("\\n")) {
        Assert.assertTrue(line, disassemblyLineRE.matcher(line).find());
    }
    Assert.assertTrue(bytecodes.length > 0);
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
private static byte getByteCode(Call call) {
    ResolvedJavaMethod m = call.debugInfo.getBytecodePosition().getMethod();
    int callPosition = call.debugInfo.getBytecodePosition().getBCI();
    byte[] code = m.getCode();
    return code[callPosition];
}
 

import jdk.vm.ci.meta.ResolvedJavaMethod; //导入方法依赖的package包/类
@Override
public byte[] methodCode(ResolvedJavaMethod method) {
    return method.getCode();
}