*** old/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/HotSpotGraalCompiler.java	Fri Jul  7 09:30:12 2017
--- new/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/HotSpotGraalCompiler.java	Fri Jul  7 09:30:12 2017

*** 25,49 ****
--- 25,49 ----
  import static org.graalvm.compiler.core.common.GraalOptions.OptAssumptions;
  import static org.graalvm.compiler.nodes.graphbuilderconf.IntrinsicContext.CompilationContext.ROOT_COMPILATION;
  
  import java.io.ByteArrayOutputStream;
  import java.io.PrintStream;
+ import java.util.Collections;
  import java.util.Formattable;
  import java.util.Formatter;
+ import java.util.List;
  
  import org.graalvm.compiler.api.runtime.GraalJVMCICompiler;
  import org.graalvm.compiler.bytecode.Bytecode;
  import org.graalvm.compiler.code.CompilationResult;
  import org.graalvm.compiler.core.GraalCompiler;
  import org.graalvm.compiler.core.common.CompilationIdentifier;
  import org.graalvm.compiler.core.common.util.CompilationAlarm;
! import org.graalvm.compiler.debug.DebugHandlersFactory;
! import org.graalvm.compiler.debug.DebugConfigScope;
! import org.graalvm.compiler.debug.DebugEnvironment;
! import org.graalvm.compiler.debug.GraalDebugConfig;
  import org.graalvm.compiler.debug.TopLevelDebugConfig;
  import org.graalvm.compiler.debug.internal.method.MethodMetricsRootScopeInfo;
! import org.graalvm.compiler.debug.DebugContext;
! import org.graalvm.compiler.debug.DebugContext.Activation;
! import org.graalvm.compiler.debug.DebugOptions;
  import org.graalvm.compiler.hotspot.CompilationCounters.Options;
  import org.graalvm.compiler.hotspot.meta.HotSpotProviders;
  import org.graalvm.compiler.hotspot.phases.OnStackReplacementPhase;
  import org.graalvm.compiler.java.GraphBuilderPhase;
  import org.graalvm.compiler.lir.asm.CompilationResultBuilderFactory;

*** 58,67 ****
--- 58,68 ----
  import org.graalvm.compiler.phases.OptimisticOptimizations;
  import org.graalvm.compiler.phases.OptimisticOptimizations.Optimization;
  import org.graalvm.compiler.phases.PhaseSuite;
  import org.graalvm.compiler.phases.tiers.HighTierContext;
  import org.graalvm.compiler.phases.tiers.Suites;
+ import org.graalvm.compiler.printer.GraalDebugHandlersFactory;
  
  import jdk.vm.ci.code.CompilationRequest;
  import jdk.vm.ci.code.CompilationRequestResult;
  import jdk.vm.ci.hotspot.HotSpotCompilationRequest;
  import jdk.vm.ci.hotspot.HotSpotCompilationRequestResult;

*** 78,94 ****
--- 79,103 ----
  
      private final HotSpotJVMCIRuntimeProvider jvmciRuntime;
      private final HotSpotGraalRuntimeProvider graalRuntime;
      private final CompilationCounters compilationCounters;
      private final BootstrapWatchDog bootstrapWatchDog;
+     private List<DebugHandlersFactory> factories;
  
      HotSpotGraalCompiler(HotSpotJVMCIRuntimeProvider jvmciRuntime, HotSpotGraalRuntimeProvider graalRuntime, OptionValues options) {
          this.jvmciRuntime = jvmciRuntime;
          this.graalRuntime = graalRuntime;
          // It is sufficient to have one compilation counter object per Graal compiler object.
          this.compilationCounters = Options.CompilationCountLimit.getValue(options) > 0 ? new CompilationCounters(options) : null;
!         this.bootstrapWatchDog = graalRuntime.isBootstrapping() && !GraalDebugConfig.Options.BootstrapInitializeOnly.getValue(options) ? BootstrapWatchDog.maybeCreate(graalRuntime) : null;
+     }
+ 
+     public List<DebugHandlersFactory> getDebugHandlersFactories() {
+         if (factories == null) {
+             factories = Collections.singletonList(new GraalDebugHandlersFactory(graalRuntime.getHostProviders().getSnippetReflection()));
+         }
+         return factories;
      }
  
      @Override
      public HotSpotGraalRuntimeProvider getGraalRuntime() {
          return graalRuntime;

*** 102,157 ****
--- 111,165 ----
      @SuppressWarnings("try")
      CompilationRequestResult compileMethod(CompilationRequest request, boolean installAsDefault) {
          if (graalRuntime.isShutdown()) {
              return HotSpotCompilationRequestResult.failure(String.format("Shutdown entered"), false);
          }
          OptionValues options = graalRuntime.getOptions(request.getMethod());
+ 
+         ResolvedJavaMethod method = request.getMethod();
+         OptionValues options = graalRuntime.getOptions(method);
  
          if (graalRuntime.isBootstrapping()) {
!             if (GraalDebugConfig.Options.BootstrapInitializeOnly.getValue(options)) {
!                 return HotSpotCompilationRequestResult.failure(String.format("Skip compilation because %s is enabled", GraalDebugConfig.Options.BootstrapInitializeOnly.getName()), true);
!                 return HotSpotCompilationRequestResult.failure(String.format("Skip compilation because %s is enabled", DebugOptions.BootstrapInitializeOnly.getName()), true);
              }
              if (bootstrapWatchDog != null) {
                  if (bootstrapWatchDog.hitCriticalCompilationRateOrTimeout()) {
                      // Drain the compilation queue to expedite completion of the bootstrap
                      return HotSpotCompilationRequestResult.failure("hit critical bootstrap compilation rate or timeout", true);
                  }
              }
          }
          ResolvedJavaMethod method = request.getMethod();
          HotSpotCompilationRequest hsRequest = (HotSpotCompilationRequest) request;
          try (CompilationWatchDog w1 = CompilationWatchDog.watch(method, hsRequest.getId(), options);
                          BootstrapWatchDog.Watch w2 = bootstrapWatchDog == null ? null : bootstrapWatchDog.watch(request);
                          CompilationAlarm alarm = CompilationAlarm.trackCompilationPeriod(options);) {
              if (compilationCounters != null) {
                  compilationCounters.countCompilation(method);
              }
              // Ensure a debug configuration for this thread is initialized
              DebugEnvironment.ensureInitialized(options, graalRuntime.getHostProviders().getSnippetReflection());
              CompilationTask task = new CompilationTask(jvmciRuntime, this, hsRequest, true, installAsDefault, options);
!             CompilationRequestResult r = null;
!             try (DebugConfigScope dcs = Debug.setConfig(new TopLevelDebugConfig());
!                             Debug.Scope s = Debug.methodMetricsScope("HotSpotGraalCompiler", MethodMetricsRootScopeInfo.create(method), true, method)) {
!                 r = task.runCompilation();
!             try (DebugContext debug = graalRuntime.openDebugContext(options, task.getCompilationIdentifier(), method, getDebugHandlersFactories());
!                             Activation a = debug.activate()) {
!                 r = task.runCompilation(debug);
              }
              assert r != null;
              return r;
          }
      }
  
!     public CompilationResult compile(ResolvedJavaMethod method, int entryBCI, boolean useProfilingInfo, CompilationIdentifier compilationId, OptionValues options, DebugContext debug) {
          HotSpotBackend backend = graalRuntime.getHostBackend();
          HotSpotProviders providers = backend.getProviders();
          final boolean isOSR = entryBCI != JVMCICompiler.INVOCATION_ENTRY_BCI;
!         StructuredGraph graph = method.isNative() || isOSR ? null : getIntrinsicGraph(method, providers, compilationId, options, debug);
  
          if (graph == null) {
              SpeculationLog speculationLog = method.getSpeculationLog();
              if (speculationLog != null) {
                  speculationLog.collectFailedSpeculations();
              }
!             graph = new StructuredGraph.Builder(options, debug, AllowAssumptions.ifTrue(OptAssumptions.getValue(options))).method(method).entryBCI(entryBCI).speculationLog(
                              speculationLog).useProfilingInfo(useProfilingInfo).compilationId(compilationId).build();
          }
  
          Suites suites = getSuites(providers, options);
          LIRSuites lirSuites = getLIRSuites(providers, options);

*** 184,213 ****
--- 192,222 ----
       * installed for the method.
       *
       * @param method
       * @param compilationId
       * @param options
+      * @param debug
       * @return an intrinsic graph that can be compiled and installed for {@code method} or null
       */
      @SuppressWarnings("try")
!     public StructuredGraph getIntrinsicGraph(ResolvedJavaMethod method, HotSpotProviders providers, CompilationIdentifier compilationId, OptionValues options, DebugContext debug) {
          Replacements replacements = providers.getReplacements();
          Bytecode subst = replacements.getSubstitutionBytecode(method);
          if (subst != null) {
              ResolvedJavaMethod substMethod = subst.getMethod();
              assert !substMethod.equals(method);
!             StructuredGraph graph = new StructuredGraph.Builder(options, debug, AllowAssumptions.YES).method(substMethod).compilationId(compilationId).build();
!             try (Debug.Scope scope = Debug.scope("GetIntrinsicGraph", graph)) {
!             try (DebugContext.Scope scope = debug.scope("GetIntrinsicGraph", graph)) {
                  Plugins plugins = new Plugins(providers.getGraphBuilderPlugins());
                  GraphBuilderConfiguration config = GraphBuilderConfiguration.getSnippetDefault(plugins);
                  IntrinsicContext initialReplacementContext = new IntrinsicContext(method, substMethod, subst.getOrigin(), ROOT_COMPILATION);
                  new GraphBuilderPhase.Instance(providers.getMetaAccess(), providers.getStampProvider(), providers.getConstantReflection(), providers.getConstantFieldProvider(), config,
                                  OptimisticOptimizations.NONE, initialReplacementContext).apply(graph);
                  assert !graph.isFrozen();
                  return graph;
              } catch (Throwable e) {
!                 Debug.handle(e);
!                 debug.handle(e);
              }
          }
          return null;
      }