Java Assumption类代码示例

import jdk.vm.ci.meta.Assumptions.Assumption; //导入依赖的package包/类
/**
 * Checks the behavior of class loading on {@link Assumption invalidation}. {@code methodName}
 * is compiled and the resulting graph is checked for {@code expectedAssumption}. The code is
 * installed and optionally {@code classToLoad} is loaded. The class is assumed to be an inner
 * class of the test class and the name of the class to load is constructed relative to that.
 *
 * @param methodName the method to compile
 * @param expectedAssumption expected {@link Assumption} instance to find in graph
 * @param classToLoad an optional class to load to trigger an invalidation check
 * @param willInvalidate true if loading {@code classToLoad} should invalidate the method
 */
protected void testAssumption(String methodName, Assumption expectedAssumption, String classToLoad, boolean willInvalidate) {
    ResolvedJavaMethod javaMethod = getResolvedJavaMethod(methodName);

    StructuredGraph graph = parseEager(javaMethod, AllowAssumptions.YES);
    assertTrue(!graph.getAssumptions().isEmpty());
    checkGraph(expectedAssumption, graph);

    CompilationResult compilationResult = compile(javaMethod, graph);
    final InstalledCode installedCode = getBackend().createDefaultInstalledCode(graph.getDebug(), javaMethod, compilationResult);
    assertTrue(installedCode.isValid());
    if (classToLoad != null) {
        String fullName = getClass().getName() + "$" + classToLoad;
        try {
            Class.forName(fullName);
        } catch (ClassNotFoundException e) {
            fail("Can't find class %s", fullName);
        }
        assertTrue(!willInvalidate == installedCode.isValid(), "method should be %s", willInvalidate ? "invalid" : "valid");
    }
}
 

import jdk.vm.ci.meta.Assumptions.Assumption; //导入依赖的package包/类
private void checkForRegisterFinalizeNode(Class<?> cl, boolean shouldContainFinalizer, AllowAssumptions allowAssumptions) {
    StructuredGraph graph = parseAndProcess(cl, allowAssumptions);
    Assert.assertTrue(graph.getNodes().filter(RegisterFinalizerNode.class).count() == (shouldContainFinalizer ? 1 : 0));
    int noFinalizerAssumption = 0;
    Assumptions assumptions = graph.getAssumptions();
    if (assumptions != null) {
        for (Assumption a : assumptions) {
            if (a instanceof NoFinalizableSubclass) {
                noFinalizerAssumption++;
            } else if (a instanceof LeafType) {
                // Need to also allow leaf type assumption instead of no finalizable subclass
                // assumption.
                noFinalizerAssumption++;
            }
        }
    }
    Assert.assertTrue(noFinalizerAssumption == (shouldContainFinalizer ? 0 : 1));
}
 

import jdk.vm.ci.meta.Assumptions.Assumption; //导入依赖的package包/类
@SuppressFBWarnings(value = "EI_EXPOSE_REP2", justification = "caller transfers ownership of `sites`, `targetCode`, `comments`, `methods`, `dataSection`, `dataSectionPatches` and `assumptions`")
public HotSpotCompiledCode(String name, byte[] targetCode, int targetCodeSize, Site[] sites, Assumption[] assumptions, ResolvedJavaMethod[] methods, Comment[] comments, byte[] dataSection,
                int dataSectionAlignment, DataPatch[] dataSectionPatches, boolean isImmutablePIC, int totalFrameSize, StackSlot deoptRescueSlot) {
    this.name = name;
    this.targetCode = targetCode;
    this.targetCodeSize = targetCodeSize;
    this.sites = sites;
    this.assumptions = assumptions;
    this.methods = methods;

    this.comments = comments;
    this.dataSection = dataSection;
    this.dataSectionAlignment = dataSectionAlignment;
    this.dataSectionPatches = dataSectionPatches;
    this.isImmutablePIC = isImmutablePIC;
    this.totalFrameSize = totalFrameSize;
    this.deoptRescueSlot = deoptRescueSlot;

    assert validateFrames();
}
 

import jdk.vm.ci.meta.Assumptions.Assumption; //导入依赖的package包/类
public HotSpotCompiledCode(String name, byte[] targetCode, int targetCodeSize, Site[] sites, Assumption[] assumptions, ResolvedJavaMethod[] methods, Comment[] comments, byte[] dataSection,
                int dataSectionAlignment, DataPatch[] dataSectionPatches, boolean isImmutablePIC, int totalFrameSize, StackSlot deoptRescueSlot) {
    this.name = name;
    this.targetCode = targetCode;
    this.targetCodeSize = targetCodeSize;
    this.sites = sites;
    this.assumptions = assumptions;
    this.methods = methods;

    this.comments = comments;
    this.dataSection = dataSection;
    this.dataSectionAlignment = dataSectionAlignment;
    this.dataSectionPatches = dataSectionPatches;
    this.isImmutablePIC = isImmutablePIC;
    this.totalFrameSize = totalFrameSize;
    this.deoptRescueSlot = deoptRescueSlot;

    assert validateFrames();
}
 

import jdk.vm.ci.meta.Assumptions.Assumption; //导入依赖的package包/类
/**
 * Checks the behavior of class loading on {@link Assumption invalidation}. {@code methodName}
 * is compiled and the resulting graph is checked for {@code expectedAssumption}. The code is
 * installed and optionally {@code classToLoad} is loaded. The class is assumed to be an inner
 * class of the test class and the name of the class to load is constructed relative to that.
 *
 * @param methodName the method to compile
 * @param expectedAssumption expected {@link Assumption} instance to find in graph
 * @param classToLoad an optional class to load to trigger an invalidation check
 * @param willInvalidate true if loading {@code classToLoad} should invalidate the method
 */
protected void testAssumption(String methodName, Assumption expectedAssumption, String classToLoad, boolean willInvalidate) {
    ResolvedJavaMethod javaMethod = getResolvedJavaMethod(methodName);

    StructuredGraph graph = parseEager(javaMethod, AllowAssumptions.YES);
    assertTrue(!graph.getAssumptions().isEmpty());
    checkGraph(expectedAssumption, graph);

    CompilationResult compilationResult = compile(javaMethod, graph);
    final InstalledCode installedCode = getBackend().createDefaultInstalledCode(javaMethod, compilationResult);
    assertTrue(installedCode.isValid());
    if (classToLoad != null) {
        String fullName = getClass().getName() + "$" + classToLoad;
        try {
            Class.forName(fullName);
        } catch (ClassNotFoundException e) {
            fail("Can't find class %s", fullName);
        }
        assertTrue(!willInvalidate == installedCode.isValid(), "method should be %s", willInvalidate ? "invalid" : "valid");
    }
}
 

import jdk.vm.ci.meta.Assumptions.Assumption; //导入依赖的package包/类
protected void checkGraph(Assumption expectedAssumption, StructuredGraph graph) {
    boolean found = false;
    for (Assumption a : graph.getAssumptions()) {
        if (expectedAssumption.equals(a)) {
            found = true;
        }
    }
    assertTrue(found, "Can't find assumption %s", expectedAssumption);
}
 

import jdk.vm.ci.meta.Assumptions.Assumption; //导入依赖的package包/类
public HotSpotCompiledNmethod(String name, byte[] targetCode, int targetCodeSize, Site[] sites, Assumption[] assumptions, ResolvedJavaMethod[] methods, Comment[] comments, byte[] dataSection,
                int dataSectionAlignment, DataPatch[] dataSectionPatches, boolean isImmutablePIC, int totalFrameSize, StackSlot deoptRescueSlot, HotSpotResolvedJavaMethod method, int entryBCI,
                int id, long jvmciEnv, boolean hasUnsafeAccess) {
    super(name, targetCode, targetCodeSize, sites, assumptions, methods, comments, dataSection, dataSectionAlignment, dataSectionPatches, isImmutablePIC, totalFrameSize, deoptRescueSlot);
    this.method = method;
    this.entryBCI = entryBCI;
    this.id = id;
    this.jvmciEnv = jvmciEnv;
    this.hasUnsafeAccess = hasUnsafeAccess;
}
 

import jdk.vm.ci.meta.Assumptions.Assumption; //导入依赖的package包/类
public HotSpotCompiledCode finish(HotSpotResolvedJavaMethod method) {
    int id = method.allocateCompileId(0);
    byte[] finishedCode = code.finish();
    Site[] finishedSites = sites.toArray(new Site[0]);
    byte[] finishedData = data.finish();
    DataPatch[] finishedDataPatches = dataPatches.toArray(new DataPatch[0]);
    return new HotSpotCompiledNmethod(method.getName(), finishedCode, finishedCode.length, finishedSites, new Assumption[0], new ResolvedJavaMethod[]{method}, new Comment[0], finishedData, 16,
                    finishedDataPatches, false, frameSize, deoptRescue, method, 0, id, 0L, false);
}
 

import jdk.vm.ci.meta.Assumptions.Assumption; //导入依赖的package包/类
static void processAssumption(Set<Assumption> newAssumptions, Assumption assumption, List<AssumptionValidAssumption> manual) {
    if (assumption != null) {
        if (assumption instanceof AssumptionValidAssumption) {
            AssumptionValidAssumption assumptionValidAssumption = (AssumptionValidAssumption) assumption;
            manual.add(assumptionValidAssumption);
        } else {
            newAssumptions.add(assumption);
        }
    }
}
 

import jdk.vm.ci.meta.Assumptions.Assumption; //导入依赖的package包/类
/**
 * Sets the assumptions made during compilation.
 */
public void setAssumptions(Assumption[] assumptions) {
    this.assumptions = assumptions;
}
 

import jdk.vm.ci.meta.Assumptions.Assumption; //导入依赖的package包/类
@Override
protected void checkGraph(Assumption expectedAssumption, StructuredGraph graph) {
    super.checkGraph(expectedAssumption, graph);
    assertTrue(graph.isTrivial());
}
 

import jdk.vm.ci.meta.Assumptions.Assumption; //导入依赖的package包/类
protected void testAssumptionInvalidate(String methodName, Assumption expected, String classToLoad) {
    testAssumption(methodName, expected, classToLoad, true);
}
 

import jdk.vm.ci.meta.Assumptions.Assumption; //导入依赖的package包/类
public static HotSpotCompiledCode createCompiledCode(CodeCacheProvider codeCache, ResolvedJavaMethod method, HotSpotCompilationRequest compRequest, CompilationResult compResult) {
    String name = compResult.getName();

    byte[] targetCode = compResult.getTargetCode();
    int targetCodeSize = compResult.getTargetCodeSize();

    Site[] sites = getSortedSites(codeCache, compResult);

    Assumption[] assumptions = compResult.getAssumptions();

    ResolvedJavaMethod[] methods = compResult.getMethods();

    List<CodeAnnotation> annotations = compResult.getAnnotations();
    Comment[] comments = new Comment[annotations.size()];
    if (!annotations.isEmpty()) {
        for (int i = 0; i < comments.length; i++) {
            CodeAnnotation annotation = annotations.get(i);
            String text;
            if (annotation instanceof CodeComment) {
                CodeComment codeComment = (CodeComment) annotation;
                text = codeComment.value;
            } else if (annotation instanceof JumpTable) {
                JumpTable jumpTable = (JumpTable) annotation;
                text = "JumpTable [" + jumpTable.low + " .. " + jumpTable.high + "]";
            } else {
                text = annotation.toString();
            }
            comments[i] = new Comment(annotation.position, text);
        }
    }

    DataSection data = compResult.getDataSection();
    byte[] dataSection = new byte[data.getSectionSize()];

    ByteBuffer buffer = ByteBuffer.wrap(dataSection).order(ByteOrder.nativeOrder());
    Builder<DataPatch> patchBuilder = Stream.builder();
    data.buildDataSection(buffer, vmConstant -> {
        patchBuilder.accept(new DataPatch(buffer.position(), new ConstantReference(vmConstant)));
    });

    int dataSectionAlignment = data.getSectionAlignment();
    DataPatch[] dataSectionPatches = patchBuilder.build().toArray(len -> new DataPatch[len]);

    int totalFrameSize = compResult.getTotalFrameSize();
    StackSlot customStackArea = compResult.getCustomStackArea();
    boolean isImmutablePIC = compResult.isImmutablePIC();

    if (method instanceof HotSpotResolvedJavaMethod) {
        HotSpotResolvedJavaMethod hsMethod = (HotSpotResolvedJavaMethod) method;
        int entryBCI = compResult.getEntryBCI();
        boolean hasUnsafeAccess = compResult.hasUnsafeAccess();

        int id;
        long jvmciEnv;
        if (compRequest != null) {
            id = compRequest.getId();
            jvmciEnv = compRequest.getJvmciEnv();
        } else {
            id = hsMethod.allocateCompileId(entryBCI);
            jvmciEnv = 0L;
        }
        return new HotSpotCompiledNmethod(name, targetCode, targetCodeSize, sites, assumptions, methods, comments, dataSection, dataSectionAlignment, dataSectionPatches, isImmutablePIC,
                        totalFrameSize, customStackArea, hsMethod, entryBCI, id, jvmciEnv, hasUnsafeAccess);
    } else {
        return new HotSpotCompiledCode(name, targetCode, targetCodeSize, sites, assumptions, methods, comments, dataSection, dataSectionAlignment, dataSectionPatches, isImmutablePIC,
                        totalFrameSize, customStackArea);
    }
}
 

import jdk.vm.ci.meta.Assumptions.Assumption; //导入依赖的package包/类
@Test(expected = JVMCIError.class)
public void testInvalidAssumption() {
    installEmptyCode(new Site[0], new Assumption[]{new InvalidAssumption()}, new Comment[0], 16, new DataPatch[0], null);
}
 

import jdk.vm.ci.meta.Assumptions.Assumption; //导入依赖的package包/类
@Test(expected = JVMCIError.class)
public void testInvalidAlignment() {
    installEmptyCode(new Site[0], new Assumption[0], new Comment[0], 7, new DataPatch[0], null);
}