Examples with CompiledMethod org.jikesrvm.compilers.common.CompiledMethod used on opensource projects

Example 31 with CompiledMethod

use of org.jikesrvm.compilers.common.CompiledMethod in project JikesRVM by JikesRVM.

the class MagicTest method recompileTestMethodOnOptLevel.

public void recompileTestMethodOnOptLevel(int optLevel) {
    int methodId = RuntimeCompiler.recompileWithOpt(testMethodForGetCompilerLevel, optLevel);
    assertThat(methodId, not(equalTo(-1)));
    CompiledMethod cm = testMethodForGetCompilerLevel.getCurrentCompiledMethod();
    assertThat(cm.getCompilerType(), is(OPT));
    assertThat(((OptCompiledMethod) cm).getOptLevel(), is(optLevel));
}

Example 32 with CompiledMethod

use of org.jikesrvm.compilers.common.CompiledMethod in project JikesRVM by JikesRVM.

the class DefaultInlineOracle method shouldInline.

@Override
public InlineDecision shouldInline(final CompilationState state) {
    final OptOptions opts = state.getOptions();
    final boolean verbose = opts.PRINT_DETAILED_INLINE_REPORT;
    if (!opts.INLINE) {
        return NO("inlining not enabled");
    }
    final RVMMethod staticCallee = state.obtainTarget();
    final NormalMethod rootMethod = state.getRootMethod();
    final RVMMethod caller = state.getMethod();
    final int bcIndex = state.getRealBytecodeIndex();
    if (verbose)
        VM.sysWriteln("Begin inline decision for " + "<" + caller + "," + bcIndex + "," + staticCallee + ">");
    // Stage 1: We definitely don't inline certain methods
    if (!state.isInvokeInterface()) {
        if (staticCallee.isNative()) {
            reportUnguardedDecisionIfVerbose("NO: native method", verbose);
            return NO("native method");
        }
        if (hasNoInlinePragma(staticCallee, state)) {
            reportUnguardedDecisionIfVerbose("NO: pragmaNoInline", verbose);
            return NO("pragmaNoInline");
        }
        // traces (see StackTrace).
        if (staticCallee.isObjectInitializer() && staticCallee.getDeclaringClass().isAssignableToThrowable()) {
            reportUnguardedDecisionIfVerbose("NO: constructor of class assignable to throwable", verbose);
            return NO("constructor of class assignable to throwable");
        }
    }
    // at worse replace one call instruction with another one).
    if (!state.isInvokeInterface() && !staticCallee.isAbstract()) {
        // above test passes
        if (state.getHasPreciseTarget() || !needsGuard(staticCallee)) {
            // call is guardless
            int inlinedSizeEstimate = inlinedSizeEstimate((NormalMethod) staticCallee, state);
            if (inlinedSizeEstimate < opts.INLINE_MAX_ALWAYS_INLINE_TARGET_SIZE) {
                // inlining is desirable
                if (!state.getSequence().containsMethod(staticCallee)) {
                    // not recursive
                    reportUnguardedDecisionIfVerbose("YES: trivial guardless inline", verbose);
                    return YES(staticCallee, "trivial inline");
                }
            }
            if (hasInlinePragma(staticCallee, state)) {
                // inlining is desirable
                if (!state.getSequence().containsMethod(staticCallee)) {
                    // not recursive
                    reportUnguardedDecisionIfVerbose("YES: pragma inline", verbose);
                    return YES(staticCallee, "pragma inline");
                }
            }
        }
    }
    if (opts.getOptLevel() == 0) {
        // at opt level 0, trivial unguarded inlines are the only kind we consider
        reportUnguardedDecisionIfVerbose("NO: only do trivial inlines at O0", verbose);
        return NO("Only do trivial inlines at O0");
    }
    // than faster boot image compilation.
    if (VM.runningVM && rootMethod.inlinedSizeEstimate() > opts.INLINE_MASSIVE_METHOD_SIZE) {
        reportUnguardedDecisionIfVerbose("NO: only do trivial inlines into massive methods when the VM is running", verbose);
        return NO("Root method is massive; no non-trivial inlines");
    }
    // Stage 3: Determine based on profile data and static information
    // what are the possible targets of this call.
    WeightedCallTargets targets = null;
    boolean purelyStatic = true;
    if (Controller.dcgAvailable() && Controller.options.ADAPTIVE_INLINING) {
        targets = Controller.dcg.getCallTargets(caller, bcIndex);
        if (targets != null) {
            reportProfilingIfVerbose("Found profile data", verbose);
            purelyStatic = false;
            WeightedCallTargets filteredTargets = targets.filter(staticCallee, state.getHasPreciseTarget());
            if (targets != filteredTargets) {
                reportProfilingIfVerbose("Profiled callees filtered based on static information", verbose);
                targets = filteredTargets;
                if (targets == null) {
                    reportProfilingIfVerbose("After filterting no profile data...", verbose);
                    // After filtering, no matching profile data, fall back to
                    // static information to avoid degradations
                    targets = WeightedCallTargets.create(staticCallee, 0);
                    purelyStatic = true;
                }
            }
        }
    }
    // we are inspecting it to determine how/whether to do the inline guard.
    synchronized (RVMClass.classLoadListener) {
        boolean guardOverrideOnStaticCallee = false;
        if (targets == null) {
            reportUnguardedDecisionIfVerbose("no profile data", verbose);
            // be able to share all the decision making logic.
            if (state.isInvokeInterface()) {
                if (opts.INLINE_GUARDED_INTERFACES) {
                    RVMMethod singleImpl = InterfaceHierarchy.getUniqueImplementation(staticCallee);
                    if (singleImpl != null && hasBody(singleImpl)) {
                        if (verbose) {
                            VM.sysWriteln("\tFound a single implementation " + singleImpl + " of an interface method " + staticCallee);
                        }
                        targets = WeightedCallTargets.create(singleImpl, 0);
                        guardOverrideOnStaticCallee = true;
                    }
                }
            } else {
                // invokestatic, invokevirtual, invokespecial
                if (staticCallee.isAbstract()) {
                    // look for single non-abstract implementation of the abstract method
                    RVMClass klass = staticCallee.getDeclaringClass();
                    while (true) {
                        RVMClass[] subClasses = klass.getSubClasses();
                        // multiple subclasses => multiple targets
                        if (subClasses.length != 1)
                            break;
                        RVMMethod singleImpl = subClasses[0].findDeclaredMethod(staticCallee.getName(), staticCallee.getDescriptor());
                        if (singleImpl != null && !singleImpl.isAbstract()) {
                            // found something
                            reportProfilingIfVerbose("single impl of abstract method", verbose);
                            targets = WeightedCallTargets.create(singleImpl, 0);
                            guardOverrideOnStaticCallee = true;
                            break;
                        }
                        // keep crawling down the hierarchy
                        klass = subClasses[0];
                    }
                } else {
                    targets = WeightedCallTargets.create(staticCallee, 0);
                }
            }
        }
        // If there is a precise target, then targets contains exactly that target method.
        if (targets == null)
            return NO("No potential targets identified");
        // Stage 4: We have one or more targets.  Determine what if anything should be done with them.
        final ArrayList<RVMMethod> methodsToInline = new ArrayList<RVMMethod>();
        final ArrayList<Boolean> methodsNeedGuard = new ArrayList<Boolean>();
        final double callSiteWeight = targets.totalWeight();
        // real closures anyone?
        final boolean goosc = guardOverrideOnStaticCallee;
        // real closures anyone?
        final boolean ps = purelyStatic;
        targets.visitTargets(new WeightedCallTargets.Visitor() {

            @Override
            public void visit(RVMMethod callee, double weight) {
                if (hasBody(callee)) {
                    reportInitialProfileState(verbose, callee, weight);
                    // Don't inline recursively and respect no inline pragmas
                    InlineSequence seq = state.getSequence();
                    if (seq.containsMethod(callee)) {
                        reportSelectionIfVerbose("Reject: recursive", verbose);
                        return;
                    }
                    if (hasNoInlinePragma(callee, state)) {
                        reportSelectionIfVerbose("Reject: noinline pragma", verbose);
                        return;
                    }
                    // more or less figure out the guard situation early -- impacts size estimate.
                    boolean needsGuard = !state.getHasPreciseTarget() && (staticCallee != callee || needsGuard(staticCallee));
                    if (needsGuard && isForbiddenSpeculation(state.getRootMethod(), callee)) {
                        reportSelectionIfVerbose("Reject: forbidden speculation", verbose);
                        return;
                    }
                    boolean currentlyFinal = (goosc || (staticCallee == callee)) && isCurrentlyFinal(callee, !opts.guardWithClassTest());
                    boolean preEx = needsGuard && state.getIsExtant() && opts.INLINE_PREEX && currentlyFinal;
                    if (needsGuard && !preEx) {
                        if (!opts.INLINE_GUARDED) {
                            reportSelectionIfVerbose("Reject: guarded inlining disabled", verbose);
                            return;
                        }
                        if (!currentlyFinal && ps) {
                            reportSelectionIfVerbose("Reject: multiple targets and no profile data", verbose);
                            return;
                        }
                    }
                    // Estimate cost of performing this inlining action.
                    // Includes cost of guard & off-branch call if they are going to be generated.
                    boolean decideYes = false;
                    if (hasInlinePragma(callee, state)) {
                        reportSelectionIfVerbose("Select: pragma inline", verbose);
                        decideYes = true;
                    } else {
                        // Preserve previous inlining decisions
                        // Not the best thing in the world due to phase shifts, but
                        // it does buy some degree of stability. So, it is probably the lesser
                        // of two evils.
                        CompiledMethod prev = state.getRootMethod().getCurrentCompiledMethod();
                        if (prev != null && prev.getCompilerType() == CompiledMethod.OPT) {
                            if (((OptCompiledMethod) prev).getMCMap().hasInlinedEdge(caller, bcIndex, callee)) {
                                reportSelectionIfVerbose("Select: Previously inlined", verbose);
                                decideYes = true;
                            }
                        }
                        if (!decideYes) {
                            int inlinedSizeEstimate = inlinedSizeEstimate((NormalMethod) callee, state);
                            int cost = inliningActionCost(inlinedSizeEstimate, needsGuard, preEx, opts);
                            int maxCost = opts.INLINE_MAX_TARGET_SIZE;
                            if (callSiteWeight > Controller.options.INLINE_AI_SEED_MULTIPLIER) {
                                // real profile data with enough samples for us to trust it.
                                // Use weight and shape of call site distribution to compute
                                // a higher maxCost.
                                double fractionOfSample = weight / callSiteWeight;
                                if (needsGuard && fractionOfSample < opts.INLINE_AI_MIN_CALLSITE_FRACTION) {
                                    // This call accounts for less than INLINE_AI_MIN_CALLSITE_FRACTION
                                    // of the profiled targets at this call site.
                                    // It is highly unlikely to be profitable to inline it.
                                    reportSelectionIfVerbose("Reject: less than INLINE_AI_MIN_CALLSITE_FRACTION of distribution", verbose);
                                    maxCost = 0;
                                } else {
                                    if (cost > maxCost) {
                                        /* We're going to increase the maximum callee size (maxCost) we're willing
                       * to inline based on how "hot" (what % of the total weight in the
                       * dynamic call graph) the edge is.
                       */
                                        double adjustedWeight = AdaptiveInlining.adjustedWeight(weight);
                                        if (adjustedWeight > Controller.options.INLINE_AI_HOT_CALLSITE_THRESHOLD) {
                                            /* A truly hot edge; use the max allowable callee size */
                                            maxCost = opts.INLINE_AI_MAX_TARGET_SIZE;
                                        } else {
                                            /* A warm edge, we will use a value between the static default and the max allowable.
                         * The code below simply does a linear interpolation between 2x static default
                         * and max allowable.
                         * Other alternatives would be to do a log interpolation or some other step function.
                         */
                                            int range = opts.INLINE_AI_MAX_TARGET_SIZE - 2 * opts.INLINE_MAX_TARGET_SIZE;
                                            double slope = (range) / Controller.options.INLINE_AI_HOT_CALLSITE_THRESHOLD;
                                            int scaledAdj = (int) (slope * adjustedWeight);
                                            maxCost += opts.INLINE_MAX_TARGET_SIZE + scaledAdj;
                                        }
                                    }
                                }
                            }
                            // Somewhat bogus, but if we get really deeply inlined we start backing off.
                            int curDepth = state.getInlineDepth();
                            if (curDepth > opts.INLINE_MAX_INLINE_DEPTH) {
                                maxCost /= (curDepth - opts.INLINE_MAX_INLINE_DEPTH + 1);
                            }
                            decideYes = cost <= maxCost;
                            if (decideYes) {
                                reportSelectionIfVerbose("Accept: cost of " + cost + " was below threshold " + maxCost, verbose);
                            } else {
                                reportSelectionIfVerbose("Reject: cost of " + cost + " was above threshold " + maxCost, verbose);
                            }
                        }
                    }
                    if (decideYes) {
                        // Ok, we're going to inline it.
                        // Record that and also whether or not we think it needs a guard.
                        methodsToInline.add(callee);
                        if (preEx) {
                            ClassLoadingDependencyManager cldm = (ClassLoadingDependencyManager) RVMClass.classLoadListener;
                            if (ClassLoadingDependencyManager.TRACE || ClassLoadingDependencyManager.DEBUG) {
                                cldm.report("PREEX_INLINE: Inlined " + callee + " into " + caller);
                            }
                            cldm.addNotOverriddenDependency(callee, state.getCompiledMethod());
                            if (goosc) {
                                cldm.addNotOverriddenDependency(staticCallee, state.getCompiledMethod());
                            }
                            methodsNeedGuard.add(Boolean.FALSE);
                        } else {
                            methodsNeedGuard.add(needsGuard);
                        }
                    }
                }
            }

            private void reportInitialProfileState(final boolean verbose, RVMMethod callee, double weight) {
                double adjustedWeight = AdaptiveInlining.adjustedWeight(weight);
                String sampleString = " samples (";
                if (Double.isNaN(adjustedWeight)) {
                    sampleString += "no DCG available)";
                } else {
                    sampleString += (100 * adjustedWeight) + "%)";
                }
                reportProfilingIfVerbose("Evaluating target " + callee + " with " + weight + sampleString, verbose);
            }
        });
        // Stage 5: Choose guards and package up the results in an InlineDecision object
        if (methodsToInline.isEmpty()) {
            InlineDecision d = NO("No desirable targets");
            reportGuardedDecisionIfVerbose(d, verbose);
            return d;
        } else if (methodsToInline.size() == 1) {
            RVMMethod target = methodsToInline.get(0);
            boolean needsGuard = methodsNeedGuard.get(0);
            if (needsGuard) {
                if ((guardOverrideOnStaticCallee || target == staticCallee) && isCurrentlyFinal(target, !opts.guardWithClassTest())) {
                    InlineDecision d = guardedYES(target, chooseGuard(caller, target, staticCallee, state, true), "Guarded inline of single static target");
                    /*
             * Determine if it is allowable to put an OSR point in the failed case of
             * the guarded inline instead of generating a real call instruction.
             * There are several conditions that must be met for this to be allowable:
             *   (1) OSR guarded inlining and recompilation must both be enabled
             *   (2) The current context must be an interruptible method
             *   (3) The application must be started.  This is a rough proxy for the VM
             *       being fully booted so we can actually get through the OSR process.
             *       Note: One implication of this requirement is that we will
             *       never put an OSR on an off-branch of a guarded inline in bootimage
             *       code.
             */
                    if (opts.OSR_GUARDED_INLINING && Controller.options.ENABLE_RECOMPILATION && caller.isInterruptible() && OptimizingCompiler.getAppStarted()) {
                        if (VM.VerifyAssertions)
                            VM._assert(VM.runningVM);
                        d.setOSRTestFailed();
                    }
                    if (verbose)
                        VM.sysWriteln("\tDecide: " + d);
                    return d;
                } else {
                    InlineDecision d = guardedYES(target, chooseGuard(caller, target, staticCallee, state, false), "Guarded inlining of one potential target");
                    reportGuardedDecisionIfVerbose(d, verbose);
                    return d;
                }
            } else {
                InlineDecision d = YES(target, "Unique and desirable target");
                reportGuardedDecisionIfVerbose(d, verbose);
                return d;
            }
        } else {
            RVMMethod[] methods = new RVMMethod[methodsNeedGuard.size()];
            byte[] guards = new byte[methods.length];
            int idx = 0;
            Iterator<RVMMethod> methodIterator = methodsToInline.iterator();
            Iterator<Boolean> guardIterator = methodsNeedGuard.iterator();
            while (methodIterator.hasNext()) {
                RVMMethod target = methodIterator.next();
                boolean needsGuard = guardIterator.next();
                if (VM.VerifyAssertions) {
                    if (!needsGuard) {
                        VM.sysWriteln("Error, inlining for " + methodsToInline.size() + " targets");
                        VM.sysWriteln("Inlining into " + rootMethod + " at bytecode index " + bcIndex);
                        VM.sysWriteln("Method: " + target + " doesn't need a guard");
                        for (int i = 0; i < methodsToInline.size(); i++) {
                            VM.sysWriteln("  Method " + i + ": " + methodsToInline.get(i));
                            VM.sysWriteln("  NeedsGuard: " + methodsNeedGuard.get(i));
                        }
                        VM._assert(VM.NOT_REACHED);
                    }
                }
                methods[idx] = target;
                guards[idx] = chooseGuard(caller, target, staticCallee, state, false);
                idx++;
            }
            InlineDecision d = guardedYES(methods, guards, "Inline multiple targets");
            reportGuardedDecisionIfVerbose(d, verbose);
            return d;
        }
    }
}

Example 33 with CompiledMethod

use of org.jikesrvm.compilers.common.CompiledMethod in project JikesRVM by JikesRVM.

the class Reflection method outOfLineInvoke.

private static Object outOfLineInvoke(RVMMethod method, Object thisArg, Object[] otherArgs, boolean isNonvirtual) {
    // the class must be initialized before we can invoke a method
    // 
    RVMClass klass = method.getDeclaringClass();
    if (!klass.isInitialized()) {
        RuntimeEntrypoints.initializeClassForDynamicLink(klass);
    }
    // remember return type
    // Determine primitive type-ness early to avoid call (possible yield)
    // later while refs are possibly being held in int arrays.
    // 
    TypeReference returnType = method.getReturnType();
    boolean returnIsPrimitive = returnType.isPrimitiveType();
    // decide how to pass parameters
    // 
    int triple = 0;
    if (VM.BuildForIA32) {
        triple = org.jikesrvm.ia32.MachineReflection.countParameters(method);
    } else {
        if (VM.VerifyAssertions)
            VM._assert(VM.BuildForPowerPC);
        triple = org.jikesrvm.ppc.MachineReflection.countParameters(method);
    }
    int gprs = triple & REFLECTION_GPRS_MASK;
    WordArray GPRs = (gprs > 0) ? WordArray.create(gprs) : emptyWordArray;
    int fprs = (triple >> REFLECTION_GPRS_BITS) & 0x1F;
    double[] FPRs = (fprs > 0) ? new double[fprs] : emptyDoubleArray;
    byte[] FPRmeta;
    if (BuildForSSE2Full) {
        FPRmeta = (fprs > 0) ? new byte[fprs] : emptyByteArray;
    } else {
        FPRmeta = null;
    }
    int spillCount = triple >> (REFLECTION_GPRS_BITS + REFLECTION_FPRS_BITS);
    WordArray Spills = (spillCount > 0) ? WordArray.create(spillCount) : emptyWordArray;
    if (firstUse) {
        // force dynamic link sites in unwrappers to get resolved,
        // before disabling gc.
        // this is a bit silly, but I can't think of another way to do it [--DL]
        unwrapBoolean(wrapBoolean(0));
        unwrapByte(wrapByte((byte) 0));
        unwrapChar(wrapChar((char) 0));
        unwrapShort(wrapShort((short) 0));
        unwrapInt(wrapInt(0));
        unwrapLong(wrapLong(0));
        unwrapFloat(wrapFloat(0));
        unwrapDouble(wrapDouble(0));
        firstUse = false;
    }
    // choose actual method to be called
    // 
    RVMMethod targetMethod;
    if (isNonvirtual || method.isStatic() || method.isObjectInitializer()) {
        targetMethod = method;
    } else {
        RVMClass C = Magic.getObjectType(thisArg).asClass();
        if (!method.getDeclaringClass().isInterface()) {
            int tibIndex = method.getOffset().toInt() >>> LOG_BYTES_IN_ADDRESS;
            targetMethod = C.getVirtualMethods()[tibIndex - TIB_FIRST_VIRTUAL_METHOD_INDEX];
        } else {
            RVMClass I = method.getDeclaringClass();
            if (!RuntimeEntrypoints.isAssignableWith(I, C))
                throw new IncompatibleClassChangeError();
            targetMethod = C.findVirtualMethod(method.getName(), method.getDescriptor());
            if (targetMethod == null)
                throw new IncompatibleClassChangeError();
        }
    }
    // getCurrentCompiledMethod is synchronized but Unpreemptible.
    // Therefore there are no possible yieldpoints from the time
    // the compiledMethod is loaded in getCurrentCompiledMethod
    // to when we disable GC below.
    // We can't allow any yieldpoints between these points because of the way in which
    // we GC compiled code.  Once a method is marked as obsolete, if it is not
    // executing on the stack of some thread, then the process of collecting the
    // code and meta-data might be initiated.
    targetMethod.compile();
    CompiledMethod cm = targetMethod.getCurrentCompiledMethod();
    while (cm == null) {
        targetMethod.compile();
        cm = targetMethod.getCurrentCompiledMethod();
    }
    RVMThread.getCurrentThread().disableYieldpoints();
    CodeArray code = cm.getEntryCodeArray();
    if (VM.BuildForIA32) {
        org.jikesrvm.ia32.MachineReflection.packageParameters(method, thisArg, otherArgs, GPRs, FPRs, FPRmeta, Spills);
    } else {
        if (VM.VerifyAssertions)
            VM._assert(VM.BuildForPowerPC);
        org.jikesrvm.ppc.MachineReflection.packageParameters(method, thisArg, otherArgs, GPRs, FPRs, FPRmeta, Spills);
    }
    // critical: no yieldpoints/GCpoints between here and the invoke of code!
    // We may have references hidden in the GPRs and Spills arrays!!!
    RVMThread.getCurrentThread().enableYieldpoints();
    if (!returnIsPrimitive) {
        return Magic.invokeMethodReturningObject(code, GPRs, FPRs, FPRmeta, Spills);
    }
    if (returnType.isVoidType()) {
        Magic.invokeMethodReturningVoid(code, GPRs, FPRs, FPRmeta, Spills);
        return null;
    }
    if (returnType.isBooleanType()) {
        int x = Magic.invokeMethodReturningInt(code, GPRs, FPRs, FPRmeta, Spills);
        return x == 1;
    }
    if (returnType.isByteType()) {
        int x = Magic.invokeMethodReturningInt(code, GPRs, FPRs, FPRmeta, Spills);
        return (byte) x;
    }
    if (returnType.isShortType()) {
        int x = Magic.invokeMethodReturningInt(code, GPRs, FPRs, FPRmeta, Spills);
        return (short) x;
    }
    if (returnType.isCharType()) {
        int x = Magic.invokeMethodReturningInt(code, GPRs, FPRs, FPRmeta, Spills);
        return (char) x;
    }
    if (returnType.isIntType()) {
        return Magic.invokeMethodReturningInt(code, GPRs, FPRs, FPRmeta, Spills);
    }
    if (returnType.isLongType()) {
        return Magic.invokeMethodReturningLong(code, GPRs, FPRs, FPRmeta, Spills);
    }
    if (returnType.isFloatType()) {
        return Magic.invokeMethodReturningFloat(code, GPRs, FPRs, FPRmeta, Spills);
    }
    if (returnType.isDoubleType()) {
        return Magic.invokeMethodReturningDouble(code, GPRs, FPRs, FPRmeta, Spills);
    }
    if (VM.VerifyAssertions)
        VM._assert(NOT_REACHED);
    return null;
}

Example 34 with CompiledMethod

use of org.jikesrvm.compilers.common.CompiledMethod in project JikesRVM by JikesRVM.

the class RuntimeEntrypoints method deliverHardwareException.

/**
 * Deliver a hardware exception to current java thread.
 * <p>
 * Does not return.
 * (stack is unwound, starting at trap site, and
 *           execution resumes in a catch block somewhere up the stack)
 *     /or/  execution resumes at instruction following trap
 *     (for TRAP_STACK_OVERFLOW)
 *
 * <p> Note:     Control reaches here by the actions of an
 *           external "C" signal handler
 *           which saves the register state of the trap site into the
 *           "exceptionRegisters" field of the current
 *           Thread object.
 *           The signal handler also inserts a &lt;hardware trap&gt; frame
 *           onto the stack immediately above this frame, for use by
 *           HardwareTrapGCMapIterator during garbage collection.
 *
 * @param trapCode code indicating kind of exception that was trapped
 * (see TRAP_xxx, above)
 * @param trapInfo array subscript (for array bounds trap, only), marker
 * (for stack overflow traps on PPC) or
 */
@Entrypoint
@UnpreemptibleNoWarn
static void deliverHardwareException(int trapCode, Word trapInfo) {
    if (VM.verboseSignalHandling)
        VM.sysWriteln("delivering hardware exception");
    RVMThread myThread = RVMThread.getCurrentThread();
    if (VM.verboseSignalHandling)
        VM.sysWriteln("we have a thread = ", Magic.objectAsAddress(myThread));
    if (VM.verboseSignalHandling)
        VM.sysWriteln("it's in state = ", myThread.getExecStatus());
    AbstractRegisters exceptionRegisters = myThread.getExceptionRegisters();
    if (VM.verboseSignalHandling)
        VM.sysWriteln("we have exception registers = ", Magic.objectAsAddress(exceptionRegisters));
    if ((trapCode == TRAP_STACK_OVERFLOW || trapCode == TRAP_JNI_STACK) && myThread.getStack().length < (StackFrameLayout.getMaxStackSize() >> LOG_BYTES_IN_ADDRESS) && !myThread.hasNativeStackFrame()) {
        // (C trap handler has set register.ip to the instruction following the trap).
        if (trapCode == TRAP_JNI_STACK) {
            RVMThread.resizeCurrentStack(myThread.getStackLength() + StackFrameLayout.getJNIStackGrowthSize(), exceptionRegisters);
        } else {
            RVMThread.resizeCurrentStack(myThread.getStackLength() + StackFrameLayout.getStackGrowthSize(), exceptionRegisters);
        }
        if (VM.VerifyAssertions)
            VM._assert(exceptionRegisters.getInUse());
        exceptionRegisters.setInUse(false);
        Magic.restoreHardwareExceptionState(exceptionRegisters);
        if (VM.VerifyAssertions)
            VM._assert(NOT_REACHED);
    }
    // GC stress testing
    if (canForceGC()) {
        // VM.sysWriteln("FORCING GC: in deliverHardwareException");
        System.gc();
    }
    // Hardware traps in uninterruptible code should be considered hard failures.
    if (!VM.sysFailInProgress()) {
        Address fp = exceptionRegisters.getInnermostFramePointer();
        int compiledMethodId = Magic.getCompiledMethodID(fp);
        if (compiledMethodId != StackFrameLayout.getInvisibleMethodID()) {
            CompiledMethod compiledMethod = CompiledMethods.getCompiledMethod(compiledMethodId);
            Address ip = exceptionRegisters.getInnermostInstructionAddress();
            Offset instructionOffset = compiledMethod.getInstructionOffset(ip);
            if (compiledMethod.isWithinUninterruptibleCode(instructionOffset)) {
                VM.sysWriteln();
                switch(trapCode) {
                    case TRAP_NULL_POINTER:
                        VM.sysWriteln("Fatal error: NullPointerException within uninterruptible region.");
                        break;
                    case TRAP_ARRAY_BOUNDS:
                        VM.sysWriteln("Fatal error: ArrayIndexOutOfBoundsException within uninterruptible region (index was ", trapInfo.toInt(), ").");
                        break;
                    case TRAP_DIVIDE_BY_ZERO:
                        VM.sysWriteln("Fatal error: DivideByZero within uninterruptible region.");
                        break;
                    case TRAP_STACK_OVERFLOW:
                    case TRAP_JNI_STACK:
                        VM.sysWriteln("Fatal error: StackOverflowError within uninterruptible region.");
                        break;
                    case TRAP_CHECKCAST:
                        VM.sysWriteln("Fatal error: ClassCastException within uninterruptible region.");
                        break;
                    case TRAP_MUST_IMPLEMENT:
                        VM.sysWriteln("Fatal error: IncompatibleClassChangeError within uninterruptible region.");
                        break;
                    case TRAP_STORE_CHECK:
                        VM.sysWriteln("Fatal error: ArrayStoreException within uninterruptible region.");
                        break;
                    case TRAP_UNREACHABLE_BYTECODE:
                        VM.sysWriteln("Fatal error: Reached a bytecode that was determined to be unreachable within uninterruptible region.");
                        break;
                    default:
                        VM.sysWriteln("Fatal error: Unknown hardware trap within uninterruptible region.");
                        break;
                }
                VM.sysWriteln("trapCode = ", trapCode);
                VM.sysWriteln("trapInfo = ", trapInfo.toAddress());
                VM.sysFail("Exiting virtual machine due to uninterruptibility violation.");
            }
        }
    }
    Throwable exceptionObject;
    switch(trapCode) {
        case TRAP_NULL_POINTER:
            exceptionObject = new java.lang.NullPointerException();
            break;
        case TRAP_ARRAY_BOUNDS:
            exceptionObject = new java.lang.ArrayIndexOutOfBoundsException(trapInfo.toInt());
            break;
        case TRAP_DIVIDE_BY_ZERO:
            exceptionObject = new java.lang.ArithmeticException();
            break;
        case TRAP_STACK_OVERFLOW:
        case TRAP_JNI_STACK:
            exceptionObject = new java.lang.StackOverflowError();
            break;
        case TRAP_CHECKCAST:
            exceptionObject = new java.lang.ClassCastException();
            break;
        case TRAP_MUST_IMPLEMENT:
            exceptionObject = new java.lang.IncompatibleClassChangeError();
            break;
        case TRAP_STORE_CHECK:
            exceptionObject = new java.lang.ArrayStoreException();
            break;
        case TRAP_UNREACHABLE_BYTECODE:
            exceptionObject = new java.lang.InternalError(UNREACHABLE_BC_MESSAGE);
            break;
        default:
            exceptionObject = new java.lang.UnknownError();
            RVMThread.traceback("UNKNOWN ERROR");
            break;
    }
    // VM.enableGC() is called when the exception is delivered.
    VM.disableGC();
    deliverException(exceptionObject, exceptionRegisters);
}

Example 35 with CompiledMethod

use of org.jikesrvm.compilers.common.CompiledMethod in project JikesRVM by JikesRVM.

the class StackTrace method firstRealMethod.

/**
 * Find the first non-VM method/exception initializer method in the stack
 * trace. As we're working with the compiled methods we're assuming the
 * constructor of the exception won't have been inlined into the throwing
 * method.
 *
 * @param cause the cause of generating the stack trace marking the end of the
 *          frames to elide
 * @return the index of the method throwing the exception or else 0
 */
private int firstRealMethod(Throwable cause) {
    /* We expect a hardware trap to look like:
     * at org.jikesrvm.runtime.StackTrace.<init>(StackTrace.java:78)
     * at java.lang.VMThrowable.fillInStackTrace(VMThrowable.java:67)
     * at java.lang.Throwable.fillInStackTrace(Throwable.java:498)
     * at java.lang.Throwable.<init>(Throwable.java:159)
     * at java.lang.Throwable.<init>(Throwable.java:147)
     * at java.lang.Exception.<init>(Exception.java:66)
     * at java.lang.RuntimeException.<init>(RuntimeException.java:64)
     * at java.lang.NullPointerException.<init>(NullPointerException.java:69)
     * at org.jikesrvm.runtime.RuntimeEntrypoints.deliverHardwareException(RuntimeEntrypoints.java:682)
     * at <hardware trap>(Unknown Source:0)
     *
     * and a software trap to look like:
     * at org.jikesrvm.runtime.StackTrace.<init>(StackTrace.java:78)
     * at java.lang.VMThrowable.fillInStackTrace(VMThrowable.java:67)
     * at java.lang.Throwable.fillInStackTrace(Throwable.java:498)
     * at java.lang.Throwable.<init>(Throwable.java:159)
     * at java.lang.Error.<init>(Error.java:81)
     * at java.lang.LinkageError.<init>(LinkageError.java:72)
     * at java.lang.ExceptionInInitializerError.<init>(ExceptionInInitializerError.java:85)
     * at java.lang.ExceptionInInitializerError.<init>(ExceptionInInitializerError.java:75)
     *
     * and an OutOfMemoryError to look like:
     * ???
     * ...
     * at org.jikesrvm.mm.mminterface.MemoryManager.allocateSpace(MemoryManager.java:613)
     * ...
     * at org.jikesrvm.runtime.RuntimeEntrypoints.unresolvedNewArray(RuntimeEntrypoints.java:401)
     */
    if (Options.stackTraceFull) {
        return 0;
    } else {
        int element = 0;
        CompiledMethod compiledMethod = getCompiledMethod(element);
        // Deal with OutOfMemoryError
        if (cause instanceof OutOfMemoryError) {
            // (1) search until RuntimeEntrypoints
            while ((element < compiledMethods.length) && (compiledMethod != null) && compiledMethod.getMethod().getDeclaringClass().getClassForType() != RuntimeEntrypoints.class) {
                element++;
                compiledMethod = getCompiledMethod(element);
            }
            // (2) continue until not RuntimeEntrypoints
            while ((element < compiledMethods.length) && (compiledMethod != null) && compiledMethod.getMethod().getDeclaringClass().getClassForType() == RuntimeEntrypoints.class) {
                element++;
                compiledMethod = getCompiledMethod(element);
            }
            return element;
        }
        // (1) remove any StackTrace frames
        element = removeStackTraceFrames(element);
        compiledMethod = getCompiledMethod(element);
        // (2) remove any VMThrowable frames
        if (VM.BuildForGnuClasspath) {
            while ((element < compiledMethods.length) && (compiledMethod != null) && compiledMethod.getMethod().getDeclaringClass().getClassForType().getName().equals("java.lang.VMThrowable")) {
                element++;
                compiledMethod = getCompiledMethod(element);
            }
        }
        // (3) remove any Throwable frames
        while ((element < compiledMethods.length) && (compiledMethod != null) && compiledMethod.getMethod().getDeclaringClass().getClassForType() == java.lang.Throwable.class) {
            element++;
            compiledMethod = getCompiledMethod(element);
        }
        // (4) remove frames belonging to exception constructors upto the causes constructor
        while ((element < compiledMethods.length) && (compiledMethod != null) && (compiledMethod.getMethod().getDeclaringClass().getClassForType() != cause.getClass()) && compiledMethod.getMethod().isObjectInitializer() && compiledMethod.getMethod().getDeclaringClass().isAssignableToThrowable()) {
            element++;
            compiledMethod = getCompiledMethod(element);
        }
        // Sun's VM has the same problem
        while ((element < compiledMethods.length) && (compiledMethod != null) && (compiledMethod.getMethod().getDeclaringClass().getClassForType() == cause.getClass()) && compiledMethod.getMethod().isObjectInitializer()) {
            element++;
            compiledMethod = getCompiledMethod(element);
        }
        // a time!
        if ((element < compiledMethods.length) && (compiledMethod != null) && Entrypoints.isInvisibleRaiseMethod(compiledMethod.getMethod())) {
            element++;
            compiledMethod = getCompiledMethod(element);
        }
        // (7) remove possible hardware exception deliverer frames
        if (element < compiledMethods.length - 2) {
            compiledMethod = getCompiledMethod(element + 1);
            if ((compiledMethod != null) && compiledMethod.getCompilerType() == CompiledMethod.TRAP) {
                element += 2;
            }
        }
        return element;
    }
}