1 /*
2 * Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.
3 * Copyright (c) 2012, 2015 SAP SE. All rights reserved.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 #ifndef CPU_PPC_VM_FRAME_PPC_HPP
27 #define CPU_PPC_VM_FRAME_PPC_HPP
28
29 #include "runtime/synchronizer.hpp"
30
31 // C frame layout on PPC-64.
32 //
33 // In this figure the stack grows upwards, while memory grows
34 // downwards. See "64-bit PowerPC ELF ABI Supplement Version 1.7",
35 // IBM Corp. (2003-10-29)
36 // (http://math-atlas.sourceforge.net/devel/assembly/PPC-elf64abi-1.7.pdf).
37 //
38 // Square brackets denote stack regions possibly larger
39 // than a single 64 bit slot.
40 //
41 // STACK:
42 // 0 [C_FRAME] <-- SP after prolog (mod 16 = 0)
43 // [C_FRAME] <-- SP before prolog
44 // ...
45 // [C_FRAME]
46 //
47 // C_FRAME:
48 // 0 [ABI_REG_ARGS]
49 // 112 CARG_9: outgoing arg 9 (arg_1 ... arg_8 via gpr_3 ... gpr_{10})
50 // ...
51 // 40+M*8 CARG_M: outgoing arg M (M is the maximum of outgoing args taken over all call sites in the procedure)
52 // local 1
53 // ...
54 // local N
55 // spill slot for vector reg (16 bytes aligned)
56 // ...
57 // spill slot for vector reg
58 // alignment (4 or 12 bytes)
59 // V SR_VRSAVE
60 // V+4 spill slot for GR
61 // ... ...
62 // spill slot for GR
63 // spill slot for FR
64 // ...
65 // spill slot for FR
66 //
67 // ABI_48:
68 // 0 caller's SP
69 // 8 space for condition register (CR) for next call
70 // 16 space for link register (LR) for next call
71 // 24 reserved
72 // 32 reserved
73 // 40 space for TOC (=R2) register for next call
74 //
75 // ABI_REG_ARGS:
76 // 0 [ABI_48]
77 // 48 CARG_1: spill slot for outgoing arg 1. used by next callee.
78 // ... ...
79 // 104 CARG_8: spill slot for outgoing arg 8. used by next callee.
80 //
81
82 public:
83
84 // C frame layout
85 static const int alignment_in_bytes = 16;
86
87 // ABI_MINFRAME:
88 struct abi_minframe {
89 uint64_t callers_sp;
90 uint64_t cr; //_16
91 uint64_t lr;
92 #if !defined(ABI_ELFv2)
93 uint64_t reserved1; //_16
94 uint64_t reserved2;
95 #endif
96 uint64_t toc; //_16
97 // nothing to add here!
98 // aligned to frame::alignment_in_bytes (16)
99 };
100
101 enum {
102 abi_minframe_size = sizeof(abi_minframe)
103 };
104
105 struct abi_reg_args : abi_minframe {
106 uint64_t carg_1;
107 uint64_t carg_2; //_16
108 uint64_t carg_3;
109 uint64_t carg_4; //_16
110 uint64_t carg_5;
111 uint64_t carg_6; //_16
112 uint64_t carg_7;
113 uint64_t carg_8; //_16
114 // aligned to frame::alignment_in_bytes (16)
115 };
116
117 enum {
118 abi_reg_args_size = sizeof(abi_reg_args)
119 };
120
121 #define _abi(_component) \
122 (offset_of(frame::abi_reg_args, _component))
123
124 struct abi_reg_args_spill : abi_reg_args {
125 // additional spill slots
126 uint64_t spill_ret;
127 uint64_t spill_fret; //_16
128 // aligned to frame::alignment_in_bytes (16)
129 };
130
131 enum {
132 abi_reg_args_spill_size = sizeof(abi_reg_args_spill)
133 };
134
135 #define _abi_reg_args_spill(_component) \
136 (offset_of(frame::abi_reg_args_spill, _component))
137
138 // non-volatile GPRs:
139
140 struct spill_nonvolatiles {
141 uint64_t r14;
142 uint64_t r15; //_16
143 uint64_t r16;
144 uint64_t r17; //_16
145 uint64_t r18;
146 uint64_t r19; //_16
147 uint64_t r20;
148 uint64_t r21; //_16
149 uint64_t r22;
150 uint64_t r23; //_16
151 uint64_t r24;
152 uint64_t r25; //_16
153 uint64_t r26;
154 uint64_t r27; //_16
155 uint64_t r28;
156 uint64_t r29; //_16
157 uint64_t r30;
158 uint64_t r31; //_16
159
160 double f14;
161 double f15;
162 double f16;
163 double f17;
164 double f18;
165 double f19;
166 double f20;
167 double f21;
168 double f22;
169 double f23;
170 double f24;
171 double f25;
172 double f26;
173 double f27;
174 double f28;
175 double f29;
176 double f30;
177 double f31;
178
179 // aligned to frame::alignment_in_bytes (16)
180 };
181
182 enum {
183 spill_nonvolatiles_size = sizeof(spill_nonvolatiles)
184 };
185
186 #define _spill_nonvolatiles_neg(_component) \
187 (int)(-frame::spill_nonvolatiles_size + offset_of(frame::spill_nonvolatiles, _component))
188
189 // Frame layout for the Java template interpreter on PPC64.
190 //
191 // In these figures the stack grows upwards, while memory grows
192 // downwards. Square brackets denote regions possibly larger than
193 // single 64 bit slots.
194 //
195 // STACK (interpreter is active):
196 // 0 [TOP_IJAVA_FRAME]
197 // [PARENT_IJAVA_FRAME]
198 // ...
199 // [PARENT_IJAVA_FRAME]
200 // [ENTRY_FRAME]
201 // [C_FRAME]
202 // ...
203 // [C_FRAME]
204 //
205 // With the following frame layouts:
206 // TOP_IJAVA_FRAME:
207 // 0 [TOP_IJAVA_FRAME_ABI]
208 // alignment (optional)
209 // [operand stack]
210 // [monitors] (optional)
211 // [IJAVA_STATE]
212 // note: own locals are located in the caller frame.
213 //
214 // PARENT_IJAVA_FRAME:
215 // 0 [PARENT_IJAVA_FRAME_ABI]
216 // alignment (optional)
217 // [callee's Java result]
218 // [callee's locals w/o arguments]
219 // [outgoing arguments]
220 // [used part of operand stack w/o arguments]
221 // [monitors] (optional)
222 // [IJAVA_STATE]
223 //
224 // ENTRY_FRAME:
225 // 0 [PARENT_IJAVA_FRAME_ABI]
226 // alignment (optional)
227 // [callee's Java result]
228 // [callee's locals w/o arguments]
229 // [outgoing arguments]
230 // [ENTRY_FRAME_LOCALS]
231
232 struct parent_ijava_frame_abi : abi_minframe {
233 };
234
235 enum {
236 parent_ijava_frame_abi_size = sizeof(parent_ijava_frame_abi)
237 };
238
239 #define _parent_ijava_frame_abi(_component) \
240 (offset_of(frame::parent_ijava_frame_abi, _component))
241
242 struct top_ijava_frame_abi : abi_reg_args {
243 };
244
245 enum {
246 top_ijava_frame_abi_size = sizeof(top_ijava_frame_abi)
247 };
248
249 #define _top_ijava_frame_abi(_component) \
250 (offset_of(frame::top_ijava_frame_abi, _component))
251
252 struct ijava_state {
253 #ifdef ASSERT
254 uint64_t ijava_reserved; // Used for assertion.
255 #endif
256 uint64_t method;
257 uint64_t mirror;
258 uint64_t locals;
259 uint64_t monitors;
260 uint64_t cpoolCache;
261 uint64_t bcp;
262 uint64_t esp;
263 uint64_t mdx;
264 uint64_t top_frame_sp; // Maybe define parent_frame_abi and move there.
265 uint64_t sender_sp;
266 // Slots only needed for native calls. Maybe better to move elsewhere.
267 uint64_t oop_tmp;
268 uint64_t lresult;
269 uint64_t fresult;
270 };
271
272 enum {
273 ijava_state_size = sizeof(ijava_state)
274 };
275
276 #define _ijava_state_neg(_component) \
277 (int) (-frame::ijava_state_size + offset_of(frame::ijava_state, _component))
278
279 // ENTRY_FRAME
280
281 struct entry_frame_locals {
282 uint64_t call_wrapper_address;
283 uint64_t result_address; //_16
284 uint64_t result_type;
285 uint64_t arguments_tos_address; //_16
286 // aligned to frame::alignment_in_bytes (16)
287 uint64_t r[spill_nonvolatiles_size/sizeof(uint64_t)];
288 };
289
290 enum {
291 entry_frame_locals_size = sizeof(entry_frame_locals)
292 };
293
294 #define _entry_frame_locals_neg(_component) \
295 (int)(-frame::entry_frame_locals_size + offset_of(frame::entry_frame_locals, _component))
296
297
298 // Frame layout for JIT generated methods
299 //
300 // In these figures the stack grows upwards, while memory grows
301 // downwards. Square brackets denote regions possibly larger than single
302 // 64 bit slots.
303 //
304 // STACK (interpreted Java calls JIT generated Java):
305 // [JIT_FRAME] <-- SP (mod 16 = 0)
306 // [TOP_IJAVA_FRAME]
307 // ...
308 //
309 // JIT_FRAME (is a C frame according to PPC-64 ABI):
310 // [out_preserve]
311 // [out_args]
312 // [spills]
313 // [pad_1]
314 // [monitor] (optional)
315 // ...
316 // [monitor] (optional)
317 // [pad_2]
318 // [in_preserve] added / removed by prolog / epilog
319 //
320
321 // JIT_ABI (TOP and PARENT)
322
323 struct jit_abi {
324 uint64_t callers_sp;
325 uint64_t cr;
326 uint64_t lr;
327 uint64_t toc;
328 // Nothing to add here!
329 // NOT ALIGNED to frame::alignment_in_bytes (16).
330 };
331
332 struct jit_out_preserve : jit_abi {
333 // Nothing to add here!
334 };
335
336 struct jit_in_preserve {
337 // Nothing to add here!
338 };
339
340 enum {
341 jit_out_preserve_size = sizeof(jit_out_preserve),
342 jit_in_preserve_size = sizeof(jit_in_preserve)
343 };
344
345 struct jit_monitor {
346 uint64_t monitor[1];
347 };
348
349 enum {
350 jit_monitor_size = sizeof(jit_monitor),
351 };
352
353 private:
354
355 // STACK:
356 // ...
357 // [THIS_FRAME] <-- this._sp (stack pointer for this frame)
358 // [CALLER_FRAME] <-- this.fp() (_sp of caller's frame)
359 // ...
360 //
361
362 // frame pointer for this frame
363 intptr_t* _fp;
364
365 // The frame's stack pointer before it has been extended by a c2i adapter;
366 // needed by deoptimization
367 intptr_t* _unextended_sp;
368
369 public:
370
371 // Accessors for fields
372 intptr_t* fp() const { return _fp; }
373
374 // Accessors for ABIs
375 inline abi_minframe* own_abi() const { return (abi_minframe*) _sp; }
376 inline abi_minframe* callers_abi() const { return (abi_minframe*) _fp; }
377
378 private:
379
380 // Find codeblob and set deopt_state.
381 inline void find_codeblob_and_set_pc_and_deopt_state(address pc);
382
383 public:
384
385 // Constructors
386 inline frame(intptr_t* sp);
387 frame(intptr_t* sp, address pc);
388 inline frame(intptr_t* sp, address pc, intptr_t* unextended_sp);
389
390 private:
391
392 intptr_t* compiled_sender_sp(CodeBlob* cb) const;
393 address* compiled_sender_pc_addr(CodeBlob* cb) const;
394 address* sender_pc_addr(void) const;
395
396 public:
397
398 inline ijava_state* get_ijava_state() const;
399 // Some convenient register frame setters/getters for deoptimization.
400 inline intptr_t* interpreter_frame_esp() const;
401 inline void interpreter_frame_set_cpcache(ConstantPoolCache* cp);
402 inline void interpreter_frame_set_esp(intptr_t* esp);
403 inline void interpreter_frame_set_top_frame_sp(intptr_t* top_frame_sp);
404 inline void interpreter_frame_set_sender_sp(intptr_t* sender_sp);
405
406 // Size of a monitor in bytes.
407 static int interpreter_frame_monitor_size_in_bytes();
408
409 // The size of a cInterpreter object.
410 static inline int interpreter_frame_cinterpreterstate_size_in_bytes();
411
412 private:
413
414 ConstantPoolCache** interpreter_frame_cpoolcache_addr() const;
415
416 public:
417
418 // Additional interface for entry frames:
419 inline entry_frame_locals* get_entry_frame_locals() const {
420 return (entry_frame_locals*) (((address) fp()) - entry_frame_locals_size);
421 }
422
423 enum {
424 // normal return address is 1 bundle past PC
425 pc_return_offset = 0
426 };
427
428 static jint interpreter_frame_expression_stack_direction() { return -1; }
429
430 #endif // CPU_PPC_VM_FRAME_PPC_HPP