*** old/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.hotspot.amd64/src/org/graalvm/compiler/hotspot/amd64/AMD64HotSpotLIRGenerator.java	Mon Mar 20 17:38:11 2017
--- new/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.hotspot.amd64/src/org/graalvm/compiler/hotspot/amd64/AMD64HotSpotLIRGenerator.java	Mon Mar 20 17:38:11 2017

*** 20,52 ****
--- 20,49 ----
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  package org.graalvm.compiler.hotspot.amd64;
  
+ import static jdk.vm.ci.amd64.AMD64.rbp;
  import static org.graalvm.compiler.core.common.GraalOptions.GeneratePIC;
  import static org.graalvm.compiler.hotspot.HotSpotBackend.INITIALIZE_KLASS_BY_SYMBOL;
  import static org.graalvm.compiler.hotspot.HotSpotBackend.RESOLVE_KLASS_BY_SYMBOL;
  import static org.graalvm.compiler.hotspot.HotSpotBackend.RESOLVE_METHOD_BY_SYMBOL_AND_LOAD_COUNTERS;
  import static org.graalvm.compiler.hotspot.HotSpotBackend.RESOLVE_STRING_BY_SYMBOL;
  import static org.graalvm.compiler.hotspot.HotSpotBackend.FETCH_UNROLL_INFO;
  import static org.graalvm.compiler.hotspot.HotSpotBackend.UNCOMMON_TRAP;
  import static jdk.vm.ci.amd64.AMD64.rbp;
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Map;
  
  import org.graalvm.compiler.asm.amd64.AMD64Address.Scale;
  import org.graalvm.compiler.core.amd64.AMD64ArithmeticLIRGenerator;
  import org.graalvm.compiler.core.amd64.AMD64LIRGenerator;
  import org.graalvm.compiler.core.amd64.AMD64MoveFactoryBase.BackupSlotProvider;
+ import org.graalvm.compiler.core.common.CompressEncoding;
  import org.graalvm.compiler.core.common.LIRKind;
  import org.graalvm.compiler.core.common.spi.ForeignCallLinkage;
  import org.graalvm.compiler.core.common.spi.LIRKindTool;
  import org.graalvm.compiler.debug.Debug;
  import org.graalvm.compiler.debug.GraalError;
  import org.graalvm.compiler.hotspot.CompressEncoding;
  import org.graalvm.compiler.hotspot.GraalHotSpotVMConfig;
  import org.graalvm.compiler.hotspot.HotSpotBackend;
  import org.graalvm.compiler.hotspot.HotSpotDebugInfoBuilder;
  import org.graalvm.compiler.hotspot.HotSpotForeignCallLinkage;
  import org.graalvm.compiler.hotspot.HotSpotLIRGenerationResult;

*** 61,71 ****
--- 58,67 ----
  import org.graalvm.compiler.lir.LIRFrameState;
  import org.graalvm.compiler.lir.LIRInstruction;
  import org.graalvm.compiler.lir.LIRInstructionClass;
  import org.graalvm.compiler.lir.LabelRef;
  import org.graalvm.compiler.lir.StandardOp.NoOp;
  import org.graalvm.compiler.lir.StandardOp.SaveRegistersOp;
  import org.graalvm.compiler.lir.SwitchStrategy;
  import org.graalvm.compiler.lir.Variable;
  import org.graalvm.compiler.lir.VirtualStackSlot;
  import org.graalvm.compiler.lir.amd64.AMD64AddressValue;
  import org.graalvm.compiler.lir.amd64.AMD64CCall;

*** 79,88 ****
--- 75,85 ----
  import org.graalvm.compiler.lir.amd64.AMD64SaveRegistersOp;
  import org.graalvm.compiler.lir.amd64.AMD64VZeroUpper;
  import org.graalvm.compiler.lir.asm.CompilationResultBuilder;
  import org.graalvm.compiler.lir.framemap.FrameMapBuilder;
  import org.graalvm.compiler.lir.gen.LIRGenerationResult;
+ import org.graalvm.compiler.options.OptionValues;
  
  import jdk.vm.ci.amd64.AMD64;
  import jdk.vm.ci.amd64.AMD64Kind;
  import jdk.vm.ci.code.CallingConvention;
  import jdk.vm.ci.code.Register;

*** 292,329 ****
--- 289,298 ----
              append(new AMD64VZeroUpper(arguments));
          }
          super.emitForeignCallOp(linkage, result, arguments, temps, info);
      }
  
      @Override
      public void emitLeaveCurrentStackFrame(SaveRegistersOp saveRegisterOp) {
          append(new AMD64HotSpotLeaveCurrentStackFrameOp(saveRegisterOp));
      }
  
      @Override
      public void emitLeaveDeoptimizedStackFrame(Value frameSize, Value initialInfo) {
          Variable frameSizeVariable = load(frameSize);
          Variable initialInfoVariable = load(initialInfo);
          append(new AMD64HotSpotLeaveDeoptimizedStackFrameOp(frameSizeVariable, initialInfoVariable));
      }
  
      @Override
      public void emitEnterUnpackFramesStackFrame(Value framePc, Value senderSp, Value senderFp, SaveRegistersOp saveRegisterOp) {
          Register threadRegister = getProviders().getRegisters().getThreadRegister();
          Variable framePcVariable = load(framePc);
          Variable senderSpVariable = load(senderSp);
          Variable senderFpVariable = load(senderFp);
          append(new AMD64HotSpotEnterUnpackFramesStackFrameOp(threadRegister, config.threadLastJavaSpOffset(), config.threadLastJavaPcOffset(), config.threadLastJavaFpOffset(), framePcVariable,
                          senderSpVariable, senderFpVariable, saveRegisterOp));
      }
  
      @Override
      public void emitLeaveUnpackFramesStackFrame(SaveRegistersOp saveRegisterOp) {
          Register threadRegister = getProviders().getRegisters().getThreadRegister();
          append(new AMD64HotSpotLeaveUnpackFramesStackFrameOp(threadRegister, config.threadLastJavaSpOffset(), config.threadLastJavaPcOffset(), config.threadLastJavaFpOffset(), saveRegisterOp));
      }
  
      /**
       * @param savedRegisters the registers saved by this operation which may be subject to pruning
       * @param savedRegisterLocations the slots to which the registers are saved
       * @param supportsRemove determines if registers can be pruned
       */

*** 357,373 ****
--- 326,335 ----
              savedRegisterLocations[i] = allocateSaveRegisterLocation(savedRegisters[i]);
          }
          return emitSaveRegisters(savedRegisters, savedRegisterLocations, supportsRemove);
      }
  
      @Override
      public SaveRegistersOp emitSaveAllRegisters() {
          // We are saving all registers.
          // TODO Save upper half of YMM registers.
          return emitSaveAllRegisters(target().arch.getAvailableValueRegisters().toArray(), false);
      }
  
      protected void emitRestoreRegisters(AMD64SaveRegistersOp save) {
          append(new AMD64RestoreRegistersOp(save.getSlots().clone(), save));
      }
  
      /**

*** 419,430 ****
--- 381,396 ----
  
          if (destroysRegisters) {
              if (stub != null) {
                  if (stub.preservesRegisters()) {
                      HotSpotLIRGenerationResult generationResult = getResult();
!                     assert !generationResult.getCalleeSaveInfo().containsKey(currentRuntimeCallInfo);
                      generationResult.getCalleeSaveInfo().put(currentRuntimeCallInfo, save);
!                     LIRFrameState key = currentRuntimeCallInfo;
+                     if (key == null) {
+                         key = LIRFrameState.NO_STATE;
+                     }
+                     assert !generationResult.getCalleeSaveInfo().containsKey(key);
+                     generationResult.getCalleeSaveInfo().put(key, save);
                      emitRestoreRegisters(save);
                  }
              }
          }
  

*** 509,550 ****
--- 475,484 ----
          append(timestamp);
          return emitMove(timestamp.getLowResult());
      }
  
      @Override
      public Value emitUncommonTrapCall(Value trapRequest, Value mode, SaveRegistersOp saveRegisterOp) {
          ForeignCallLinkage linkage = getForeignCalls().lookupForeignCall(UNCOMMON_TRAP);
  
          Register thread = getProviders().getRegisters().getThreadRegister();
          append(new AMD64HotSpotCRuntimeCallPrologueOp(config.threadLastJavaSpOffset(), thread));
          Variable result = super.emitForeignCall(linkage, null, thread.asValue(LIRKind.value(AMD64Kind.QWORD)), trapRequest, mode);
          append(new AMD64HotSpotCRuntimeCallEpilogueOp(config.threadLastJavaSpOffset(), config.threadLastJavaFpOffset(), config.threadLastJavaPcOffset(), thread));
  
          Map<LIRFrameState, SaveRegistersOp> calleeSaveInfo = getResult().getCalleeSaveInfo();
          assert !calleeSaveInfo.containsKey(currentRuntimeCallInfo);
          calleeSaveInfo.put(currentRuntimeCallInfo, saveRegisterOp);
  
          return result;
      }
  
      @Override
      public Value emitDeoptimizationFetchUnrollInfoCall(Value mode, SaveRegistersOp saveRegisterOp) {
          ForeignCallLinkage linkage = getForeignCalls().lookupForeignCall(FETCH_UNROLL_INFO);
  
          Register thread = getProviders().getRegisters().getThreadRegister();
          append(new AMD64HotSpotCRuntimeCallPrologueOp(config.threadLastJavaSpOffset(), thread));
          Variable result = super.emitForeignCall(linkage, null, thread.asValue(LIRKind.value(AMD64Kind.QWORD)), mode);
          append(new AMD64HotSpotCRuntimeCallEpilogueOp(config.threadLastJavaSpOffset(), config.threadLastJavaFpOffset(), config.threadLastJavaPcOffset(), thread));
  
          Map<LIRFrameState, SaveRegistersOp> calleeSaveInfo = getResult().getCalleeSaveInfo();
          assert !calleeSaveInfo.containsKey(currentRuntimeCallInfo);
          calleeSaveInfo.put(currentRuntimeCallInfo, saveRegisterOp);
  
          return result;
      }
  
      @Override
      public void emitTailcall(Value[] args, Value address) {
          append(new AMD64TailcallOp(args, address));
      }
  
      @Override

*** 619,644 ****
--- 553,569 ----
          if (BenchmarkCounters.enabled) {
              // ensure that the rescue slot is available
              LIRInstruction op = getOrInitRescueSlotOp();
              // insert dummy instruction into the start block
              LIR lir = getResult().getLIR();
!             ArrayList<LIRInstruction> instructions = lir.getLIRforBlock(lir.getControlFlowGraph().getStartBlock());
              instructions.add(1, op);
              Debug.dump(Debug.INFO_LOG_LEVEL, lir, "created rescue dummy op");
          }
      }
  
      @Override
      public void emitPushInterpreterFrame(Value frameSize, Value framePc, Value senderSp, Value initialInfo) {
          Variable frameSizeVariable = load(frameSize);
          Variable framePcVariable = load(framePc);
          Variable senderSpVariable = load(senderSp);
          Variable initialInfoVariable = load(initialInfo);
          append(new AMD64HotSpotPushInterpreterFrameOp(frameSizeVariable, framePcVariable, senderSpVariable, initialInfoVariable, config));
      }
  
      @Override
      public Value emitCompress(Value pointer, CompressEncoding encoding, boolean nonNull) {
          LIRKind inputKind = pointer.getValueKind(LIRKind.class);
          assert inputKind.getPlatformKind() == AMD64Kind.QWORD;
          if (inputKind.isReference(0)) {
              // oop

*** 647,664 ****
--- 572,590 ----
              return result;
          } else {
              // metaspace pointer
              Variable result = newVariable(LIRKind.value(AMD64Kind.DWORD));
              AllocatableValue base = Value.ILLEGAL;
              if (encoding.base != 0 || GeneratePIC.getValue()) {
!                 if (GeneratePIC.getValue()) {
+             OptionValues options = getResult().getLIR().getOptions();
!             if (encoding.hasBase() || GeneratePIC.getValue(options)) {
+                 if (GeneratePIC.getValue(options)) {
                      Variable baseAddress = newVariable(LIRKind.value(AMD64Kind.QWORD));
                      AMD64HotSpotMove.BaseMove move = new AMD64HotSpotMove.BaseMove(baseAddress, config);
                      append(move);
                      base = baseAddress;
                  } else {
!                     base = emitLoadConstant(LIRKind.value(AMD64Kind.QWORD), JavaConstant.forLong(encoding.base));
!                     base = emitLoadConstant(LIRKind.value(AMD64Kind.QWORD), JavaConstant.forLong(encoding.getBase()));
                  }
              }
              append(new AMD64HotSpotMove.CompressPointer(result, asAllocatable(pointer), base, encoding, nonNull));
              return result;
          }

*** 675,692 ****
--- 601,619 ----
              return result;
          } else {
              // metaspace pointer
              Variable result = newVariable(LIRKind.value(AMD64Kind.QWORD));
              AllocatableValue base = Value.ILLEGAL;
              if (encoding.base != 0 || GeneratePIC.getValue()) {
!                 if (GeneratePIC.getValue()) {
+             OptionValues options = getResult().getLIR().getOptions();
!             if (encoding.hasBase() || GeneratePIC.getValue(options)) {
+                 if (GeneratePIC.getValue(options)) {
                      Variable baseAddress = newVariable(LIRKind.value(AMD64Kind.QWORD));
                      AMD64HotSpotMove.BaseMove move = new AMD64HotSpotMove.BaseMove(baseAddress, config);
                      append(move);
                      base = baseAddress;
                  } else {
!                     base = emitLoadConstant(LIRKind.value(AMD64Kind.QWORD), JavaConstant.forLong(encoding.base));
!                     base = emitLoadConstant(LIRKind.value(AMD64Kind.QWORD), JavaConstant.forLong(encoding.getBase()));
                  }
              }
              append(new AMD64HotSpotMove.UncompressPointer(result, asAllocatable(pointer), base, encoding, nonNull));
              return result;
          }

*** 695,707 ****
--- 622,635 ----
      @Override
      public void emitNullCheck(Value address, LIRFrameState state) {
          if (address.getValueKind().getPlatformKind() == AMD64Kind.DWORD) {
              CompressEncoding encoding = config.getOopEncoding();
              Value uncompressed;
!             if (encoding.shift <= 3) {
!             if (encoding.getShift() <= 3) {
                  LIRKind wordKind = LIRKind.unknownReference(target().arch.getWordKind());
!                 uncompressed = new AMD64AddressValue(wordKind, getProviders().getRegisters().getHeapBaseRegister().asValue(wordKind), asAllocatable(address), Scale.fromInt(1 << encoding.shift), 0);
!                 uncompressed = new AMD64AddressValue(wordKind, getProviders().getRegisters().getHeapBaseRegister().asValue(wordKind), asAllocatable(address), Scale.fromInt(1 << encoding.getShift()),
+                                 0);
              } else {
                  uncompressed = emitUncompress(address, encoding, false);
              }
              append(new AMD64Move.NullCheckOp(asAddressValue(uncompressed), state));
          } else {