--- old/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot.sparc/src/jdk/vm/ci/hotspot/sparc/SPARCHotSpotRegisterConfig.java 2016-06-21 23:03:48.000000000 +0200 +++ new/src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot.sparc/src/jdk/vm/ci/hotspot/sparc/SPARCHotSpotRegisterConfig.java 2016-06-21 23:03:48.000000000 +0200 @@ -65,8 +65,6 @@ import static jdk.vm.ci.sparc.SPARC.sp; import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; import java.util.HashSet; import java.util.List; @@ -74,6 +72,7 @@ import jdk.vm.ci.code.CallingConvention; import jdk.vm.ci.code.CallingConvention.Type; import jdk.vm.ci.code.Register; +import jdk.vm.ci.code.RegisterArray; import jdk.vm.ci.code.RegisterAttributes; import jdk.vm.ci.code.RegisterConfig; import jdk.vm.ci.code.StackSlot; @@ -92,7 +91,7 @@ private final TargetDescription target; - private final Register[] allocatable; + private final RegisterArray allocatable; private final RegisterAttributes[] attributesMap; @@ -102,20 +101,19 @@ private final boolean addNativeRegisterArgumentSlots; @Override - public Register[] getAllocatableRegisters() { - return allocatable.clone(); + public RegisterArray getAllocatableRegisters() { + return allocatable; } @Override - public Register[] filterAllocatableRegisters(PlatformKind kind, Register[] registers) { + public RegisterArray filterAllocatableRegisters(PlatformKind kind, RegisterArray registers) { ArrayList list = new ArrayList<>(); for (Register reg : registers) { if (target.arch.canStoreValue(reg.getRegisterCategory(), kind)) { list.add(reg); } } - Register[] ret = list.toArray(new Register[list.size()]); - return ret; + return new RegisterArray(list); } @Override @@ -123,29 +121,29 @@ return attributesMap.clone(); } - private final Register[] cpuCallerParameterRegisters = {o0, o1, o2, o3, o4, o5}; - private final Register[] cpuCalleeParameterRegisters = {i0, i1, i2, i3, i4, i5}; + private final RegisterArray cpuCallerParameterRegisters = new RegisterArray(o0, o1, o2, o3, o4, o5); + private final RegisterArray cpuCalleeParameterRegisters = new RegisterArray(i0, i1, i2, i3, i4, i5); - private final Register[] fpuFloatParameterRegisters = {f0, f1, f2, f3, f4, f5, f6, f7}; - private final Register[] fpuDoubleParameterRegisters = {d0, null, d2, null, d4, null, d6, null}; + private final RegisterArray fpuFloatParameterRegisters = new RegisterArray(f0, f1, f2, f3, f4, f5, f6, f7); + private final RegisterArray fpuDoubleParameterRegisters = new RegisterArray(d0, null, d2, null, d4, null, d6, null); // @formatter:off - private final Register[] callerSaveRegisters; + private final RegisterArray callerSaveRegisters; /** * This lists all L and I registers which are saved in the register window. */ - private final Register[] windowSaveRegisters = { + private final RegisterArray windowSaveRegisters = new RegisterArray( l0, l1, l2, l3, l4, l5, l6, l7, - i0, i1, i2, i3, i4, i5, i6, i7}; + i0, i1, i2, i3, i4, i5, i6, i7); // @formatter:on - private static final Register[] reservedRegisters = {sp, g0, g2}; + private static final RegisterArray reservedRegisters = new RegisterArray(sp, g0, g2); - private static Register[] initAllocatable(Architecture arch, boolean reserveForHeapBase) { - Register[] allRegisters = arch.getAvailableValueRegisters(); - Register[] registers = new Register[allRegisters.length - reservedRegisters.length - (reserveForHeapBase ? 1 : 0)]; - List reservedRegistersList = Arrays.asList(reservedRegisters); + private static RegisterArray initAllocatable(Architecture arch, boolean reserveForHeapBase) { + RegisterArray allRegisters = arch.getAvailableValueRegisters(); + Register[] registers = new Register[allRegisters.size() - reservedRegisters.size() - (reserveForHeapBase ? 1 : 0)]; + List reservedRegistersList = reservedRegisters.asList(); int idx = 0; for (Register reg : allRegisters) { @@ -162,33 +160,32 @@ } assert idx == registers.length; - return registers; + return new RegisterArray(registers); } public SPARCHotSpotRegisterConfig(TargetDescription target, boolean useCompressedOops) { this(target, initAllocatable(target.arch, useCompressedOops)); } - public SPARCHotSpotRegisterConfig(TargetDescription target, Register[] allocatable) { + public SPARCHotSpotRegisterConfig(TargetDescription target, RegisterArray allocatable) { this.target = target; - this.allocatable = allocatable.clone(); + this.allocatable = allocatable; this.addNativeRegisterArgumentSlots = false; - HashSet callerSaveSet = new HashSet<>(); - Collections.addAll(callerSaveSet, target.arch.getAvailableValueRegisters()); + HashSet callerSaveSet = new HashSet<>(target.arch.getAvailableValueRegisters().asList()); for (Register cs : windowSaveRegisters) { callerSaveSet.remove(cs); } - this.callerSaveRegisters = callerSaveSet.toArray(new Register[callerSaveSet.size()]); + this.callerSaveRegisters = new RegisterArray(callerSaveSet); attributesMap = RegisterAttributes.createMap(this, SPARC.allRegisters); } @Override - public Register[] getCallerSaveRegisters() { + public RegisterArray getCallerSaveRegisters() { return callerSaveRegisters; } @Override - public Register[] getCalleeSaveRegisters() { + public RegisterArray getCalleeSaveRegisters() { return null; } @@ -210,7 +207,7 @@ } @Override - public Register[] getCallingConventionRegisters(Type type, JavaKind kind) { + public RegisterArray getCallingConventionRegisters(Type type, JavaKind kind) { HotSpotCallingConventionType hotspotType = (HotSpotCallingConventionType) type; switch (kind) { case Boolean: @@ -229,7 +226,7 @@ } } - private CallingConvention callingConvention(Register[] generalParameterRegisters, JavaType returnType, JavaType[] parameterTypes, HotSpotCallingConventionType type, + private CallingConvention callingConvention(RegisterArray generalParameterRegisters, JavaType returnType, JavaType[] parameterTypes, HotSpotCallingConventionType type, ValueKindFactory valueKindFactory) { AllocatableValue[] locations = new AllocatableValue[parameterTypes.length]; @@ -248,25 +245,25 @@ case Int: case Long: case Object: - if (currentGeneral < generalParameterRegisters.length) { - Register register = generalParameterRegisters[currentGeneral++]; + if (currentGeneral < generalParameterRegisters.size()) { + Register register = generalParameterRegisters.get(currentGeneral++); locations[i] = register.asValue(valueKindFactory.getValueKind(kind)); } break; case Double: - if (currentFloating < fpuFloatParameterRegisters.length) { + if (currentFloating < fpuFloatParameterRegisters.size()) { if (currentFloating % 2 != 0) { // Make register number even to be a double reg currentFloating++; } - Register register = fpuDoubleParameterRegisters[currentFloating]; + Register register = fpuDoubleParameterRegisters.get(currentFloating); currentFloating += 2; // Only every second is a double register locations[i] = register.asValue(valueKindFactory.getValueKind(kind)); } break; case Float: - if (currentFloating < fpuFloatParameterRegisters.length) { - Register register = fpuFloatParameterRegisters[currentFloating++]; + if (currentFloating < fpuFloatParameterRegisters.size()) { + Register register = fpuFloatParameterRegisters.get(currentFloating++); locations[i] = register.asValue(valueKindFactory.getValueKind(kind)); } break; @@ -291,7 +288,7 @@ int outArgSpillArea; if (type == HotSpotCallingConventionType.NativeCall && addNativeRegisterArgumentSlots) { // Space for native callee which may spill our outgoing arguments - outArgSpillArea = Math.min(locations.length, generalParameterRegisters.length) * target.wordSize; + outArgSpillArea = Math.min(locations.length, generalParameterRegisters.size()) * target.wordSize; } else { outArgSpillArea = 0; } @@ -336,6 +333,6 @@ @Override public String toString() { - return String.format("Allocatable: " + Arrays.toString(getAllocatableRegisters()) + "%n" + "CallerSave: " + Arrays.toString(getCallerSaveRegisters()) + "%n"); + return String.format("Allocatable: " + getAllocatableRegisters() + "%n" + "CallerSave: " + getCallerSaveRegisters() + "%n"); } }