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

*** 28,39 ****
--- 28,37 ----
  import static jdk.vm.ci.amd64.AMD64.r10;
  import static jdk.vm.ci.amd64.AMD64.rax;
  import static jdk.vm.ci.amd64.AMD64.rsp;
  import static jdk.vm.ci.code.ValueUtil.asRegister;
  
  import java.util.Set;
  
  import org.graalvm.compiler.asm.Assembler;
  import org.graalvm.compiler.asm.Label;
  import org.graalvm.compiler.asm.amd64.AMD64Address;
  import org.graalvm.compiler.asm.amd64.AMD64Assembler.ConditionFlag;
  import org.graalvm.compiler.asm.amd64.AMD64MacroAssembler;

*** 64,73 ****
--- 62,73 ----
  import org.graalvm.compiler.lir.framemap.FrameMapBuilder;
  import org.graalvm.compiler.lir.gen.LIRGenerationResult;
  import org.graalvm.compiler.lir.gen.LIRGeneratorTool;
  import org.graalvm.compiler.nodes.StructuredGraph;
  import org.graalvm.compiler.nodes.spi.NodeLIRBuilderTool;
+ import org.graalvm.compiler.options.OptionValues;
+ import org.graalvm.util.EconomicSet;
  
  import jdk.vm.ci.amd64.AMD64;
  import jdk.vm.ci.amd64.AMD64Kind;
  import jdk.vm.ci.code.CallingConvention;
  import jdk.vm.ci.code.Register;

*** 168,178 ****
--- 168,178 ----
                      asm.subqWide(rsp, frameSize);
                      assert asm.position() - verifiedEntryPointOffset >= PATCHED_VERIFIED_ENTRY_POINT_INSTRUCTION_SIZE;
                  } else {
                      asm.decrementq(rsp, frameSize);
                  }
!                 if (ZapStackOnMethodEntry.getValue(crb.getOptions())) {
                      final int intSize = 4;
                      for (int i = 0; i < frameSize / intSize; ++i) {
                          asm.movl(new AMD64Address(rsp, i * intSize), 0xC1C1C1C1);
                      }
                  }

*** 206,231 ****
--- 206,232 ----
          // - has no deoptimization points
          // - makes no foreign calls (which require an aligned stack)
          HotSpotLIRGenerationResult gen = (HotSpotLIRGenerationResult) lirGenRen;
          LIR lir = gen.getLIR();
          assert gen.getDeoptimizationRescueSlot() == null || frameMap.frameNeedsAllocating() : "method that can deoptimize must have a frame";
!         boolean omitFrame = CanOmitFrame.getValue() && !frameMap.frameNeedsAllocating() && !lir.hasArgInCallerFrame() && !gen.hasForeignCall();
!         OptionValues options = lir.getOptions();
+         boolean omitFrame = CanOmitFrame.getValue(options) && !frameMap.frameNeedsAllocating() && !lir.hasArgInCallerFrame() && !gen.hasForeignCall();
  
          Stub stub = gen.getStub();
          Assembler masm = createAssembler(frameMap);
          HotSpotFrameContext frameContext = new HotSpotFrameContext(stub != null, omitFrame);
          DataBuilder dataBuilder = new HotSpotDataBuilder(getCodeCache().getTarget());
!         CompilationResultBuilder crb = factory.createBuilder(getCodeCache(), getForeignCalls(), frameMap, masm, dataBuilder, frameContext, options, compilationResult);
          crb.setTotalFrameSize(frameMap.totalFrameSize());
          crb.setMaxInterpreterFrameSize(gen.getMaxInterpreterFrameSize());
          StackSlot deoptimizationRescueSlot = gen.getDeoptimizationRescueSlot();
          if (deoptimizationRescueSlot != null && stub == null) {
              crb.compilationResult.setCustomStackAreaOffset(deoptimizationRescueSlot);
          }
  
          if (stub != null) {
!             EconomicSet<Register> destroyedCallerRegisters = gatherDestroyedCallerRegisters(lir);
              updateStub(stub, destroyedCallerRegisters, gen.getCalleeSaveInfo(), frameMap);
          }
  
          return crb;
      }

*** 266,276 ****
--- 267,277 ----
              AMD64Address src = new AMD64Address(receiver, config.hubOffset);
  
              if (config.useCompressedClassPointers) {
                  Register register = r10;
                  AMD64HotSpotMove.decodeKlassPointer(crb, asm, register, providers.getRegisters().getHeapBaseRegister(), src, config);
!                 if (GeneratePIC.getValue(crb.getOptions())) {
                      asm.movq(providers.getRegisters().getHeapBaseRegister(), asm.getPlaceholder(-1));
                      crb.recordMark(config.MARKID_NARROW_OOP_BASE_ADDRESS);
                  } else {
                      if (config.narrowKlassBase != 0) {
                          // The heap base register was destroyed above, so restore it

*** 287,297 ****
--- 288,298 ----
          asm.align(config.codeEntryAlignment);
          crb.recordMark(config.MARKID_OSR_ENTRY);
          asm.bind(verifiedEntry);
          crb.recordMark(config.MARKID_VERIFIED_ENTRY);
  
!         if (GeneratePIC.getValue(crb.getOptions())) {
              // Check for method state
              HotSpotFrameContext frameContext = (HotSpotFrameContext) crb.frameContext;
              if (!frameContext.isStub) {
                  crb.recordInlineDataInCodeWithNote(new HotSpotSentinelConstant(LIRKind.value(AMD64Kind.QWORD), JavaKind.Long), HotSpotConstantLoadAction.MAKE_NOT_ENTRANT);
                  asm.movq(AMD64.rax, asm.getPlaceholder(-1));

*** 332,346 ****
--- 333,347 ----
              }
          }
      }
  
      @Override
!     public RegisterAllocationConfig newRegisterAllocationConfig(RegisterConfig registerConfig, String[] allocationRestrictedTo) {
          RegisterConfig registerConfigNonNull = registerConfig == null ? getCodeCache().getRegisterConfig() : registerConfig;
!         return new AMD64HotSpotRegisterAllocationConfig(registerConfigNonNull, allocationRestrictedTo);
      }
  
      @Override
!     public EconomicSet<Register> translateToCallerRegisters(EconomicSet<Register> calleeRegisters) {
          return calleeRegisters;
      }
  }