src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.hotspot.sparc/src/org/graalvm/compiler/hotspot/sparc/SPARCHotSpotBackend.java

*** 20,36 ****
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  package org.graalvm.compiler.hotspot.sparc;
  
- import static org.graalvm.compiler.asm.sparc.SPARCAssembler.BPCC;
- import static org.graalvm.compiler.asm.sparc.SPARCAssembler.isGlobalRegister;
- import static org.graalvm.compiler.asm.sparc.SPARCAssembler.Annul.NOT_ANNUL;
- import static org.graalvm.compiler.asm.sparc.SPARCAssembler.BranchPredict.PREDICT_NOT_TAKEN;
- import static org.graalvm.compiler.asm.sparc.SPARCAssembler.CC.Xcc;
- import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.NotEqual;
- import static org.graalvm.compiler.core.common.GraalOptions.ZapStackOnMethodEntry;
  import static jdk.vm.ci.code.ValueUtil.asRegister;
  import static jdk.vm.ci.code.ValueUtil.isRegister;
  import static jdk.vm.ci.sparc.SPARC.g0;
  import static jdk.vm.ci.sparc.SPARC.g5;
  import static jdk.vm.ci.sparc.SPARC.i0;
--- 20,29 ----
*** 38,51 ****
  import static jdk.vm.ci.sparc.SPARC.l0;
  import static jdk.vm.ci.sparc.SPARC.l7;
  import static jdk.vm.ci.sparc.SPARC.o0;
  import static jdk.vm.ci.sparc.SPARC.o7;
  import static jdk.vm.ci.sparc.SPARC.sp;
  
  import java.util.HashSet;
- import java.util.List;
- import java.util.Map;
  import java.util.Set;
  import java.util.concurrent.ConcurrentHashMap;
  
  import org.graalvm.compiler.asm.Assembler;
  import org.graalvm.compiler.asm.Label;
--- 31,50 ----
  import static jdk.vm.ci.sparc.SPARC.l0;
  import static jdk.vm.ci.sparc.SPARC.l7;
  import static jdk.vm.ci.sparc.SPARC.o0;
  import static jdk.vm.ci.sparc.SPARC.o7;
  import static jdk.vm.ci.sparc.SPARC.sp;
+ import static org.graalvm.compiler.asm.sparc.SPARCAssembler.BPCC;
+ import static org.graalvm.compiler.asm.sparc.SPARCAssembler.isGlobalRegister;
+ import static org.graalvm.compiler.asm.sparc.SPARCAssembler.Annul.NOT_ANNUL;
+ import static org.graalvm.compiler.asm.sparc.SPARCAssembler.BranchPredict.PREDICT_NOT_TAKEN;
+ import static org.graalvm.compiler.asm.sparc.SPARCAssembler.CC.Xcc;
+ import static org.graalvm.compiler.asm.sparc.SPARCAssembler.ConditionFlag.NotEqual;
+ import static org.graalvm.compiler.core.common.GraalOptions.ZapStackOnMethodEntry;
  
+ import java.util.ArrayList;
  import java.util.HashSet;
  import java.util.Set;
  import java.util.concurrent.ConcurrentHashMap;
  
  import org.graalvm.compiler.asm.Assembler;
  import org.graalvm.compiler.asm.Label;
*** 60,74 ****
  import org.graalvm.compiler.core.common.alloc.RegisterAllocationConfig;
  import org.graalvm.compiler.core.common.cfg.AbstractBlockBase;
  import org.graalvm.compiler.core.sparc.SPARCNodeMatchRules;
  import org.graalvm.compiler.debug.Debug;
  import org.graalvm.compiler.debug.DebugCounter;
  import org.graalvm.compiler.hotspot.HotSpotDataBuilder;
  import org.graalvm.compiler.hotspot.HotSpotGraalRuntimeProvider;
  import org.graalvm.compiler.hotspot.HotSpotHostBackend;
  import org.graalvm.compiler.hotspot.HotSpotLIRGenerationResult;
- import org.graalvm.compiler.hotspot.GraalHotSpotVMConfig;
  import org.graalvm.compiler.hotspot.meta.HotSpotForeignCallsProvider;
  import org.graalvm.compiler.hotspot.meta.HotSpotProviders;
  import org.graalvm.compiler.hotspot.stubs.Stub;
  import org.graalvm.compiler.lir.InstructionValueConsumer;
  import org.graalvm.compiler.lir.LIR;
--- 59,73 ----
  import org.graalvm.compiler.core.common.alloc.RegisterAllocationConfig;
  import org.graalvm.compiler.core.common.cfg.AbstractBlockBase;
  import org.graalvm.compiler.core.sparc.SPARCNodeMatchRules;
  import org.graalvm.compiler.debug.Debug;
  import org.graalvm.compiler.debug.DebugCounter;
+ import org.graalvm.compiler.hotspot.GraalHotSpotVMConfig;
  import org.graalvm.compiler.hotspot.HotSpotDataBuilder;
  import org.graalvm.compiler.hotspot.HotSpotGraalRuntimeProvider;
  import org.graalvm.compiler.hotspot.HotSpotHostBackend;
  import org.graalvm.compiler.hotspot.HotSpotLIRGenerationResult;
  import org.graalvm.compiler.hotspot.meta.HotSpotForeignCallsProvider;
  import org.graalvm.compiler.hotspot.meta.HotSpotProviders;
  import org.graalvm.compiler.hotspot.stubs.Stub;
  import org.graalvm.compiler.lir.InstructionValueConsumer;
  import org.graalvm.compiler.lir.LIR;
*** 90,99 ****
--- 89,102 ----
  import org.graalvm.compiler.lir.sparc.SPARCLIRInstructionMixin;
  import org.graalvm.compiler.lir.sparc.SPARCLIRInstructionMixin.SizeEstimate;
  import org.graalvm.compiler.lir.sparc.SPARCTailDelayedLIRInstruction;
  import org.graalvm.compiler.nodes.StructuredGraph;
  import org.graalvm.compiler.nodes.spi.NodeLIRBuilderTool;
+ import org.graalvm.compiler.options.OptionValues;
+ import org.graalvm.util.EconomicMap;
+ import org.graalvm.util.EconomicSet;
+ import org.graalvm.util.Equivalence;
  
  import jdk.vm.ci.code.CallingConvention;
  import jdk.vm.ci.code.Register;
  import jdk.vm.ci.code.RegisterConfig;
  import jdk.vm.ci.code.StackSlot;
*** 201,211 ****
                      masm.setx(stackpoinerChange, scratch, false);
                      masm.save(sp, scratch, sp);
                  }
              }
  
!             if (ZapStackOnMethodEntry.getValue()) {
                  final int slotSize = 8;
                  for (int i = 0; i < frameSize / slotSize; ++i) {
                      // 0xC1C1C1C1
                      masm.stx(g0, new SPARCAddress(sp, i * slotSize));
                  }
--- 204,214 ----
                      masm.setx(stackpoinerChange, scratch, false);
                      masm.save(sp, scratch, sp);
                  }
              }
  
!             if (ZapStackOnMethodEntry.getValue(crb.getOptions())) {
                  final int slotSize = 8;
                  for (int i = 0; i < frameSize / slotSize; ++i) {
                      // 0xC1C1C1C1
                      masm.stx(g0, new SPARCAddress(sp, i * slotSize));
                  }
*** 233,254 ****
          Stub stub = gen.getStub();
          Assembler masm = createAssembler(frameMap);
          // On SPARC we always use stack frames.
          HotSpotFrameContext frameContext = new HotSpotFrameContext(stub != null);
          DataBuilder dataBuilder = new HotSpotDataBuilder(getCodeCache().getTarget());
!         CompilationResultBuilder crb = factory.createBuilder(getProviders().getCodeCache(), getProviders().getForeignCalls(), frameMap, masm, dataBuilder, frameContext, 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) {
              // Even on sparc we need to save floating point registers
!             Set<Register> destroyedCallerRegisters = gatherDestroyedCallerRegisters(lir);
!             Map<LIRFrameState, SaveRegistersOp> calleeSaveInfo = gen.getCalleeSaveInfo();
              updateStub(stub, destroyedCallerRegisters, calleeSaveInfo, frameMap);
          }
          assert registerSizePredictionValidator(crb);
          return crb;
      }
--- 236,258 ----
          Stub stub = gen.getStub();
          Assembler masm = createAssembler(frameMap);
          // On SPARC we always use stack frames.
          HotSpotFrameContext frameContext = new HotSpotFrameContext(stub != null);
          DataBuilder dataBuilder = new HotSpotDataBuilder(getCodeCache().getTarget());
!         OptionValues options = lir.getOptions();
!         CompilationResultBuilder crb = factory.createBuilder(getProviders().getCodeCache(), getProviders().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) {
              // Even on sparc we need to save floating point registers
!             EconomicSet<Register> destroyedCallerRegisters = gatherDestroyedCallerRegisters(lir);
!             EconomicMap<LIRFrameState, SaveRegistersOp> calleeSaveInfo = gen.getCalleeSaveInfo();
              updateStub(stub, destroyedCallerRegisters, calleeSaveInfo, frameMap);
          }
          assert registerSizePredictionValidator(crb);
          return crb;
      }
*** 419,429 ****
       * Tries to put DelayedControlTransfer instructions and DelayableLIRInstructions together. Also
       * it tries to move the DelayedLIRInstruction to the DelayedControlTransfer instruction, if
       * possible.
       */
      private static void stuffDelayedControlTransfers(LIR l, AbstractBlockBase<?> block) {
!         List<LIRInstruction> instructions = l.getLIRforBlock(block);
          if (instructions.size() >= 2) {
              LIRDependencyAccumulator acc = new LIRDependencyAccumulator();
              SPARCDelayedControlTransfer delayedTransfer = null;
              int delayTransferPosition = -1;
              for (int i = instructions.size() - 1; i >= 0; i--) {
--- 423,433 ----
       * Tries to put DelayedControlTransfer instructions and DelayableLIRInstructions together. Also
       * it tries to move the DelayedLIRInstruction to the DelayedControlTransfer instruction, if
       * possible.
       */
      private static void stuffDelayedControlTransfers(LIR l, AbstractBlockBase<?> block) {
!         ArrayList<LIRInstruction> instructions = l.getLIRforBlock(block);
          if (instructions.size() >= 2) {
              LIRDependencyAccumulator acc = new LIRDependencyAccumulator();
              SPARCDelayedControlTransfer delayedTransfer = null;
              int delayTransferPosition = -1;
              for (int i = instructions.size() - 1; i >= 0; i--) {
*** 495,512 ****
              return overlap;
          }
      }
  
      @Override
!     public RegisterAllocationConfig newRegisterAllocationConfig(RegisterConfig registerConfig) {
          RegisterConfig registerConfigNonNull = registerConfig == null ? getCodeCache().getRegisterConfig() : registerConfig;
!         return new SPARCHotSpotRegisterAllocationConfig(registerConfigNonNull);
      }
  
      @Override
!     public Set<Register> translateToCallerRegisters(Set<Register> calleeRegisters) {
!         HashSet<Register> callerRegisters = new HashSet<>(calleeRegisters.size());
          for (Register register : calleeRegisters) {
              if (l0.number <= register.number && register.number <= l7.number) {
                  // do nothing
              } else if (o0.number <= register.number && register.number <= o7.number) {
                  // do nothing
--- 499,516 ----
              return overlap;
          }
      }
  
      @Override
!     public RegisterAllocationConfig newRegisterAllocationConfig(RegisterConfig registerConfig, String[] allocationRestrictedTo) {
          RegisterConfig registerConfigNonNull = registerConfig == null ? getCodeCache().getRegisterConfig() : registerConfig;
!         return new SPARCHotSpotRegisterAllocationConfig(registerConfigNonNull, allocationRestrictedTo);
      }
  
      @Override
!     public EconomicSet<Register> translateToCallerRegisters(EconomicSet<Register> calleeRegisters) {
!         EconomicSet<Register> callerRegisters = EconomicSet.create(Equivalence.IDENTITY, calleeRegisters.size());
          for (Register register : calleeRegisters) {
              if (l0.number <= register.number && register.number <= l7.number) {
                  // do nothing
              } else if (o0.number <= register.number && register.number <= o7.number) {
                  // do nothing