Mercurial > hg > graal-jvmci-8

comparison jvmci/jdk.vm.ci.hotspot.sparc/src/jdk/vm/ci/hotspot/sparc/SPARCHotSpotRegisterConfig.java @ 22672:1bbd4a7c274b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Rename jdk.internal.jvmci to jdk.vm.ci
author Tom Rodriguez <tom.rodriguez@oracle.com>
date Thu, 08 Oct 2015 17:28:41 -0700
parents jvmci/jdk.internal.jvmci.hotspot.sparc/src/jdk/internal/jvmci/hotspot/sparc/SPARCHotSpotRegisterConfig.java@a215c16882e0
children 4688478ecb7b
comparison
equal deleted inserted replaced
22671:97f30e4d0e95 22672:1bbd4a7c274b
1 /*
2 * Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23 package jdk.vm.ci.hotspot.sparc;
24
25 import static jdk.vm.ci.sparc.SPARC.FPUd;
26 import static jdk.vm.ci.sparc.SPARC.FPUs;
27 import static jdk.vm.ci.sparc.SPARC.d0;
28 import static jdk.vm.ci.sparc.SPARC.d2;
29 import static jdk.vm.ci.sparc.SPARC.d32;
30 import static jdk.vm.ci.sparc.SPARC.d34;
31 import static jdk.vm.ci.sparc.SPARC.d36;
32 import static jdk.vm.ci.sparc.SPARC.d38;
33 import static jdk.vm.ci.sparc.SPARC.d4;
34 import static jdk.vm.ci.sparc.SPARC.d40;
35 import static jdk.vm.ci.sparc.SPARC.d42;
36 import static jdk.vm.ci.sparc.SPARC.d44;
37 import static jdk.vm.ci.sparc.SPARC.d46;
38 import static jdk.vm.ci.sparc.SPARC.d48;
39 import static jdk.vm.ci.sparc.SPARC.d50;
40 import static jdk.vm.ci.sparc.SPARC.d52;
41 import static jdk.vm.ci.sparc.SPARC.d54;
42 import static jdk.vm.ci.sparc.SPARC.d56;
43 import static jdk.vm.ci.sparc.SPARC.d58;
44 import static jdk.vm.ci.sparc.SPARC.d6;
45 import static jdk.vm.ci.sparc.SPARC.d60;
46 import static jdk.vm.ci.sparc.SPARC.d62;
47 import static jdk.vm.ci.sparc.SPARC.f0;
48 import static jdk.vm.ci.sparc.SPARC.f1;
49 import static jdk.vm.ci.sparc.SPARC.f10;
50 import static jdk.vm.ci.sparc.SPARC.f11;
51 import static jdk.vm.ci.sparc.SPARC.f12;
52 import static jdk.vm.ci.sparc.SPARC.f13;
53 import static jdk.vm.ci.sparc.SPARC.f14;
54 import static jdk.vm.ci.sparc.SPARC.f15;
55 import static jdk.vm.ci.sparc.SPARC.f16;
56 import static jdk.vm.ci.sparc.SPARC.f17;
57 import static jdk.vm.ci.sparc.SPARC.f18;
58 import static jdk.vm.ci.sparc.SPARC.f19;
59 import static jdk.vm.ci.sparc.SPARC.f2;
60 import static jdk.vm.ci.sparc.SPARC.f20;
61 import static jdk.vm.ci.sparc.SPARC.f21;
62 import static jdk.vm.ci.sparc.SPARC.f22;
63 import static jdk.vm.ci.sparc.SPARC.f23;
64 import static jdk.vm.ci.sparc.SPARC.f24;
65 import static jdk.vm.ci.sparc.SPARC.f25;
66 import static jdk.vm.ci.sparc.SPARC.f26;
67 import static jdk.vm.ci.sparc.SPARC.f27;
68 import static jdk.vm.ci.sparc.SPARC.f28;
69 import static jdk.vm.ci.sparc.SPARC.f29;
70 import static jdk.vm.ci.sparc.SPARC.f3;
71 import static jdk.vm.ci.sparc.SPARC.f30;
72 import static jdk.vm.ci.sparc.SPARC.f31;
73 import static jdk.vm.ci.sparc.SPARC.f4;
74 import static jdk.vm.ci.sparc.SPARC.f5;
75 import static jdk.vm.ci.sparc.SPARC.f6;
76 import static jdk.vm.ci.sparc.SPARC.f7;
77 import static jdk.vm.ci.sparc.SPARC.f8;
78 import static jdk.vm.ci.sparc.SPARC.f9;
79 import static jdk.vm.ci.sparc.SPARC.g1;
80 import static jdk.vm.ci.sparc.SPARC.g2;
81 import static jdk.vm.ci.sparc.SPARC.g3;
82 import static jdk.vm.ci.sparc.SPARC.g4;
83 import static jdk.vm.ci.sparc.SPARC.g5;
84 import static jdk.vm.ci.sparc.SPARC.g6;
85 import static jdk.vm.ci.sparc.SPARC.g7;
86 import static jdk.vm.ci.sparc.SPARC.i0;
87 import static jdk.vm.ci.sparc.SPARC.i1;
88 import static jdk.vm.ci.sparc.SPARC.i2;
89 import static jdk.vm.ci.sparc.SPARC.i3;
90 import static jdk.vm.ci.sparc.SPARC.i4;
91 import static jdk.vm.ci.sparc.SPARC.i5;
92 import static jdk.vm.ci.sparc.SPARC.i6;
93 import static jdk.vm.ci.sparc.SPARC.i7;
94 import static jdk.vm.ci.sparc.SPARC.l0;
95 import static jdk.vm.ci.sparc.SPARC.l1;
96 import static jdk.vm.ci.sparc.SPARC.l2;
97 import static jdk.vm.ci.sparc.SPARC.l3;
98 import static jdk.vm.ci.sparc.SPARC.l4;
99 import static jdk.vm.ci.sparc.SPARC.l5;
100 import static jdk.vm.ci.sparc.SPARC.l6;
101 import static jdk.vm.ci.sparc.SPARC.l7;
102 import static jdk.vm.ci.sparc.SPARC.o0;
103 import static jdk.vm.ci.sparc.SPARC.o1;
104 import static jdk.vm.ci.sparc.SPARC.o2;
105 import static jdk.vm.ci.sparc.SPARC.o3;
106 import static jdk.vm.ci.sparc.SPARC.o4;
107 import static jdk.vm.ci.sparc.SPARC.o5;
108 import static jdk.vm.ci.sparc.SPARC.o7;
109 import static jdk.vm.ci.sparc.SPARC.sp;
110
111 import java.util.ArrayList;
112 import java.util.Arrays;
113
114 import jdk.vm.ci.code.Architecture;
115 import jdk.vm.ci.code.CallingConvention;
116 import jdk.vm.ci.code.CallingConvention.Type;
117 import jdk.vm.ci.code.Register;
118 import jdk.vm.ci.code.RegisterAttributes;
119 import jdk.vm.ci.code.RegisterConfig;
120 import jdk.vm.ci.code.StackSlot;
121 import jdk.vm.ci.code.TargetDescription;
122 import jdk.vm.ci.common.JVMCIError;
123 import jdk.vm.ci.hotspot.HotSpotVMConfig;
124 import jdk.vm.ci.meta.AllocatableValue;
125 import jdk.vm.ci.meta.JavaKind;
126 import jdk.vm.ci.meta.JavaType;
127 import jdk.vm.ci.meta.LIRKind;
128 import jdk.vm.ci.meta.PlatformKind;
129 import jdk.vm.ci.meta.Value;
130 import jdk.vm.ci.sparc.SPARC;
131 import jdk.vm.ci.sparc.SPARCKind;
132
133 public class SPARCHotSpotRegisterConfig implements RegisterConfig {
134
135 private final Architecture architecture;
136
137 private final Register[] allocatable;
138
139 private final RegisterAttributes[] attributesMap;
140
141 @Override
142 public Register[] getAllocatableRegisters() {
143 return allocatable.clone();
144 }
145
146 public Register[] filterAllocatableRegisters(PlatformKind kind, Register[] registers) {
147 ArrayList<Register> list = new ArrayList<>();
148 for (Register reg : registers) {
149 if (architecture.canStoreValue(reg.getRegisterCategory(), kind)) {
150 // Special treatment for double precision
151 // TODO: This is wasteful it uses only half of the registers as float.
152 if (kind == SPARCKind.DOUBLE) {
153 if (reg.getRegisterCategory().equals(FPUd)) {
154 list.add(reg);
155 }
156 } else if (kind == SPARCKind.SINGLE) {
157 if (reg.getRegisterCategory().equals(FPUs)) {
158 list.add(reg);
159 }
160 } else {
161 list.add(reg);
162 }
163 }
164 }
165
166 Register[] ret = list.toArray(new Register[list.size()]);
167 return ret;
168 }
169
170 @Override
171 public RegisterAttributes[] getAttributesMap() {
172 return attributesMap.clone();
173 }
174
175 private final Register[] cpuCallerParameterRegisters = {o0, o1, o2, o3, o4, o5};
176 private final Register[] cpuCalleeParameterRegisters = {i0, i1, i2, i3, i4, i5};
177
178 private final Register[] fpuParameterRegisters = {f0, f1, f2, f3, f4, f5, f6, f7};
179 private final Register[] fpuDoubleParameterRegisters = {d0, null, d2, null, d4, null, d6, null};
180 // @formatter:off
181 private final Register[] callerSaveRegisters =
182 {g1, g2, g3, g4, g5, g6, g7,
183 o0, o1, o2, o3, o4, o5, o7,
184 f0, f1, f2, f3, f4, f5, f6, f7,
185 f8, f9, f10, f11, f12, f13, f14, f15,
186 f16, f17, f18, f19, f20, f21, f22, f23,
187 f24, f25, f26, f27, f28, f29, f30, f31,
188 d32, d34, d36, d38, d40, d42, d44, d46,
189 d48, d50, d52, d54, d56, d58, d60, d62};
190 // @formatter:on
191
192 /**
193 * Registers saved by the callee. This lists all L and I registers which are saved in the
194 * register window.
195 */
196 private final Register[] calleeSaveRegisters = {l0, l1, l2, l3, l4, l5, l6, l7, i0, i1, i2, i3, i4, i5, i6, i7};
197
198 private static Register[] initAllocatable(boolean reserveForHeapBase) {
199 Register[] registers = null;
200 if (reserveForHeapBase) {
201 // @formatter:off
202 registers = new Register[]{
203 // TODO this is not complete
204 // o7 cannot be used as register because it is always overwritten on call
205 // and the current register handler would ignore this fact if the called
206 // method still does not modify registers, in fact o7 is modified by the Call instruction
207 // There would be some extra handlin necessary to be able to handle the o7 properly for local usage
208 g1, g4, g5,
209 o0, o1, o2, o3, o4, o5, /*o6,o7,*/
210 l0, l1, l2, l3, l4, l5, l6, l7,
211 i0, i1, i2, i3, i4, i5, /*i6,*/ /*i7,*/
212 //f0, f1, f2, f3, f4, f5, f6, f7,
213 f8, f9, f10, f11, f12, f13, f14, f15,
214 f16, f17, f18, f19, f20, f21, f22, f23,
215 f24, f25, f26, f27, f28, f29, f30, f31,
216 d32, d34, d36, d38, d40, d42, d44, d46,
217 d48, d50, d52, d54, d56, d58, d60, d62
218 };
219 // @formatter:on
220 } else {
221 // @formatter:off
222 registers = new Register[]{
223 // TODO this is not complete
224 g1, g4, g5,
225 o0, o1, o2, o3, o4, o5, /*o6, o7,*/
226 l0, l1, l2, l3, l4, l5, l6, l7,
227 i0, i1, i2, i3, i4, i5, /*i6,*/ /*i7,*/
228 // f0, f1, f2, f3, f4, f5, f6, f7
229 f8, f9, f10, f11, f12, f13, f14, f15,
230 f16, f17, f18, f19, f20, f21, f22, f23,
231 f24, f25, f26, f27, f28, f29, f30, f31,
232 d32, d34, d36, d38, d40, d42, d44, d46,
233 d48, d50, d52, d54, d56, d58, d60, d62
234 };
235 // @formatter:on
236 }
237
238 return registers;
239 }
240
241 public SPARCHotSpotRegisterConfig(TargetDescription target, HotSpotVMConfig config) {
242 this(target, initAllocatable(config.useCompressedOops));
243 }
244
245 public SPARCHotSpotRegisterConfig(TargetDescription target, Register[] allocatable) {
246 this.architecture = target.arch;
247 this.allocatable = allocatable.clone();
248 attributesMap = RegisterAttributes.createMap(this, SPARC.allRegisters);
249 }
250
251 @Override
252 public Register[] getCallerSaveRegisters() {
253 return callerSaveRegisters;
254 }
255
256 public Register[] getCalleeSaveRegisters() {
257 return calleeSaveRegisters;
258 }
259
260 @Override
261 public boolean areAllAllocatableRegistersCallerSaved() {
262 return false;
263 }
264
265 @Override
266 public Register getRegisterForRole(int index) {
267 throw new UnsupportedOperationException();
268 }
269
270 @Override
271 public CallingConvention getCallingConvention(Type type, JavaType returnType, JavaType[] parameterTypes, TargetDescription target, boolean stackOnly) {
272 if (type == Type.JavaCall || type == Type.NativeCall) {
273 return callingConvention(cpuCallerParameterRegisters, returnType, parameterTypes, type, target, stackOnly);
274 }
275 if (type == Type.JavaCallee) {
276 return callingConvention(cpuCalleeParameterRegisters, returnType, parameterTypes, type, target, stackOnly);
277 }
278 throw JVMCIError.shouldNotReachHere();
279 }
280
281 public Register[] getCallingConventionRegisters(Type type, JavaKind kind) {
282 switch (kind) {
283 case Boolean:
284 case Byte:
285 case Short:
286 case Char:
287 case Int:
288 case Long:
289 case Object:
290 return type == Type.JavaCallee ? cpuCalleeParameterRegisters : cpuCallerParameterRegisters;
291 case Double:
292 case Float:
293 return fpuParameterRegisters;
294 default:
295 throw JVMCIError.shouldNotReachHere("Unknown JavaKind " + kind);
296 }
297 }
298
299 private CallingConvention callingConvention(Register[] generalParameterRegisters, JavaType returnType, JavaType[] parameterTypes, Type type, TargetDescription target, boolean stackOnly) {
300 AllocatableValue[] locations = new AllocatableValue[parameterTypes.length];
301
302 int currentGeneral = 0;
303 int currentFloating = 0;
304 int currentStackOffset = 0;
305
306 for (int i = 0; i < parameterTypes.length; i++) {
307 final JavaKind kind = parameterTypes[i].getJavaKind().getStackKind();
308
309 switch (kind) {
310 case Byte:
311 case Boolean:
312 case Short:
313 case Char:
314 case Int:
315 case Long:
316 case Object:
317 if (!stackOnly && currentGeneral < generalParameterRegisters.length) {
318 Register register = generalParameterRegisters[currentGeneral++];
319 locations[i] = register.asValue(target.getLIRKind(kind));
320 }
321 break;
322 case Double:
323 if (!stackOnly && currentFloating < fpuParameterRegisters.length) {
324 if (currentFloating % 2 != 0) {
325 // Make register number even to be a double reg
326 currentFloating++;
327 }
328 Register register = fpuDoubleParameterRegisters[currentFloating];
329 currentFloating += 2; // Only every second is a double register
330 locations[i] = register.asValue(target.getLIRKind(kind));
331 }
332 break;
333 case Float:
334 if (!stackOnly && currentFloating < fpuParameterRegisters.length) {
335 Register register = fpuParameterRegisters[currentFloating++];
336 locations[i] = register.asValue(target.getLIRKind(kind));
337 }
338 break;
339 default:
340 throw JVMCIError.shouldNotReachHere();
341 }
342
343 if (locations[i] == null) {
344 LIRKind lirKind = target.getLIRKind(kind);
345 // Stack slot is always aligned to its size in bytes but minimum wordsize
346 int typeSize = lirKind.getPlatformKind().getSizeInBytes();
347 currentStackOffset = roundUp(currentStackOffset, typeSize);
348 int slotOffset = currentStackOffset + SPARC.REGISTER_SAFE_AREA_SIZE;
349 locations[i] = StackSlot.get(lirKind, slotOffset, !type.out);
350 currentStackOffset += typeSize;
351 }
352 }
353
354 JavaKind returnKind = returnType == null ? JavaKind.Void : returnType.getJavaKind();
355 AllocatableValue returnLocation = returnKind == JavaKind.Void ? Value.ILLEGAL : getReturnRegister(returnKind, type).asValue(target.getLIRKind(returnKind.getStackKind()));
356 // Space where callee may spill outgoing parameters o0...o5
357 int lowerOutgoingSpace = Math.min(locations.length, 6) * target.wordSize;
358 return new CallingConvention(currentStackOffset + lowerOutgoingSpace, returnLocation, locations);
359 }
360
361 private static int roundUp(int number, int mod) {
362 return ((number + mod - 1) / mod) * mod;
363 }
364
365 @Override
366 public Register getReturnRegister(JavaKind kind) {
367 return getReturnRegister(kind, Type.JavaCallee);
368 }
369
370 private static Register getReturnRegister(JavaKind kind, Type type) {
371 switch (kind) {
372 case Boolean:
373 case Byte:
374 case Char:
375 case Short:
376 case Int:
377 case Long:
378 case Object:
379 return type == Type.JavaCallee ? i0 : o0;
380 case Float:
381 return f0;
382 case Double:
383 return d0;
384 case Void:
385 case Illegal:
386 return null;
387 default:
388 throw new UnsupportedOperationException("no return register for type " + kind);
389 }
390 }
391
392 @Override
393 public Register getFrameRegister() {
394 return sp;
395 }
396
397 @Override
398 public String toString() {
399 return String.format("Allocatable: " + Arrays.toString(getAllocatableRegisters()) + "%n" + "CallerSave: " + Arrays.toString(getCallerSaveRegisters()) + "%n");
400 }
401 }