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

*** 20,39 ****
--- 20,37 ----
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  package org.graalvm.compiler.lir.gen;
  
  import static org.graalvm.compiler.lir.LIRValueUtil.asConstant;
  import static org.graalvm.compiler.lir.LIRValueUtil.asJavaConstant;
  import static org.graalvm.compiler.lir.LIRValueUtil.isConstantValue;
  import static org.graalvm.compiler.lir.LIRValueUtil.isJavaConstant;
  import static org.graalvm.compiler.lir.LIRValueUtil.isVariable;
  import static org.graalvm.compiler.lir.LIRValueUtil.isVirtualStackSlot;
  import static jdk.vm.ci.code.ValueUtil.asAllocatableValue;
  import static jdk.vm.ci.code.ValueUtil.isAllocatableValue;
  import static jdk.vm.ci.code.ValueUtil.isLegal;
  import static jdk.vm.ci.code.ValueUtil.isStackSlot;
+ import static org.graalvm.compiler.lir.LIRValueUtil.asConstant;
+ import static org.graalvm.compiler.lir.LIRValueUtil.isConstantValue;
+ import static org.graalvm.compiler.lir.LIRValueUtil.isVariable;
+ import static org.graalvm.compiler.lir.LIRValueUtil.isVirtualStackSlot;
  
  import java.util.ArrayList;
  import java.util.List;
  
  import org.graalvm.compiler.asm.Label;

*** 58,69 ****
--- 56,68 ----
  import org.graalvm.compiler.lir.StandardOp.LabelOp;
  import org.graalvm.compiler.lir.StandardOp.SaveRegistersOp;
  import org.graalvm.compiler.lir.SwitchStrategy;
  import org.graalvm.compiler.lir.Variable;
  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 jdk.vm.ci.code.CallingConvention;
  import jdk.vm.ci.code.CodeCacheProvider;
  import jdk.vm.ci.code.Register;
  import jdk.vm.ci.code.RegisterAttributes;

*** 84,96 ****
--- 83,95 ----
  public abstract class LIRGenerator implements LIRGeneratorTool {
  
      public static class Options {
          // @formatter:off
          @Option(help = "Print HIR along side LIR as the latter is generated", type = OptionType.Debug)
!         public static final OptionValue<Boolean> PrintIRWithLIR = new OptionValue<>(false);
!         public static final OptionKey<Boolean> PrintIRWithLIR = new OptionKey<>(false);
          @Option(help = "The trace level for the LIR generator", type = OptionType.Debug)
!         public static final OptionValue<Integer> TraceLIRGeneratorLevel = new OptionValue<>(0);
!         public static final OptionKey<Integer> TraceLIRGeneratorLevel = new OptionKey<>(0);
          // @formatter:on
      }
  
      private final LIRKindTool lirKindTool;
  

*** 101,115 ****
--- 100,120 ----
      private LIRGenerationResult res;
  
      protected final ArithmeticLIRGenerator arithmeticLIRGen;
      private final MoveFactory moveFactory;
  
+     private final boolean printIrWithLir;
+     private final int traceLIRGeneratorLevel;
+ 
      public LIRGenerator(LIRKindTool lirKindTool, ArithmeticLIRGenerator arithmeticLIRGen, MoveFactory moveFactory, CodeGenProviders providers, LIRGenerationResult res) {
          this.lirKindTool = lirKindTool;
          this.arithmeticLIRGen = arithmeticLIRGen;
          this.res = res;
          this.providers = providers;
+         OptionValues options = res.getLIR().getOptions();
+         this.printIrWithLir = !TTY.isSuppressed() && Options.PrintIRWithLIR.getValue(options);
+         this.traceLIRGeneratorLevel = TTY.isSuppressed() ? 0 : Options.TraceLIRGeneratorLevel.getValue(options);
  
          assert arithmeticLIRGen.lirGen == null;
          arithmeticLIRGen.lirGen = this;
          this.moveFactory = moveFactory;
      }

*** 217,227 ****
--- 222,232 ----
          append(moveFactory.createLoad(dst, src));
      }
  
      @Override
      public Value emitConstant(LIRKind kind, Constant constant) {
!         if (constant instanceof JavaConstant && moveFactory.canInlineConstant((JavaConstant) constant)) {
              return new ConstantValue(toRegisterKind(kind), constant);
          } else {
              return emitLoadConstant(kind, constant);
          }
      }

*** 257,267 ****
--- 262,272 ----
          return (Variable) value;
      }
  
      @Override
      public Value loadNonConst(Value value) {
!         if (isJavaConstant(value) && !moveFactory.canInlineConstant(asJavaConstant(value))) {
!         if (isConstantValue(value) && !moveFactory.canInlineConstant(asConstant(value))) {
              return emitMove(value);
          }
          return value;
      }
  

*** 295,318 ****
--- 300,323 ----
          currentPosition = position;
      }
  
      @Override
      public <I extends LIRInstruction> I append(I op) {
!         if (Options.PrintIRWithLIR.getValue() && !TTY.isSuppressed()) {
!         if (printIrWithLir) {
              TTY.println(op.toStringWithIdPrefix());
              TTY.println();
          }
          assert LIRVerifier.verify(op);
!         ArrayList<LIRInstruction> lirForBlock = res.getLIR().getLIRforBlock(getCurrentBlock());
          op.setPosition(currentPosition);
          lirForBlock.add(op);
          return op;
      }
  
      @Override
      public boolean hasBlockEnd(AbstractBlockBase<?> block) {
!         ArrayList<LIRInstruction> ops = getResult().getLIR().getLIRforBlock(block);
          if (ops.size() == 0) {
              return false;
          }
          return ops.get(ops.size() - 1) instanceof BlockEndOp;
      }

*** 322,352 ****
--- 327,357 ----
          private BlockScopeImpl(AbstractBlockBase<?> block) {
              currentBlock = block;
          }
  
          private void doBlockStart() {
!             if (Options.PrintIRWithLIR.getValue()) {
!             if (printIrWithLir) {
                  TTY.print(currentBlock.toString());
              }
  
              // set up the list of LIR instructions
              assert res.getLIR().getLIRforBlock(currentBlock) == null : "LIR list already computed for this block";
              res.getLIR().setLIRforBlock(currentBlock, new ArrayList<LIRInstruction>());
  
              append(new LabelOp(new Label(currentBlock.getId()), currentBlock.isAligned()));
  
!             if (Options.TraceLIRGeneratorLevel.getValue() >= 1) {
!             if (traceLIRGeneratorLevel >= 1) {
                  TTY.println("BEGIN Generating LIR for block B" + currentBlock.getId());
              }
          }
  
          private void doBlockEnd() {
!             if (Options.TraceLIRGeneratorLevel.getValue() >= 1) {
!             if (traceLIRGeneratorLevel >= 1) {
                  TTY.println("END Generating LIR for block B" + currentBlock.getId());
              }
  
!             if (Options.PrintIRWithLIR.getValue()) {
!             if (printIrWithLir) {
                  TTY.println();
              }
              currentBlock = null;
          }