src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/stubs/ExceptionHandlerStub.java

*** 39,55 ****
--- 39,57 ----
  import org.graalvm.compiler.api.replacements.Fold;
  import org.graalvm.compiler.api.replacements.Fold.InjectedParameter;
  import org.graalvm.compiler.api.replacements.Snippet;
  import org.graalvm.compiler.api.replacements.Snippet.ConstantParameter;
  import org.graalvm.compiler.core.common.spi.ForeignCallDescriptor;
+ import org.graalvm.compiler.debug.Assertions;
  import org.graalvm.compiler.graph.Node.ConstantNodeParameter;
  import org.graalvm.compiler.graph.Node.NodeIntrinsic;
  import org.graalvm.compiler.hotspot.GraalHotSpotVMConfig;
  import org.graalvm.compiler.hotspot.HotSpotBackend;
  import org.graalvm.compiler.hotspot.HotSpotForeignCallLinkage;
  import org.graalvm.compiler.hotspot.meta.HotSpotProviders;
  import org.graalvm.compiler.hotspot.nodes.StubForeignCallNode;
+ import org.graalvm.compiler.options.OptionValues;
  import org.graalvm.compiler.word.Word;
  
  import jdk.vm.ci.code.Register;
  
  /**
*** 60,71 ****
   * <p>
   * 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
--- 62,73 ----
   * <p>
   * The descriptor for a call to this stub is {@link HotSpotBackend#EXCEPTION_HANDLER}.
   */
  public class ExceptionHandlerStub extends SnippetStub {
  
!     public ExceptionHandlerStub(OptionValues options, HotSpotProviders providers, HotSpotForeignCallLinkage linkage) {
!         super("exceptionHandler", options, 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
*** 76,97 ****
          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");
--- 78,102 ----
          return false;
      }
  
      @Override
      protected Object getConstantParameterValue(int index, String name) {
!         if (index == 2) {
              return providers.getRegisters().getThreadRegister();
          }
+         assert index == 3;
+         return options;
+     }
  
      @Snippet
!     private static void exceptionHandler(Object exception, Word exceptionPc, @ConstantParameter Register threadRegister, @ConstantParameter OptionValues options) {
          Word thread = registerAsWord(threadRegister);
          checkNoExceptionInThread(thread, assertionsEnabled(INJECTED_VMCONFIG));
          checkExceptionNotNull(assertionsEnabled(INJECTED_VMCONFIG), exception);
          writeExceptionOop(thread, exception);
          writeExceptionPc(thread, exceptionPc);
!         if (logging(options)) {
              printf("handling exception %p (", Word.objectToTrackedPointer(exception).rawValue());
              decipher(Word.objectToTrackedPointer(exception).rawValue());
              printf(") at %p (", exceptionPc.rawValue());
              decipher(exceptionPc.rawValue());
              printf(")\n");
*** 100,110 ****
          // 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");
          }
  
--- 105,115 ----
          // 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(options)) {
              printf("handler for exception %p at %p is at %p (", Word.objectToTrackedPointer(exception).rawValue(), exceptionPc.rawValue(), handlerPc.rawValue());
              decipher(handlerPc.rawValue());
              printf(")\n");
          }
  
*** 134,160 ****
              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.
!      * <p>
!      * 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)
--- 139,160 ----
              fatal("exception must not be null");
          }
      }
  
      @Fold
!     static boolean logging(OptionValues options) {
!         return StubOptions.TraceExceptionHandlerStub.getValue(options);
      }
  
      /**
!      * Determines if either Java assertions are enabled for Graal or if this is a HotSpot build
!      * where the ASSERT mechanism is enabled.
       */
      @Fold
      @SuppressWarnings("all")
      static boolean assertionsEnabled(@InjectedParameter GraalHotSpotVMConfig config) {
!         return Assertions.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)