< prev index next >
src/jdk.vm.ci/share/classes/jdk.vm.ci.hotspot.amd64/src/jdk/vm/ci/hotspot/amd64/AMD64HotSpotRegisterConfig.java
Print this page
*** 40,59 ****
import static jdk.vm.ci.amd64.AMD64.xmm5;
import static jdk.vm.ci.amd64.AMD64.xmm6;
import static jdk.vm.ci.amd64.AMD64.xmm7;
import java.util.ArrayList;
- import java.util.Arrays;
- import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
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;
--- 40,58 ----
import static jdk.vm.ci.amd64.AMD64.xmm5;
import static jdk.vm.ci.amd64.AMD64.xmm6;
import static jdk.vm.ci.amd64.AMD64.xmm7;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
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;
*** 68,127 ****
public class AMD64HotSpotRegisterConfig implements RegisterConfig {
private final TargetDescription target;
! private final Register[] allocatable;
/**
* The caller saved registers always include all parameter registers.
*/
! private final Register[] callerSaved;
private final boolean allAllocatableAreCallerSaved;
private final RegisterAttributes[] attributesMap;
@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[] javaGeneralParameterRegisters;
! private final Register[] nativeGeneralParameterRegisters;
! private final Register[] xmmParameterRegisters = {xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7};
/*
* Some ABIs (e.g. Windows) require a so-called "home space", that is a save area on the stack
* to store the argument registers
*/
private final boolean needsNativeStackHomeSpace;
! private static final Register[] reservedRegisters = {rsp, r15};
! 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
--- 67,126 ----
public class AMD64HotSpotRegisterConfig implements RegisterConfig {
private final TargetDescription target;
! private final RegisterArray allocatable;
/**
* The caller saved registers always include all parameter registers.
*/
! private final RegisterArray callerSaved;
private final boolean allAllocatableAreCallerSaved;
private final RegisterAttributes[] attributesMap;
@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);
}
}
! RegisterArray ret = new RegisterArray(list);
return ret;
}
@Override
public RegisterAttributes[] getAttributesMap() {
return attributesMap.clone();
}
! private final RegisterArray javaGeneralParameterRegisters;
! private final RegisterArray nativeGeneralParameterRegisters;
! private final RegisterArray xmmParameterRegisters = new RegisterArray(xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7);
/*
* Some ABIs (e.g. Windows) require a so-called "home space", that is a save area on the stack
* to store the argument registers
*/
private final boolean needsNativeStackHomeSpace;
! private static final RegisterArray reservedRegisters = new RegisterArray(rsp, r15);
! 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
*** 134,183 ****
registers[idx++] = reg;
}
assert idx == registers.length;
! return registers;
}
public AMD64HotSpotRegisterConfig(TargetDescription target, boolean useCompressedOops, boolean windowsOs) {
this(target, initAllocatable(target.arch, useCompressedOops), windowsOs);
! assert callerSaved.length >= allocatable.length;
}
! public AMD64HotSpotRegisterConfig(TargetDescription target, Register[] allocatable, boolean windowsOs) {
this.target = target;
if (windowsOs) {
! javaGeneralParameterRegisters = new Register[]{rdx, r8, r9, rdi, rsi, rcx};
! nativeGeneralParameterRegisters = new Register[]{rcx, rdx, r8, r9};
this.needsNativeStackHomeSpace = true;
} else {
! javaGeneralParameterRegisters = new Register[]{rsi, rdx, rcx, r8, r9, rdi};
! nativeGeneralParameterRegisters = new Register[]{rdi, rsi, rdx, rcx, r8, r9};
this.needsNativeStackHomeSpace = false;
}
this.allocatable = allocatable;
Set<Register> callerSaveSet = new HashSet<>();
! Collections.addAll(callerSaveSet, allocatable);
! Collections.addAll(callerSaveSet, xmmParameterRegisters);
! Collections.addAll(callerSaveSet, javaGeneralParameterRegisters);
! Collections.addAll(callerSaveSet, nativeGeneralParameterRegisters);
! callerSaved = callerSaveSet.toArray(new Register[callerSaveSet.size()]);
allAllocatableAreCallerSaved = true;
attributesMap = RegisterAttributes.createMap(this, target.arch.getRegisters());
}
@Override
! public Register[] getCallerSaveRegisters() {
return callerSaved;
}
@Override
! public Register[] getCalleeSaveRegisters() {
return null;
}
@Override
public boolean areAllAllocatableRegistersCallerSaved() {
--- 133,182 ----
registers[idx++] = reg;
}
assert idx == registers.length;
! return new RegisterArray(registers);
}
public AMD64HotSpotRegisterConfig(TargetDescription target, boolean useCompressedOops, boolean windowsOs) {
this(target, initAllocatable(target.arch, useCompressedOops), windowsOs);
! assert callerSaved.size() >= allocatable.size();
}
! public AMD64HotSpotRegisterConfig(TargetDescription target, RegisterArray allocatable, boolean windowsOs) {
this.target = target;
if (windowsOs) {
! javaGeneralParameterRegisters = new RegisterArray(rdx, r8, r9, rdi, rsi, rcx);
! nativeGeneralParameterRegisters = new RegisterArray(rcx, rdx, r8, r9);
this.needsNativeStackHomeSpace = true;
} else {
! javaGeneralParameterRegisters = new RegisterArray(rsi, rdx, rcx, r8, r9, rdi);
! nativeGeneralParameterRegisters = new RegisterArray(rdi, rsi, rdx, rcx, r8, r9);
this.needsNativeStackHomeSpace = false;
}
this.allocatable = allocatable;
Set<Register> callerSaveSet = new HashSet<>();
! allocatable.addTo(callerSaveSet);
! xmmParameterRegisters.addTo(callerSaveSet);
! callerSaveSet.addAll(javaGeneralParameterRegisters.asList());
! nativeGeneralParameterRegisters.addTo(callerSaveSet);
! callerSaved = new RegisterArray(callerSaveSet);
allAllocatableAreCallerSaved = true;
attributesMap = RegisterAttributes.createMap(this, target.arch.getRegisters());
}
@Override
! public RegisterArray getCallerSaveRegisters() {
return callerSaved;
}
@Override
! public RegisterArray getCalleeSaveRegisters() {
return null;
}
@Override
public boolean areAllAllocatableRegistersCallerSaved() {
*** 194,204 ****
// from the caller or callee perspective
return callingConvention(javaGeneralParameterRegisters, returnType, parameterTypes, hotspotType, valueKindFactory);
}
@Override
! public Register[] getCallingConventionRegisters(Type type, JavaKind kind) {
HotSpotCallingConventionType hotspotType = (HotSpotCallingConventionType) type;
switch (kind) {
case Boolean:
case Byte:
case Short:
--- 193,203 ----
// from the caller or callee perspective
return callingConvention(javaGeneralParameterRegisters, returnType, parameterTypes, hotspotType, valueKindFactory);
}
@Override
! public RegisterArray getCallingConventionRegisters(Type type, JavaKind kind) {
HotSpotCallingConventionType hotspotType = (HotSpotCallingConventionType) type;
switch (kind) {
case Boolean:
case Byte:
case Short:
*** 213,229 ****
default:
throw JVMCIError.shouldNotReachHere();
}
}
! private CallingConvention callingConvention(Register[] generalParameterRegisters, JavaType returnType, JavaType[] parameterTypes, HotSpotCallingConventionType type,
ValueKindFactory<?> valueKindFactory) {
AllocatableValue[] locations = new AllocatableValue[parameterTypes.length];
int currentGeneral = 0;
int currentXMM = 0;
! int currentStackOffset = type == HotSpotCallingConventionType.NativeCall && needsNativeStackHomeSpace ? generalParameterRegisters.length * target.wordSize : 0;
for (int i = 0; i < parameterTypes.length; i++) {
final JavaKind kind = parameterTypes[i].getJavaKind().getStackKind();
switch (kind) {
--- 212,228 ----
default:
throw JVMCIError.shouldNotReachHere();
}
}
! private CallingConvention callingConvention(RegisterArray generalParameterRegisters, JavaType returnType, JavaType[] parameterTypes, HotSpotCallingConventionType type,
ValueKindFactory<?> valueKindFactory) {
AllocatableValue[] locations = new AllocatableValue[parameterTypes.length];
int currentGeneral = 0;
int currentXMM = 0;
! int currentStackOffset = type == HotSpotCallingConventionType.NativeCall && needsNativeStackHomeSpace ? generalParameterRegisters.size() * target.wordSize : 0;
for (int i = 0; i < parameterTypes.length; i++) {
final JavaKind kind = parameterTypes[i].getJavaKind().getStackKind();
switch (kind) {
*** 232,250 ****
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 Float:
case Double:
! if (currentXMM < xmmParameterRegisters.length) {
! Register register = xmmParameterRegisters[currentXMM++];
locations[i] = register.asValue(valueKindFactory.getValueKind(kind));
}
break;
default:
throw JVMCIError.shouldNotReachHere();
--- 231,249 ----
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 Float:
case Double:
! if (currentXMM < xmmParameterRegisters.size()) {
! Register register = xmmParameterRegisters.get(currentXMM++);
locations[i] = register.asValue(valueKindFactory.getValueKind(kind));
}
break;
default:
throw JVMCIError.shouldNotReachHere();
*** 289,296 ****
return rsp;
}
@Override
public String toString() {
! return String.format("Allocatable: " + Arrays.toString(getAllocatableRegisters()) + "%n" + "CallerSave: " + Arrays.toString(getCallerSaveRegisters()) + "%n");
}
}
--- 288,295 ----
return rsp;
}
@Override
public String toString() {
! return String.format("Allocatable: " + getAllocatableRegisters() + "%n" + "CallerSave: " + getCallerSaveRegisters() + "%n");
}
}
< prev index next >