+ * The descriptor for a call to this stub is {@link HotSpotBackend#EXCEPTION_HANDLER}. + */ +public class ExceptionHandlerStub extends SnippetStub { + + public ExceptionHandlerStub(HotSpotProviders providers, HotSpotForeignCallLinkage linkage) { + super("exceptionHandler", providers, linkage); + } + + /** + * This stub is called when returning to a method to handle an exception thrown by a callee. It + * is not used for routing implicit exceptions. Therefore, it does not need to save any + * registers as HotSpot uses a caller save convention. + */ + @Override + public boolean preservesRegisters() { + return false; + } + + @Override + protected Object getConstantParameterValue(int index, String name) { + assert index == 2; + return providers.getRegisters().getThreadRegister(); + } + + @Snippet + private static void exceptionHandler(Object exception, Word exceptionPc, @ConstantParameter Register threadRegister) { + Word thread = registerAsWord(threadRegister); + checkNoExceptionInThread(thread, assertionsEnabled(INJECTED_VMCONFIG)); + checkExceptionNotNull(assertionsEnabled(INJECTED_VMCONFIG), exception); + writeExceptionOop(thread, exception); + writeExceptionPc(thread, exceptionPc); + if (logging()) { + printf("handling exception %p (", Word.objectToTrackedPointer(exception).rawValue()); + decipher(Word.objectToTrackedPointer(exception).rawValue()); + printf(") at %p (", exceptionPc.rawValue()); + decipher(exceptionPc.rawValue()); + printf(")\n"); + } + + // patch throwing pc into return address so that deoptimization finds the right debug info + patchReturnAddress(exceptionPc); + + Word handlerPc = exceptionHandlerForPc(EXCEPTION_HANDLER_FOR_PC, thread); + + if (logging()) { + printf("handler for exception %p at %p is at %p (", Word.objectToTrackedPointer(exception).rawValue(), exceptionPc.rawValue(), handlerPc.rawValue()); + decipher(handlerPc.rawValue()); + printf(")\n"); + } + + // patch the return address so that this stub returns to the exception handler + jumpToExceptionHandler(handlerPc); + } + + static void checkNoExceptionInThread(Word thread, boolean enabled) { + if (enabled) { + Object currentException = readExceptionOop(thread); + if (currentException != null) { + fatal("exception object in thread must be null, not %p", Word.objectToTrackedPointer(currentException).rawValue()); + } + if (cAssertionsEnabled(INJECTED_VMCONFIG)) { + // This thread-local is only cleared in DEBUG builds of the VM + // (see OptoRuntime::generate_exception_blob) + Word currentExceptionPc = readExceptionPc(thread); + if (currentExceptionPc.notEqual(Word.zero())) { + fatal("exception PC in thread must be zero, not %p", currentExceptionPc.rawValue()); + } + } + } + } + + static void checkExceptionNotNull(boolean enabled, Object exception) { + if (enabled && exception == null) { + fatal("exception must not be null"); + } + } + + @Fold + static boolean logging() { + return StubOptions.TraceExceptionHandlerStub.getValue(); + } + + /** + * Determines if either Java assertions are enabled for {@link ExceptionHandlerStub} or if this + * is a HotSpot build where the ASSERT mechanism is enabled. + *
+ * This first check relies on the per-class assertion status which is why this method must be in + * this class. + */ + @Fold + @SuppressWarnings("all") + static boolean assertionsEnabled(@InjectedParameter GraalHotSpotVMConfig config) { + boolean enabled = false; + assert enabled = true; + return enabled || cAssertionsEnabled(config); + } + + public static final ForeignCallDescriptor EXCEPTION_HANDLER_FOR_PC = newDescriptor(ExceptionHandlerStub.class, "exceptionHandlerForPc", Word.class, Word.class); + + @NodeIntrinsic(value = StubForeignCallNode.class, setStampFromReturnType = true) + public static native Word exceptionHandlerForPc(@ConstantNodeParameter ForeignCallDescriptor exceptionHandlerForPc, Word thread); +}