Examples with OutOfRegistersException org.graalvm.compiler.lir.alloc.OutOfRegistersException used on opensource projects

Example 1 with OutOfRegistersException

use of org.graalvm.compiler.lir.alloc.OutOfRegistersException in project graal by oracle.

the class TraceLinearScanWalker method allocLockedRegister.

// Split an Interval and spill it to memory so that cur can be placed in a register
@SuppressWarnings("try")
private void allocLockedRegister(TraceInterval interval) {
    try (Indent indent = debug.logAndIndent("alloc locked register: need to split and spill to get register for %s", interval)) {
        // the register must be free at least until this position
        int firstUsage = interval.firstUsage(RegisterPriority.MustHaveRegister);
        int firstShouldHaveUsage = interval.firstUsage(RegisterPriority.ShouldHaveRegister);
        int regNeededUntil = Math.min(firstUsage, interval.from() + 1);
        int intervalTo = interval.to();
        assert regNeededUntil >= 0 && regNeededUntil < Integer.MAX_VALUE : "interval has no use";
        Register reg;
        Register ignore;
        /*
             * In the common case we don't spill registers that have _any_ use position that is
             * closer than the next use of the current interval, but if we can't spill the current
             * interval we weaken this strategy and also allow spilling of intervals that have a
             * non-mandatory requirements (no MustHaveRegister use position).
             */
        for (RegisterPriority registerPriority = RegisterPriority.LiveAtLoopEnd; true; registerPriority = RegisterPriority.MustHaveRegister) {
            // collect current usage of registers
            initUseLists(false);
            spillExcludeActiveFixed();
            // spillBlockUnhandledFixed(cur);
            spillBlockInactiveFixed(interval);
            spillCollectActiveAny(registerPriority);
            if (debug.isLogEnabled()) {
                printRegisterState();
            }
            reg = null;
            ignore = interval.location() != null && isRegister(interval.location()) ? asRegister(interval.location()) : null;
            for (Register availableReg : availableRegs) {
                int number = availableReg.number;
                if (availableReg.equals(ignore)) {
                // this register must be ignored
                } else if (usePos[number] > regNeededUntil) {
                    /*
                         * If the use position is the same, prefer registers (active intervals)
                         * where the value is already on the stack.
                         */
                    if (reg == null || (usePos[number] > usePos[reg.number]) || (usePos[number] == usePos[reg.number] && (!isInMemory.get(reg.number) && isInMemory.get(number)))) {
                        reg = availableReg;
                    }
                }
            }
            if (debug.isLogEnabled()) {
                debug.log("Register Selected: %s", reg);
            }
            int regUsePos = (reg == null ? 0 : usePos[reg.number]);
            if (regUsePos <= firstShouldHaveUsage) {
                /* Check if there is another interval that is already in memory. */
                if (reg == null || interval.inMemoryAt(currentPosition) || !isInMemory.get(reg.number)) {
                    if (debug.isLogEnabled()) {
                        debug.log("able to spill current interval. firstUsage(register): %d, usePos: %d", firstUsage, regUsePos);
                    }
                    if (firstUsage <= interval.from() + 1) {
                        if (registerPriority.equals(RegisterPriority.LiveAtLoopEnd)) {
                            /*
                                 * Tool of last resort: we can not spill the current interval so we
                                 * try to spill an active interval that has a usage but do not
                                 * require a register.
                                 */
                            debug.log("retry with register priority must have register");
                            continue;
                        }
                        String description = "cannot spill interval (" + interval + ") that is used in first instruction (possible reason: no register found) firstUsage=" + firstUsage + ", interval.from()=" + interval.from() + "; already used candidates: " + Arrays.toString(availableRegs);
                        /*
                             * assign a reasonable register and do a bailout in product mode to
                             * avoid errors
                             */
                        allocator.assignSpillSlot(interval);
                        if (debug.isDumpEnabled(DebugContext.INFO_LEVEL)) {
                            dumpLIRAndIntervals(description);
                        }
                        throw new OutOfRegistersException("LinearScan: no register found", description);
                    }
                    splitAndSpillInterval(interval);
                    return;
                }
            }
            // common case: break out of the loop
            break;
        }
        boolean needSplit = blockPos[reg.number] <= intervalTo;
        int splitPos = blockPos[reg.number];
        if (debug.isLogEnabled()) {
            debug.log("decided to use register %d", reg.number);
        }
        assert splitPos > 0 : "invalid splitPos";
        assert needSplit || splitPos > interval.from() : "splitting interval at from";
        interval.assignLocation(reg.asValue(allocator.getKind(interval)));
        if (needSplit) {
            // register not available for full interval : so split it
            splitWhenPartialRegisterAvailable(interval, splitPos);
        }
        // perform splitting and spilling for all affected intervals
        splitAndSpillIntersectingIntervals(reg);
        return;
    }
}

Example 2 with OutOfRegistersException

use of org.graalvm.compiler.lir.alloc.OutOfRegistersException in project graal by oracle.

the class LinearScanWalker method allocLockedRegister.

// Split an Interval and spill it to memory so that cur can be placed in a register
@SuppressWarnings("try")
void allocLockedRegister(Interval interval) {
    DebugContext debug = allocator.getDebug();
    try (Indent indent = debug.logAndIndent("alloc locked register: need to split and spill to get register for %s", interval)) {
        // the register must be free at least until this position
        int firstUsage = interval.firstUsage(RegisterPriority.MustHaveRegister);
        int firstShouldHaveUsage = interval.firstUsage(RegisterPriority.ShouldHaveRegister);
        int regNeededUntil = Math.min(firstUsage, interval.from() + 1);
        int intervalTo = interval.to();
        assert regNeededUntil >= 0 && regNeededUntil < Integer.MAX_VALUE : "interval has no use";
        Register reg;
        Register ignore;
        /*
             * In the common case we don't spill registers that have _any_ use position that is
             * closer than the next use of the current interval, but if we can't spill the current
             * interval we weaken this strategy and also allow spilling of intervals that have a
             * non-mandatory requirements (no MustHaveRegister use position).
             */
        for (RegisterPriority registerPriority = RegisterPriority.LiveAtLoopEnd; true; registerPriority = RegisterPriority.MustHaveRegister) {
            // collect current usage of registers
            initUseLists(false);
            spillExcludeActiveFixed();
            // spillBlockUnhandledFixed(cur);
            assert unhandledLists.get(RegisterBinding.Fixed).isEndMarker() : "must not have unhandled fixed intervals because all fixed intervals have a use at position 0";
            spillBlockInactiveFixed(interval);
            spillCollectActiveAny(registerPriority);
            spillCollectInactiveAny(interval);
            if (debug.isLogEnabled()) {
                printRegisterState();
            }
            reg = null;
            ignore = interval.location() != null && isRegister(interval.location()) ? asRegister(interval.location()) : null;
            for (Register availableReg : availableRegs) {
                int number = availableReg.number;
                if (availableReg.equals(ignore)) {
                // this register must be ignored
                } else if (usePos[number] > regNeededUntil) {
                    if (reg == null || (usePos[number] > usePos[reg.number])) {
                        reg = availableReg;
                    }
                }
            }
            int regUsePos = (reg == null ? 0 : usePos[reg.number]);
            if (regUsePos <= firstShouldHaveUsage) {
                if (debug.isLogEnabled()) {
                    debug.log("able to spill current interval. firstUsage(register): %d, usePos: %d", firstUsage, regUsePos);
                }
                if (firstUsage <= interval.from() + 1) {
                    if (registerPriority.equals(RegisterPriority.LiveAtLoopEnd)) {
                        /*
                             * Tool of last resort: we can not spill the current interval so we try
                             * to spill an active interval that has a usage but do not require a
                             * register.
                             */
                        debug.log("retry with register priority must have register");
                        continue;
                    }
                    String description = generateOutOfRegErrorMsg(interval, firstUsage, availableRegs);
                    /*
                         * assign a reasonable register and do a bailout in product mode to avoid
                         * errors
                         */
                    allocator.assignSpillSlot(interval);
                    debug.dump(DebugContext.INFO_LEVEL, allocator.getLIR(), description);
                    allocator.printIntervals(description);
                    throw new OutOfRegistersException("LinearScan: no register found", description);
                }
                splitAndSpillInterval(interval);
                return;
            }
            break;
        }
        boolean needSplit = blockPos[reg.number] <= intervalTo;
        int splitPos = blockPos[reg.number];
        if (debug.isLogEnabled()) {
            debug.log("decided to use register %d", reg.number);
        }
        assert splitPos > 0 : "invalid splitPos";
        assert needSplit || splitPos > interval.from() : "splitting interval at from";
        interval.assignLocation(reg.asValue(interval.kind()));
        if (needSplit) {
            // register not available for full interval : so split it
            splitWhenPartialRegisterAvailable(interval, splitPos);
        }
        // perform splitting and spilling for all affected intervals
        splitAndSpillIntersectingIntervals(reg);
        return;
    }
}

Example 3 with OutOfRegistersException

use of org.graalvm.compiler.lir.alloc.OutOfRegistersException in project graal by oracle.

the class GraalCompiler method emitLIR.

@SuppressWarnings("try")
public static LIRGenerationResult emitLIR(Backend backend, StructuredGraph graph, Object stub, RegisterConfig registerConfig, LIRSuites lirSuites) {
    String registerPressure = GraalOptions.RegisterPressure.getValue(graph.getOptions());
    String[] allocationRestrictedTo = registerPressure == null ? null : registerPressure.split(",");
    try {
        return emitLIR0(backend, graph, stub, registerConfig, lirSuites, allocationRestrictedTo);
    } catch (OutOfRegistersException e) {
        if (allocationRestrictedTo != null) {
            allocationRestrictedTo = null;
            return emitLIR0(backend, graph, stub, registerConfig, lirSuites, allocationRestrictedTo);
        }
        /* If the re-execution fails we convert the exception into a "hard" failure */
        throw new GraalError(e);
    } finally {
        graph.checkCancellation();
    }
}