src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.core.common/src/org/graalvm/compiler/core/common/alloc/RegisterAllocationConfig.java

*** 20,41 ****
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  package org.graalvm.compiler.core.common.alloc;
  
! import static org.graalvm.compiler.core.common.GraalOptions.RegisterPressure;
! 
! import java.util.HashMap;
! import java.util.Map;
  
  import jdk.vm.ci.code.Register;
  import jdk.vm.ci.code.RegisterArray;
  import jdk.vm.ci.code.RegisterConfig;
  import jdk.vm.ci.meta.PlatformKind;
  
- import org.graalvm.compiler.core.common.GraalOptions;
- 
  /**
   * Configuration for register allocation. This is different to {@link RegisterConfig} as it only
   * returns registers specified by {@link GraalOptions#RegisterPressure}.
   */
  public class RegisterAllocationConfig {
--- 20,38 ----
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  package org.graalvm.compiler.core.common.alloc;
  
! import org.graalvm.compiler.core.common.GraalOptions;
! import org.graalvm.util.EconomicMap;
! import org.graalvm.util.Equivalence;
  
  import jdk.vm.ci.code.Register;
  import jdk.vm.ci.code.RegisterArray;
  import jdk.vm.ci.code.RegisterConfig;
  import jdk.vm.ci.meta.PlatformKind;
  
  /**
   * Configuration for register allocation. This is different to {@link RegisterConfig} as it only
   * returns registers specified by {@link GraalOptions#RegisterPressure}.
   */
  public class RegisterAllocationConfig {
*** 80,108 ****
          }
          throw new IllegalArgumentException("register " + name + " is not allocatable");
      }
  
      protected RegisterArray initAllocatable(RegisterArray registers) {
!         if (RegisterPressure.getValue() != null && !RegisterPressure.getValue().equals(ALL_REGISTERS)) {
!             String[] names = RegisterPressure.getValue().split(",");
!             Register[] regs = new Register[names.length];
!             for (int i = 0; i < names.length; i++) {
!                 regs[i] = findRegister(names[i], registers);
              }
              return new RegisterArray(regs);
          }
  
          return registers;
      }
  
      protected final RegisterConfig registerConfig;
!     private final Map<PlatformKind.Key, AllocatableRegisters> categorized = new HashMap<>();
      private RegisterArray cachedRegisters;
  
!     public RegisterAllocationConfig(RegisterConfig registerConfig) {
          assert registerConfig != null;
          this.registerConfig = registerConfig;
      }
  
      /**
       * Gets the set of registers that can be used by the register allocator for a value of a
       * particular kind.
--- 77,110 ----
          }
          throw new IllegalArgumentException("register " + name + " is not allocatable");
      }
  
      protected RegisterArray initAllocatable(RegisterArray registers) {
!         if (allocationRestrictedTo != null) {
!             Register[] regs = new Register[allocationRestrictedTo.length];
!             for (int i = 0; i < allocationRestrictedTo.length; i++) {
!                 regs[i] = findRegister(allocationRestrictedTo[i], registers);
              }
              return new RegisterArray(regs);
          }
  
          return registers;
      }
  
      protected final RegisterConfig registerConfig;
!     private final EconomicMap<PlatformKind.Key, AllocatableRegisters> categorized = EconomicMap.create(Equivalence.DEFAULT);
!     private final String[] allocationRestrictedTo;
      private RegisterArray cachedRegisters;
  
!     /**
!      * @param allocationRestrictedTo if not {@code null}, register allocation will be restricted to
!      *            registers whose names appear in this array
!      */
!     public RegisterAllocationConfig(RegisterConfig registerConfig, String[] allocationRestrictedTo) {
          assert registerConfig != null;
          this.registerConfig = registerConfig;
+         this.allocationRestrictedTo = allocationRestrictedTo;
      }
  
      /**
       * Gets the set of registers that can be used by the register allocator for a value of a
       * particular kind.