< prev index next >
src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot.sparc/src/jdk/vm/ci/hotspot/sparc/SPARCHotSpotRegisterConfig.java
Print this page
*** 63,81 ****
import static jdk.vm.ci.sparc.SPARC.o4;
import static jdk.vm.ci.sparc.SPARC.o5;
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;
import jdk.vm.ci.code.Architecture;
import jdk.vm.ci.code.CallingConvention;
import jdk.vm.ci.code.CallingConvention.Type;
import jdk.vm.ci.code.Register;
import jdk.vm.ci.code.RegisterAttributes;
import jdk.vm.ci.code.RegisterConfig;
import jdk.vm.ci.code.StackSlot;
import jdk.vm.ci.code.TargetDescription;
import jdk.vm.ci.code.ValueKindFactory;
--- 63,80 ----
import static jdk.vm.ci.sparc.SPARC.o4;
import static jdk.vm.ci.sparc.SPARC.o5;
import static jdk.vm.ci.sparc.SPARC.sp;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import jdk.vm.ci.code.Architecture;
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;
import jdk.vm.ci.code.TargetDescription;
import jdk.vm.ci.code.ValueKindFactory;
*** 90,153 ****
public class SPARCHotSpotRegisterConfig implements RegisterConfig {
private final TargetDescription target;
! private final Register[] allocatable;
private final RegisterAttributes[] attributesMap;
/**
* Does native code (C++ code) spill arguments in registers to the parent frame?
*/
private final boolean addNativeRegisterArgumentSlots;
@Override
! public Register[] getAllocatableRegisters() {
! return allocatable.clone();
}
@Override
! public Register[] filterAllocatableRegisters(PlatformKind kind, Register[] registers) {
ArrayList<Register> 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;
}
@Override
public RegisterAttributes[] getAttributesMap() {
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 Register[] fpuFloatParameterRegisters = {f0, f1, f2, f3, f4, f5, f6, f7};
! private final Register[] fpuDoubleParameterRegisters = {d0, null, d2, null, d4, null, d6, null};
// @formatter:off
! private final Register[] callerSaveRegisters;
/**
* This lists all L and I registers which are saved in the register window.
*/
! private final Register[] windowSaveRegisters = {
l0, l1, l2, l3, l4, l5, l6, l7,
! i0, i1, i2, i3, i4, i5, i6, i7};
// @formatter:on
! private static final Register[] reservedRegisters = {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<Register> reservedRegistersList = Arrays.asList(reservedRegisters);
int idx = 0;
for (Register reg : allRegisters) {
if (reservedRegistersList.contains(reg)) {
// skip reserved registers
--- 89,151 ----
public class SPARCHotSpotRegisterConfig implements RegisterConfig {
private final TargetDescription target;
! private final RegisterArray allocatable;
private final RegisterAttributes[] attributesMap;
/**
* Does native code (C++ code) spill arguments in registers to the parent frame?
*/
private final boolean addNativeRegisterArgumentSlots;
@Override
! public RegisterArray getAllocatableRegisters() {
! return allocatable;
}
@Override
! public RegisterArray filterAllocatableRegisters(PlatformKind kind, RegisterArray registers) {
ArrayList<Register> list = new ArrayList<>();
for (Register reg : registers) {
if (target.arch.canStoreValue(reg.getRegisterCategory(), kind)) {
list.add(reg);
}
}
! return new RegisterArray(list);
}
@Override
public RegisterAttributes[] getAttributesMap() {
return attributesMap.clone();
}
! 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 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 RegisterArray callerSaveRegisters;
/**
* This lists all L and I registers which are saved in the register window.
*/
! private final RegisterArray windowSaveRegisters = new RegisterArray(
l0, l1, l2, l3, l4, l5, l6, l7,
! i0, i1, i2, i3, i4, i5, i6, i7);
// @formatter:on
! private static final RegisterArray reservedRegisters = new RegisterArray(sp, g0, g2);
! private static RegisterArray initAllocatable(Architecture arch, boolean reserveForHeapBase) {
! RegisterArray allRegisters = arch.getAvailableValueRegisters();
! Register[] registers = new Register[allRegisters.size() - reservedRegisters.size() - (reserveForHeapBase ? 1 : 0)];
! List<Register> reservedRegistersList = reservedRegisters.asList();
int idx = 0;
for (Register reg : allRegisters) {
if (reservedRegistersList.contains(reg)) {
// skip reserved registers
*** 160,196 ****
registers[idx++] = reg;
}
assert idx == registers.length;
! return registers;
}
public SPARCHotSpotRegisterConfig(TargetDescription target, boolean useCompressedOops) {
this(target, initAllocatable(target.arch, useCompressedOops));
}
! public SPARCHotSpotRegisterConfig(TargetDescription target, Register[] allocatable) {
this.target = target;
! this.allocatable = allocatable.clone();
this.addNativeRegisterArgumentSlots = false;
! HashSet<Register> callerSaveSet = new HashSet<>();
! Collections.addAll(callerSaveSet, target.arch.getAvailableValueRegisters());
for (Register cs : windowSaveRegisters) {
callerSaveSet.remove(cs);
}
! this.callerSaveRegisters = callerSaveSet.toArray(new Register[callerSaveSet.size()]);
attributesMap = RegisterAttributes.createMap(this, SPARC.allRegisters);
}
@Override
! public Register[] getCallerSaveRegisters() {
return callerSaveRegisters;
}
@Override
! public Register[] getCalleeSaveRegisters() {
return null;
}
@Override
public boolean areAllAllocatableRegistersCallerSaved() {
--- 158,193 ----
registers[idx++] = reg;
}
assert idx == registers.length;
! return new RegisterArray(registers);
}
public SPARCHotSpotRegisterConfig(TargetDescription target, boolean useCompressedOops) {
this(target, initAllocatable(target.arch, useCompressedOops));
}
! public SPARCHotSpotRegisterConfig(TargetDescription target, RegisterArray allocatable) {
this.target = target;
! this.allocatable = allocatable;
this.addNativeRegisterArgumentSlots = false;
! HashSet<Register> callerSaveSet = new HashSet<>(target.arch.getAvailableValueRegisters().asList());
for (Register cs : windowSaveRegisters) {
callerSaveSet.remove(cs);
}
! this.callerSaveRegisters = new RegisterArray(callerSaveSet);
attributesMap = RegisterAttributes.createMap(this, SPARC.allRegisters);
}
@Override
! public RegisterArray getCallerSaveRegisters() {
return callerSaveRegisters;
}
@Override
! public RegisterArray getCalleeSaveRegisters() {
return null;
}
@Override
public boolean areAllAllocatableRegistersCallerSaved() {
*** 208,218 ****
}
throw JVMCIError.shouldNotReachHere();
}
@Override
! public Register[] getCallingConventionRegisters(Type type, JavaKind kind) {
HotSpotCallingConventionType hotspotType = (HotSpotCallingConventionType) type;
switch (kind) {
case Boolean:
case Byte:
case Short:
--- 205,215 ----
}
throw JVMCIError.shouldNotReachHere();
}
@Override
! public RegisterArray getCallingConventionRegisters(Type type, JavaKind kind) {
HotSpotCallingConventionType hotspotType = (HotSpotCallingConventionType) type;
switch (kind) {
case Boolean:
case Byte:
case Short:
*** 227,237 ****
default:
throw JVMCIError.shouldNotReachHere("Unknown JavaKind " + kind);
}
}
! private CallingConvention callingConvention(Register[] generalParameterRegisters, JavaType returnType, JavaType[] parameterTypes, HotSpotCallingConventionType type,
ValueKindFactory<?> valueKindFactory) {
AllocatableValue[] locations = new AllocatableValue[parameterTypes.length];
int currentGeneral = 0;
int currentFloating = 0;
--- 224,234 ----
default:
throw JVMCIError.shouldNotReachHere("Unknown JavaKind " + kind);
}
}
! private CallingConvention callingConvention(RegisterArray generalParameterRegisters, JavaType returnType, JavaType[] parameterTypes, HotSpotCallingConventionType type,
ValueKindFactory<?> valueKindFactory) {
AllocatableValue[] locations = new AllocatableValue[parameterTypes.length];
int currentGeneral = 0;
int currentFloating = 0;
*** 246,274 ****
case Short:
case Char:
case Int:
case Long:
case Object:
! if (currentGeneral < generalParameterRegisters.length) {
! Register register = generalParameterRegisters[currentGeneral++];
locations[i] = register.asValue(valueKindFactory.getValueKind(kind));
}
break;
case Double:
! if (currentFloating < fpuFloatParameterRegisters.length) {
if (currentFloating % 2 != 0) {
// Make register number even to be a double reg
currentFloating++;
}
! Register register = fpuDoubleParameterRegisters[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++];
locations[i] = register.asValue(valueKindFactory.getValueKind(kind));
}
break;
default:
throw JVMCIError.shouldNotReachHere();
--- 243,271 ----
case Short:
case Char:
case Int:
case Long:
case Object:
! if (currentGeneral < generalParameterRegisters.size()) {
! Register register = generalParameterRegisters.get(currentGeneral++);
locations[i] = register.asValue(valueKindFactory.getValueKind(kind));
}
break;
case Double:
! if (currentFloating < fpuFloatParameterRegisters.size()) {
if (currentFloating % 2 != 0) {
// Make register number even to be a double reg
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.size()) {
! Register register = fpuFloatParameterRegisters.get(currentFloating++);
locations[i] = register.asValue(valueKindFactory.getValueKind(kind));
}
break;
default:
throw JVMCIError.shouldNotReachHere();
*** 289,299 ****
AllocatableValue returnLocation = returnKind == Void ? ILLEGAL : getReturnRegister(returnKind, type).asValue(valueKindFactory.getValueKind(returnKind.getStackKind()));
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;
} else {
outArgSpillArea = 0;
}
return new CallingConvention(currentStackOffset + outArgSpillArea, returnLocation, locations);
}
--- 286,296 ----
AllocatableValue returnLocation = returnKind == Void ? ILLEGAL : getReturnRegister(returnKind, type).asValue(valueKindFactory.getValueKind(returnKind.getStackKind()));
int outArgSpillArea;
if (type == HotSpotCallingConventionType.NativeCall && addNativeRegisterArgumentSlots) {
// Space for native callee which may spill our outgoing arguments
! outArgSpillArea = Math.min(locations.length, generalParameterRegisters.size()) * target.wordSize;
} else {
outArgSpillArea = 0;
}
return new CallingConvention(currentStackOffset + outArgSpillArea, returnLocation, locations);
}
*** 334,341 ****
return sp;
}
@Override
public String toString() {
! return String.format("Allocatable: " + Arrays.toString(getAllocatableRegisters()) + "%n" + "CallerSave: " + Arrays.toString(getCallerSaveRegisters()) + "%n");
}
}
--- 331,338 ----
return sp;
}
@Override
public String toString() {
! return String.format("Allocatable: " + getAllocatableRegisters() + "%n" + "CallerSave: " + getCallerSaveRegisters() + "%n");
}
}
< prev index next >