Mercurial > hg > graal-jvmci-8

comparison jvmci/jdk.vm.ci.hotspot.sparc/src/jdk/vm/ci/hotspot/sparc/SPARCHotSpotRegisterConfig.java @ 23700:9e1235406b59

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[Findbugs] various warnings reported for JVMCI sources (JDK-8159613)
author Doug Simon <doug.simon@oracle.com>
date Sat, 18 Jun 2016 13:19:01 +0200
parents 3426a4ab05c3
children 1140503536ae
comparison
equal deleted inserted replaced
23699:8f9709f61cd4 23700:9e1235406b59
87 import static jdk.vm.ci.sparc.SPARC.o4; 87 import static jdk.vm.ci.sparc.SPARC.o4;
88 import static jdk.vm.ci.sparc.SPARC.o5; 88 import static jdk.vm.ci.sparc.SPARC.o5;
89 import static jdk.vm.ci.sparc.SPARC.sp; 89 import static jdk.vm.ci.sparc.SPARC.sp;
90 90
91 import java.util.ArrayList; 91 import java.util.ArrayList;
92 import java.util.Arrays;
93 import java.util.Collections;
94 import java.util.HashSet; 92 import java.util.HashSet;
95 import java.util.List; 93 import java.util.List;
96 94
97 import jdk.vm.ci.code.Architecture; 95 import jdk.vm.ci.code.Architecture;
98 import jdk.vm.ci.code.CallingConvention; 96 import jdk.vm.ci.code.CallingConvention;
99 import jdk.vm.ci.code.CallingConvention.Type; 97 import jdk.vm.ci.code.CallingConvention.Type;
100 import jdk.vm.ci.code.Register; 98 import jdk.vm.ci.code.Register;
99 import jdk.vm.ci.code.RegisterArray;
101 import jdk.vm.ci.code.RegisterAttributes; 100 import jdk.vm.ci.code.RegisterAttributes;
102 import jdk.vm.ci.code.RegisterConfig; 101 import jdk.vm.ci.code.RegisterConfig;
103 import jdk.vm.ci.code.StackSlot; 102 import jdk.vm.ci.code.StackSlot;
104 import jdk.vm.ci.code.TargetDescription; 103 import jdk.vm.ci.code.TargetDescription;
105 import jdk.vm.ci.code.ValueKindFactory; 104 import jdk.vm.ci.code.ValueKindFactory;
114 113
115 public class SPARCHotSpotRegisterConfig implements RegisterConfig { 114 public class SPARCHotSpotRegisterConfig implements RegisterConfig {
116 115
117 private final TargetDescription target; 116 private final TargetDescription target;
118 117
119 private final Register[] allocatable; 118 private final RegisterArray allocatable;
120 119
121 private final RegisterAttributes[] attributesMap; 120 private final RegisterAttributes[] attributesMap;
122 121
123 @Override 122 @Override
124 public Register[] getAllocatableRegisters() { 123 public RegisterArray getAllocatableRegisters() {
125 return allocatable.clone(); 124 return allocatable;
126 } 125 }
127 126
128 @Override 127 @Override
129 public Register[] filterAllocatableRegisters(PlatformKind kind, Register[] registers) { 128 public RegisterArray filterAllocatableRegisters(PlatformKind kind, RegisterArray registers) {
130 ArrayList<Register> list = new ArrayList<>(); 129 ArrayList<Register> list = new ArrayList<>();
131 for (Register reg : registers) { 130 for (Register reg : registers) {
132 if (target.arch.canStoreValue(reg.getRegisterCategory(), kind)) { 131 if (target.arch.canStoreValue(reg.getRegisterCategory(), kind)) {
133 list.add(reg); 132 list.add(reg);
134 } 133 }
135 } 134 }
136 Register[] ret = list.toArray(new Register[list.size()]); 135 return new RegisterArray(list);
137 return ret;
138 } 136 }
139 137
140 @Override 138 @Override
141 public RegisterAttributes[] getAttributesMap() { 139 public RegisterAttributes[] getAttributesMap() {
142 return attributesMap.clone(); 140 return attributesMap.clone();
143 } 141 }
144 142
145 private final Register[] cpuCallerParameterRegisters = {o0, o1, o2, o3, o4, o5}; 143 private final RegisterArray cpuCallerParameterRegisters = new RegisterArray(o0, o1, o2, o3, o4, o5);
146 private final Register[] cpuCalleeParameterRegisters = {i0, i1, i2, i3, i4, i5}; 144 private final RegisterArray cpuCalleeParameterRegisters = new RegisterArray(i0, i1, i2, i3, i4, i5);
147 145
148 private final Register[] fpuFloatJavaParameterRegisters = {f0, f1, f2, f3, f4, f5, f6, f7}; 146 private final RegisterArray fpuFloatJavaParameterRegisters = new RegisterArray(f0, f1, f2, f3, f4, f5, f6, f7);
149 private final Register[] fpuDoubleJavaParameterRegisters = {d0, null, d2, null, d4, null, d6, null}; 147 private final RegisterArray fpuDoubleJavaParameterRegisters = new RegisterArray(d0, null, d2, null, d4, null, d6, null);
150 148
151 // @formatter:off 149 // @formatter:off
152 private final Register[] fpuFloatNativeParameterRegisters = { 150 private final RegisterArray fpuFloatNativeParameterRegisters = new RegisterArray(
153 f1, f3, f5, f7, f9, f11, f13, f15, 151 f1, f3, f5, f7, f9, f11, f13, f15,
154 f17, f19, f21, f23, f25, f27, f29, f31}; 152 f17, f19, f21, f23, f25, f27, f29, f31);
155 153
156 private final Register[] fpuDoubleNativeParameterRegisters = { 154 private final RegisterArray fpuDoubleNativeParameterRegisters = new RegisterArray(
157 d0, d2, d4, d6, d8, d10, d12, d14, 155 d0, d2, d4, d6, d8, d10, d12, d14,
158 d16, d18, d20, d22, d24, d26, d28, d30}; 156 d16, d18, d20, d22, d24, d26, d28, d30);
159 157
160 private final Register[] callerSaveRegisters; 158 private final RegisterArray callerSaveRegisters;
161 159
162 /** 160 /**
163 * This lists all L and I registers which are saved in the register window. 161 * This lists all L and I registers which are saved in the register window.
164 */ 162 */
165 private final Register[] windowSaveRegisters = { 163 private final RegisterArray windowSaveRegisters = new RegisterArray(
166 l0, l1, l2, l3, l4, l5, l6, l7, 164 l0, l1, l2, l3, l4, l5, l6, l7,
167 i0, i1, i2, i3, i4, i5, i6, i7}; 165 i0, i1, i2, i3, i4, i5, i6, i7);
168 // @formatter:on 166 // @formatter:on
169 167
170 private static final Register[] reservedRegisters = {sp, g0, g2}; 168 private static final RegisterArray reservedRegisters = new RegisterArray(sp, g0, g2);
171 169
172 private static Register[] initAllocatable(Architecture arch, boolean reserveForHeapBase) { 170 private static RegisterArray initAllocatable(Architecture arch, boolean reserveForHeapBase) {
173 Register[] allRegisters = arch.getAvailableValueRegisters(); 171 RegisterArray allRegisters = arch.getAvailableValueRegisters();
174 Register[] registers = new Register[allRegisters.length - reservedRegisters.length - (reserveForHeapBase ? 1 : 0)]; 172 Register[] registers = new Register[allRegisters.size() - reservedRegisters.size() - (reserveForHeapBase ? 1 : 0)];
175 List<Register> reservedRegistersList = Arrays.asList(reservedRegisters); 173 List<Register> reservedRegistersList = reservedRegisters.asList();
176 174
177 int idx = 0; 175 int idx = 0;
178 for (Register reg : allRegisters) { 176 for (Register reg : allRegisters) {
179 if (reservedRegistersList.contains(reg)) { 177 if (reservedRegistersList.contains(reg)) {
180 // skip reserved registers 178 // skip reserved registers
187 185
188 registers[idx++] = reg; 186 registers[idx++] = reg;
189 } 187 }
190 188
191 assert idx == registers.length; 189 assert idx == registers.length;
192 return registers; 190 return new RegisterArray(registers);
193 } 191 }
194 192
195 public SPARCHotSpotRegisterConfig(TargetDescription target, boolean useCompressedOops) { 193 public SPARCHotSpotRegisterConfig(TargetDescription target, boolean useCompressedOops) {
196 this(target, initAllocatable(target.arch, useCompressedOops)); 194 this(target, initAllocatable(target.arch, useCompressedOops));
197 } 195 }
198 196
199 public SPARCHotSpotRegisterConfig(TargetDescription target, Register[] allocatable) { 197 public SPARCHotSpotRegisterConfig(TargetDescription target, RegisterArray allocatable) {
200 this.target = target; 198 this.target = target;
201 this.allocatable = allocatable.clone(); 199 this.allocatable = allocatable;
202 HashSet<Register> callerSaveSet = new HashSet<>(); 200 HashSet<Register> callerSaveSet = new HashSet<>();
203 Collections.addAll(callerSaveSet, target.arch.getAvailableValueRegisters()); 201 target.arch.getAvailableValueRegisters().addTo(callerSaveSet);
204 for (Register cs : windowSaveRegisters) { 202 for (Register cs : windowSaveRegisters) {
205 callerSaveSet.remove(cs); 203 callerSaveSet.remove(cs);
206 } 204 }
207 this.callerSaveRegisters = callerSaveSet.toArray(new Register[callerSaveSet.size()]); 205 this.callerSaveRegisters = new RegisterArray(callerSaveSet);
208 attributesMap = RegisterAttributes.createMap(this, SPARC.allRegisters); 206 attributesMap = RegisterAttributes.createMap(this, SPARC.allRegisters);
209 } 207 }
210 208
211 @Override 209 @Override
212 public Register[] getCallerSaveRegisters() { 210 public RegisterArray getCallerSaveRegisters() {
213 return callerSaveRegisters; 211 return callerSaveRegisters;
214 } 212 }
215 213
216 @Override 214 @Override
217 public Register[] getCalleeSaveRegisters() { 215 public RegisterArray getCalleeSaveRegisters() {
218 return null; 216 return null;
219 } 217 }
220 218
221 @Override 219 @Override
222 public boolean areAllAllocatableRegistersCallerSaved() { 220 public boolean areAllAllocatableRegistersCallerSaved() {
234 } 232 }
235 throw JVMCIError.shouldNotReachHere(); 233 throw JVMCIError.shouldNotReachHere();
236 } 234 }
237 235
238 @Override 236 @Override
239 public Register[] getCallingConventionRegisters(Type type, JavaKind kind) { 237 public RegisterArray getCallingConventionRegisters(Type type, JavaKind kind) {
240 HotSpotCallingConventionType hotspotType = (HotSpotCallingConventionType) type; 238 HotSpotCallingConventionType hotspotType = (HotSpotCallingConventionType) type;
241 switch (kind) { 239 switch (kind) {
242 case Boolean: 240 case Boolean:
243 case Byte: 241 case Byte:
244 case Short: 242 case Short:
253 default: 251 default:
254 throw JVMCIError.shouldNotReachHere("Unknown JavaKind " + kind); 252 throw JVMCIError.shouldNotReachHere("Unknown JavaKind " + kind);
255 } 253 }
256 } 254 }
257 255
258 private CallingConvention callingConvention(Register[] generalParameterRegisters, JavaType returnType, JavaType[] parameterTypes, HotSpotCallingConventionType type, 256 private CallingConvention callingConvention(RegisterArray generalParameterRegisters, JavaType returnType, JavaType[] parameterTypes, HotSpotCallingConventionType type,
259 ValueKindFactory<?> valueKindFactory) { 257 ValueKindFactory<?> valueKindFactory) {
260 AllocatableValue[] locations = new AllocatableValue[parameterTypes.length]; 258 AllocatableValue[] locations = new AllocatableValue[parameterTypes.length];
261 259
262 int currentGeneral = 0; 260 int currentGeneral = 0;
263 int currentFloating = 0; 261 int currentFloating = 0;
265 boolean isNative = type == HotSpotCallingConventionType.NativeCall; 263 boolean isNative = type == HotSpotCallingConventionType.NativeCall;
266 264
267 for (int i = 0; i < parameterTypes.length; i++) { 265 for (int i = 0; i < parameterTypes.length; i++) {
268 final JavaKind kind = parameterTypes[i].getJavaKind().getStackKind(); 266 final JavaKind kind = parameterTypes[i].getJavaKind().getStackKind();
269 if (isNative) { 267 if (isNative) {
270 Register[] registerSet; 268 RegisterArray registerSet;
271 switch (kind) { 269 switch (kind) {
272 case Byte: 270 case Byte:
273 case Boolean: 271 case Boolean:
274 case Short: 272 case Short:
275 case Char: 273 case Char:
285 registerSet = fpuFloatNativeParameterRegisters; 283 registerSet = fpuFloatNativeParameterRegisters;
286 break; 284 break;
287 default: 285 default:
288 throw JVMCIError.shouldNotReachHere(); 286 throw JVMCIError.shouldNotReachHere();
289 } 287 }
290 if (i < registerSet.length) { 288 if (i < registerSet.size()) {
291 locations[i] = registerSet[i].asValue(valueKindFactory.getValueKind(kind)); 289 locations[i] = registerSet.get(i).asValue(valueKindFactory.getValueKind(kind));
292 currentStackOffset += target.arch.getWordSize(); 290 currentStackOffset += target.arch.getWordSize();
293 } 291 }
294 } else { 292 } else {
295 switch (kind) { 293 switch (kind) {
296 case Byte: 294 case Byte:
298 case Short: 296 case Short:
299 case Char: 297 case Char:
300 case Int: 298 case Int:
301 case Long: 299 case Long:
302 case Object: 300 case Object:
303 if (currentGeneral < generalParameterRegisters.length) { 301 if (currentGeneral < generalParameterRegisters.size()) {
304 Register register = generalParameterRegisters[currentGeneral++]; 302 Register register = generalParameterRegisters.get(currentGeneral++);
305 locations[i] = register.asValue(valueKindFactory.getValueKind(kind)); 303 locations[i] = register.asValue(valueKindFactory.getValueKind(kind));
306 } 304 }
307 break; 305 break;
308 case Double: 306 case Double:
309 if (currentFloating < fpuFloatJavaParameterRegisters.length) { 307 if (currentFloating < fpuFloatJavaParameterRegisters.size()) {
310 if (currentFloating % 2 != 0) { 308 if (currentFloating % 2 != 0) {
311 // Make register number even to be a double reg 309 // Make register number even to be a double reg
312 currentFloating++; 310 currentFloating++;
313 } 311 }
314 Register register = fpuDoubleJavaParameterRegisters[currentFloating]; 312 Register register = fpuDoubleJavaParameterRegisters.get(currentFloating);
315 currentFloating += 2; // Only every second is a double register 313 currentFloating += 2; // Only every second is a double register
316 locations[i] = register.asValue(valueKindFactory.getValueKind(kind)); 314 locations[i] = register.asValue(valueKindFactory.getValueKind(kind));
317 } 315 }
318 break; 316 break;
319 case Float: 317 case Float:
320 if (currentFloating < fpuFloatJavaParameterRegisters.length) { 318 if (currentFloating < fpuFloatJavaParameterRegisters.size()) {
321 Register register = fpuFloatJavaParameterRegisters[currentFloating++]; 319 Register register = fpuFloatJavaParameterRegisters.get(currentFloating++);
322 locations[i] = register.asValue(valueKindFactory.getValueKind(kind)); 320 locations[i] = register.asValue(valueKindFactory.getValueKind(kind));
323 } 321 }
324 break; 322 break;
325 default: 323 default:
326 throw JVMCIError.shouldNotReachHere(); 324 throw JVMCIError.shouldNotReachHere();
381 return sp; 379 return sp;
382 } 380 }
383 381
384 @Override 382 @Override
385 public String toString() { 383 public String toString() {
386 return String.format("Allocatable: " + Arrays.toString(getAllocatableRegisters()) + "%n" + "CallerSave: " + Arrays.toString(getCallerSaveRegisters()) + "%n"); 384 return String.format("Allocatable: " + getAllocatableRegisters() + "%n" + "CallerSave: " + getCallerSaveRegisters() + "%n");
387 } 385 }
388 } 386 }