*** old/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.lir/src/org/graalvm/compiler/lir/asm/CompilationResultBuilder.java	Mon Mar 20 17:40:01 2017
--- new/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.lir/src/org/graalvm/compiler/lir/asm/CompilationResultBuilder.java	Mon Mar 20 17:40:01 2017

*** 20,62 ****
--- 20,64 ----
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  package org.graalvm.compiler.lir.asm;
  
  import static org.graalvm.compiler.lir.LIRValueUtil.asJavaConstant;
  import static org.graalvm.compiler.lir.LIRValueUtil.isJavaConstant;
  import static jdk.vm.ci.code.ValueUtil.asStackSlot;
  import static jdk.vm.ci.code.ValueUtil.isStackSlot;
+ import static org.graalvm.compiler.lir.LIRValueUtil.asJavaConstant;
+ import static org.graalvm.compiler.lir.LIRValueUtil.isJavaConstant;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.IdentityHashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.function.Consumer;
  
  import org.graalvm.compiler.asm.AbstractAddress;
  import org.graalvm.compiler.asm.Assembler;
! import org.graalvm.compiler.asm.NumUtil;
! import org.graalvm.compiler.core.common.NumUtil;
  import org.graalvm.compiler.code.CompilationResult;
  import org.graalvm.compiler.code.CompilationResult.CodeAnnotation;
  import org.graalvm.compiler.code.DataSection.Data;
  import org.graalvm.compiler.code.DataSection.RawData;
  import org.graalvm.compiler.core.common.cfg.AbstractBlockBase;
  import org.graalvm.compiler.core.common.spi.ForeignCallsProvider;
  import org.graalvm.compiler.core.common.type.DataPointerConstant;
+ import org.graalvm.compiler.debug.Assertions;
  import org.graalvm.compiler.debug.Debug;
  import org.graalvm.compiler.debug.GraalError;
  import org.graalvm.compiler.graph.NodeSourcePosition;
  import org.graalvm.compiler.lir.LIR;
  import org.graalvm.compiler.lir.LIRFrameState;
  import org.graalvm.compiler.lir.LIRInstruction;
  import org.graalvm.compiler.lir.LabelRef;
  import org.graalvm.compiler.lir.framemap.FrameMap;
  import org.graalvm.compiler.options.Option;
+ import org.graalvm.compiler.options.OptionKey;
  import org.graalvm.compiler.options.OptionType;
! import org.graalvm.compiler.options.OptionValues;
+ import org.graalvm.util.EconomicMap;
+ import org.graalvm.util.Equivalence;
  
  import jdk.vm.ci.code.CodeCacheProvider;
  import jdk.vm.ci.code.DebugInfo;
  import jdk.vm.ci.code.StackSlot;
  import jdk.vm.ci.code.TargetDescription;

*** 78,88 ****
--- 80,90 ----
   */
  public class CompilationResultBuilder {
  
      // @formatter:off
      @Option(help = "Include the LIR as comments with the final assembly.", type = OptionType.Debug)
!     public static final OptionValue<Boolean> PrintLIRWithAssembly = new OptionValue<>(false);
!     public static final OptionKey<Boolean> PrintLIRWithAssembly = new OptionKey<>(false);
      // @formatter:on
  
      private static class ExceptionInfo {
  
          public final int codeOffset;

*** 140,176 ****
--- 142,177 ----
       */
      public final FrameContext frameContext;
  
      private List<ExceptionInfo> exceptionInfoList;
  
!     private final Map<Constant, Data> dataCache;
!     private final OptionValues options;
+     private final EconomicMap<Constant, Data> dataCache;
  
      private Consumer<LIRInstruction> beforeOp;
      private Consumer<LIRInstruction> afterOp;
  
      public CompilationResultBuilder(CodeCacheProvider codeCache, ForeignCallsProvider foreignCalls, FrameMap frameMap, Assembler asm, DataBuilder dataBuilder, FrameContext frameContext,
!                     OptionValues options, CompilationResult compilationResult) {
          // constants are already GVNed in the high level graph, so we can use an IdentityHashMap
          this(codeCache, foreignCalls, frameMap, asm, dataBuilder, frameContext, compilationResult, new IdentityHashMap<>());
+         this(codeCache, foreignCalls, frameMap, asm, dataBuilder, frameContext, options, compilationResult, EconomicMap.create(Equivalence.DEFAULT));
      }
  
      public CompilationResultBuilder(CodeCacheProvider codeCache, ForeignCallsProvider foreignCalls, FrameMap frameMap, Assembler asm, DataBuilder dataBuilder, FrameContext frameContext,
!                     OptionValues options, CompilationResult compilationResult, EconomicMap<Constant, Data> dataCache) {
          this.target = codeCache.getTarget();
          this.codeCache = codeCache;
          this.foreignCalls = foreignCalls;
          this.frameMap = frameMap;
          this.asm = asm;
          this.dataBuilder = dataBuilder;
          this.compilationResult = compilationResult;
          this.frameContext = frameContext;
+         this.options = options;
          assert frameContext != null;
          this.dataCache = dataCache;
  
          boolean assertionsEnabled = false;
          assert (assertionsEnabled = true) == true;
          if (dataBuilder.needDetailedPatchingInformation() || assertionsEnabled) {
+         if (dataBuilder.needDetailedPatchingInformation() || Assertions.ENABLED) {
              /*
               * Always enabled in debug mode, even when the VM does not request detailed information,
               * to increase test coverage.
               */
              asm.setCodePatchingAnnotationConsumer(assemblerCodeAnnotation -> compilationResult.addAnnotation(new AssemblerAnnotation(assemblerCodeAnnotation)));

*** 458,473 ****
--- 459,475 ----
  
      private void emitBlock(AbstractBlockBase<?> block) {
          if (block == null) {
              return;
          }
          if (Debug.isDumpEnabled(Debug.BASIC_LOG_LEVEL) || PrintLIRWithAssembly.getValue()) {
+         boolean emitComment = Debug.isDumpEnabled(Debug.BASIC_LOG_LEVEL) || PrintLIRWithAssembly.getValue(getOptions());
+         if (emitComment) {
              blockComment(String.format("block B%d %s", block.getId(), block.getLoop()));
          }
  
          for (LIRInstruction op : lir.getLIRforBlock(block)) {
!             if (Debug.isDumpEnabled(Debug.BASIC_LOG_LEVEL) || PrintLIRWithAssembly.getValue()) {
!             if (emitComment) {
                  blockComment(String.format("%d %s", op.id(), op));
              }
  
              try {
                  if (beforeOp != null) {

*** 510,515 ****
--- 512,521 ----
  
      public void setOpCallback(Consumer<LIRInstruction> beforeOp, Consumer<LIRInstruction> afterOp) {
          this.beforeOp = beforeOp;
          this.afterOp = afterOp;
      }
+ 
+     public OptionValues getOptions() {
+         return options;
+     }
  }