Thu, 11 Jul 2013 12:56:29 -0700
Merge
1 /*
2 * Copyright (c) 2002, 2012, 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 */
25 #ifndef SHARE_VM_INTERPRETER_BYTECODEINTERPRETER_HPP
26 #define SHARE_VM_INTERPRETER_BYTECODEINTERPRETER_HPP
28 #include "memory/allocation.hpp"
29 #include "oops/methodData.hpp"
30 #include "oops/method.hpp"
31 #include "runtime/basicLock.hpp"
32 #include "runtime/frame.hpp"
33 #include "runtime/globals.hpp"
34 #include "utilities/globalDefinitions.hpp"
35 #ifdef TARGET_ARCH_x86
36 # include "bytes_x86.hpp"
37 #endif
38 #ifdef TARGET_ARCH_sparc
39 # include "bytes_sparc.hpp"
40 #endif
41 #ifdef TARGET_ARCH_zero
42 # include "bytes_zero.hpp"
43 #endif
44 #ifdef TARGET_ARCH_arm
45 # include "bytes_arm.hpp"
46 #endif
47 #ifdef TARGET_ARCH_ppc
48 # include "bytes_ppc.hpp"
49 #endif
51 #ifdef CC_INTERP
53 // JavaStack Implementation
54 #define MORE_STACK(count) \
55 (topOfStack -= ((count) * Interpreter::stackElementWords))
57 // CVM definitions find hotspot equivalents...
59 union VMJavaVal64 {
60 jlong l;
61 jdouble d;
62 uint32_t v[2];
63 };
66 typedef class BytecodeInterpreter* interpreterState;
68 struct call_message {
69 class Method* _callee; // method to call during call_method request
70 address _callee_entry_point; // address to jump to for call_method request
71 int _bcp_advance; // size of the invoke bytecode operation
72 };
74 struct osr_message {
75 address _osr_buf; // the osr buffer
76 address _osr_entry; // the entry to the osr method
77 };
79 struct osr_result {
80 nmethod* nm; // osr nmethod
81 address return_addr; // osr blob return address
82 };
84 // Result returned to frame manager
85 union frame_manager_message {
86 call_message _to_call; // describes callee
87 osr_message _osr; // describes the osr
88 osr_result _osr_result; // result of OSR request
89 };
91 class BytecodeInterpreter : StackObj {
92 friend class SharedRuntime;
93 friend class AbstractInterpreterGenerator;
94 friend class CppInterpreterGenerator;
95 friend class InterpreterGenerator;
96 friend class InterpreterMacroAssembler;
97 friend class frame;
98 friend class VMStructs;
100 public:
101 enum messages {
102 no_request = 0, // unused
103 initialize, // Perform one time interpreter initializations (assumes all switches set)
104 // status message to C++ interpreter
105 method_entry, // initial method entry to interpreter
106 method_resume, // frame manager response to return_from_method request (assuming a frame to resume)
107 deopt_resume, // returning from a native call into a deopted frame
108 deopt_resume2, // deopt resume as a result of a PopFrame
109 got_monitors, // frame manager response to more_monitors request
110 rethrow_exception, // unwinding and throwing exception
111 // requests to frame manager from C++ interpreter
112 call_method, // request for new frame from interpreter, manager responds with method_entry
113 return_from_method, // request from interpreter to unwind, manager responds with method_continue
114 more_monitors, // need a new monitor
115 throwing_exception, // unwind stack and rethrow
116 popping_frame, // unwind call and retry call
117 do_osr, // request this invocation be OSR's
118 early_return // early return as commanded by jvmti
119 };
121 private:
122 JavaThread* _thread; // the vm's java thread pointer
123 address _bcp; // instruction pointer
124 intptr_t* _locals; // local variable pointer
125 ConstantPoolCache* _constants; // constant pool cache
126 Method* _method; // method being executed
127 DataLayout* _mdx; // compiler profiling data for current bytecode
128 intptr_t* _stack; // expression stack
129 messages _msg; // frame manager <-> interpreter message
130 frame_manager_message _result; // result to frame manager
131 interpreterState _prev_link; // previous interpreter state
132 oop _oop_temp; // mirror for interpreted native, null otherwise
133 intptr_t* _stack_base; // base of expression stack
134 intptr_t* _stack_limit; // limit of expression stack
135 BasicObjectLock* _monitor_base; // base of monitors on the native stack
138 public:
139 // Constructor is only used by the initialization step. All other instances are created
140 // by the frame manager.
141 BytecodeInterpreter(messages msg);
143 //
144 // Deoptimization support
145 //
146 static void layout_interpreterState(interpreterState to_fill,
147 frame* caller,
148 frame* interpreter_frame,
149 Method* method,
150 intptr_t* locals,
151 intptr_t* stack,
152 intptr_t* stack_base,
153 intptr_t* monitor_base,
154 intptr_t* frame_bottom,
155 bool top_frame);
157 /*
158 * Generic 32-bit wide "Java slot" definition. This type occurs
159 * in operand stacks, Java locals, object fields, constant pools.
160 */
161 union VMJavaVal32 {
162 jint i;
163 jfloat f;
164 class oopDesc* r;
165 uint32_t raw;
166 };
168 /*
169 * Generic 64-bit Java value definition
170 */
171 union VMJavaVal64 {
172 jlong l;
173 jdouble d;
174 uint32_t v[2];
175 };
177 /*
178 * Generic 32-bit wide "Java slot" definition. This type occurs
179 * in Java locals, object fields, constant pools, and
180 * operand stacks (as a CVMStackVal32).
181 */
182 typedef union VMSlotVal32 {
183 VMJavaVal32 j; /* For "Java" values */
184 address a; /* a return created by jsr or jsr_w */
185 } VMSlotVal32;
188 /*
189 * Generic 32-bit wide stack slot definition.
190 */
191 union VMStackVal32 {
192 VMJavaVal32 j; /* For "Java" values */
193 VMSlotVal32 s; /* any value from a "slot" or locals[] */
194 };
196 inline JavaThread* thread() { return _thread; }
198 inline address bcp() { return _bcp; }
199 inline void set_bcp(address new_bcp) { _bcp = new_bcp; }
201 inline intptr_t* locals() { return _locals; }
203 inline ConstantPoolCache* constants() { return _constants; }
204 inline Method* method() { return _method; }
205 inline DataLayout* mdx() { return _mdx; }
206 inline void set_mdx(DataLayout *new_mdx) { _mdx = new_mdx; }
208 inline messages msg() { return _msg; }
209 inline void set_msg(messages new_msg) { _msg = new_msg; }
211 inline Method* callee() { return _result._to_call._callee; }
212 inline void set_callee(Method* new_callee) { _result._to_call._callee = new_callee; }
213 inline void set_callee_entry_point(address entry) { _result._to_call._callee_entry_point = entry; }
214 inline void set_osr_buf(address buf) { _result._osr._osr_buf = buf; }
215 inline void set_osr_entry(address entry) { _result._osr._osr_entry = entry; }
216 inline int bcp_advance() { return _result._to_call._bcp_advance; }
217 inline void set_bcp_advance(int count) { _result._to_call._bcp_advance = count; }
219 inline interpreterState prev() { return _prev_link; }
221 inline intptr_t* stack() { return _stack; }
222 inline void set_stack(intptr_t* new_stack) { _stack = new_stack; }
225 inline intptr_t* stack_base() { return _stack_base; }
226 inline intptr_t* stack_limit() { return _stack_limit; }
228 inline BasicObjectLock* monitor_base() { return _monitor_base; }
230 /*
231 * 64-bit Arithmetic:
232 *
233 * The functions below follow the semantics of the
234 * ladd, land, ldiv, lmul, lor, lxor, and lrem bytecodes,
235 * respectively.
236 */
238 static jlong VMlongAdd(jlong op1, jlong op2);
239 static jlong VMlongAnd(jlong op1, jlong op2);
240 static jlong VMlongDiv(jlong op1, jlong op2);
241 static jlong VMlongMul(jlong op1, jlong op2);
242 static jlong VMlongOr (jlong op1, jlong op2);
243 static jlong VMlongSub(jlong op1, jlong op2);
244 static jlong VMlongXor(jlong op1, jlong op2);
245 static jlong VMlongRem(jlong op1, jlong op2);
247 /*
248 * Shift:
249 *
250 * The functions below follow the semantics of the
251 * lushr, lshl, and lshr bytecodes, respectively.
252 */
254 static jlong VMlongUshr(jlong op1, jint op2);
255 static jlong VMlongShl (jlong op1, jint op2);
256 static jlong VMlongShr (jlong op1, jint op2);
258 /*
259 * Unary:
260 *
261 * Return the negation of "op" (-op), according to
262 * the semantics of the lneg bytecode.
263 */
265 static jlong VMlongNeg(jlong op);
267 /*
268 * Return the complement of "op" (~op)
269 */
271 static jlong VMlongNot(jlong op);
274 /*
275 * Comparisons to 0:
276 */
278 static int32_t VMlongLtz(jlong op); /* op <= 0 */
279 static int32_t VMlongGez(jlong op); /* op >= 0 */
280 static int32_t VMlongEqz(jlong op); /* op == 0 */
282 /*
283 * Between operands:
284 */
286 static int32_t VMlongEq(jlong op1, jlong op2); /* op1 == op2 */
287 static int32_t VMlongNe(jlong op1, jlong op2); /* op1 != op2 */
288 static int32_t VMlongGe(jlong op1, jlong op2); /* op1 >= op2 */
289 static int32_t VMlongLe(jlong op1, jlong op2); /* op1 <= op2 */
290 static int32_t VMlongLt(jlong op1, jlong op2); /* op1 < op2 */
291 static int32_t VMlongGt(jlong op1, jlong op2); /* op1 > op2 */
293 /*
294 * Comparisons (returning an jint value: 0, 1, or -1)
295 *
296 * Between operands:
297 *
298 * Compare "op1" and "op2" according to the semantics of the
299 * "lcmp" bytecode.
300 */
302 static int32_t VMlongCompare(jlong op1, jlong op2);
304 /*
305 * Convert int to long, according to "i2l" bytecode semantics
306 */
307 static jlong VMint2Long(jint val);
309 /*
310 * Convert long to int, according to "l2i" bytecode semantics
311 */
312 static jint VMlong2Int(jlong val);
314 /*
315 * Convert long to float, according to "l2f" bytecode semantics
316 */
317 static jfloat VMlong2Float(jlong val);
319 /*
320 * Convert long to double, according to "l2d" bytecode semantics
321 */
322 static jdouble VMlong2Double(jlong val);
324 /*
325 * Java floating-point float value manipulation.
326 *
327 * The result argument is, once again, an lvalue.
328 *
329 * Arithmetic:
330 *
331 * The functions below follow the semantics of the
332 * fadd, fsub, fmul, fdiv, and frem bytecodes,
333 * respectively.
334 */
336 static jfloat VMfloatAdd(jfloat op1, jfloat op2);
337 static jfloat VMfloatSub(jfloat op1, jfloat op2);
338 static jfloat VMfloatMul(jfloat op1, jfloat op2);
339 static jfloat VMfloatDiv(jfloat op1, jfloat op2);
340 static jfloat VMfloatRem(jfloat op1, jfloat op2);
342 /*
343 * Unary:
344 *
345 * Return the negation of "op" (-op), according to
346 * the semantics of the fneg bytecode.
347 */
349 static jfloat VMfloatNeg(jfloat op);
351 /*
352 * Comparisons (returning an int value: 0, 1, or -1)
353 *
354 * Between operands:
355 *
356 * Compare "op1" and "op2" according to the semantics of the
357 * "fcmpl" (direction is -1) or "fcmpg" (direction is 1) bytecodes.
358 */
360 static int32_t VMfloatCompare(jfloat op1, jfloat op2,
361 int32_t direction);
362 /*
363 * Conversion:
364 */
366 /*
367 * Convert float to double, according to "f2d" bytecode semantics
368 */
370 static jdouble VMfloat2Double(jfloat op);
372 /*
373 ******************************************
374 * Java double floating-point manipulation.
375 ******************************************
376 *
377 * The result argument is, once again, an lvalue.
378 *
379 * Conversions:
380 */
382 /*
383 * Convert double to int, according to "d2i" bytecode semantics
384 */
386 static jint VMdouble2Int(jdouble val);
388 /*
389 * Convert double to float, according to "d2f" bytecode semantics
390 */
392 static jfloat VMdouble2Float(jdouble val);
394 /*
395 * Convert int to double, according to "i2d" bytecode semantics
396 */
398 static jdouble VMint2Double(jint val);
400 /*
401 * Arithmetic:
402 *
403 * The functions below follow the semantics of the
404 * dadd, dsub, ddiv, dmul, and drem bytecodes, respectively.
405 */
407 static jdouble VMdoubleAdd(jdouble op1, jdouble op2);
408 static jdouble VMdoubleSub(jdouble op1, jdouble op2);
409 static jdouble VMdoubleDiv(jdouble op1, jdouble op2);
410 static jdouble VMdoubleMul(jdouble op1, jdouble op2);
411 static jdouble VMdoubleRem(jdouble op1, jdouble op2);
413 /*
414 * Unary:
415 *
416 * Return the negation of "op" (-op), according to
417 * the semantics of the dneg bytecode.
418 */
420 static jdouble VMdoubleNeg(jdouble op);
422 /*
423 * Comparisons (returning an int32_t value: 0, 1, or -1)
424 *
425 * Between operands:
426 *
427 * Compare "op1" and "op2" according to the semantics of the
428 * "dcmpl" (direction is -1) or "dcmpg" (direction is 1) bytecodes.
429 */
431 static int32_t VMdoubleCompare(jdouble op1, jdouble op2, int32_t direction);
433 /*
434 * Copy two typeless 32-bit words from one location to another.
435 * This is semantically equivalent to:
436 *
437 * to[0] = from[0];
438 * to[1] = from[1];
439 *
440 * but this interface is provided for those platforms that could
441 * optimize this into a single 64-bit transfer.
442 */
444 static void VMmemCopy64(uint32_t to[2], const uint32_t from[2]);
447 // Arithmetic operations
449 /*
450 * Java arithmetic methods.
451 * The functions below follow the semantics of the
452 * iadd, isub, imul, idiv, irem, iand, ior, ixor,
453 * and ineg bytecodes, respectively.
454 */
456 static jint VMintAdd(jint op1, jint op2);
457 static jint VMintSub(jint op1, jint op2);
458 static jint VMintMul(jint op1, jint op2);
459 static jint VMintDiv(jint op1, jint op2);
460 static jint VMintRem(jint op1, jint op2);
461 static jint VMintAnd(jint op1, jint op2);
462 static jint VMintOr (jint op1, jint op2);
463 static jint VMintXor(jint op1, jint op2);
465 /*
466 * Shift Operation:
467 * The functions below follow the semantics of the
468 * iushr, ishl, and ishr bytecodes, respectively.
469 */
471 static juint VMintUshr(jint op, jint num);
472 static jint VMintShl (jint op, jint num);
473 static jint VMintShr (jint op, jint num);
475 /*
476 * Unary Operation:
477 *
478 * Return the negation of "op" (-op), according to
479 * the semantics of the ineg bytecode.
480 */
482 static jint VMintNeg(jint op);
484 /*
485 * Int Conversions:
486 */
488 /*
489 * Convert int to float, according to "i2f" bytecode semantics
490 */
492 static jfloat VMint2Float(jint val);
494 /*
495 * Convert int to byte, according to "i2b" bytecode semantics
496 */
498 static jbyte VMint2Byte(jint val);
500 /*
501 * Convert int to char, according to "i2c" bytecode semantics
502 */
504 static jchar VMint2Char(jint val);
506 /*
507 * Convert int to short, according to "i2s" bytecode semantics
508 */
510 static jshort VMint2Short(jint val);
512 /*=========================================================================
513 * Bytecode interpreter operations
514 *=======================================================================*/
516 static void dup(intptr_t *tos);
517 static void dup2(intptr_t *tos);
518 static void dup_x1(intptr_t *tos); /* insert top word two down */
519 static void dup_x2(intptr_t *tos); /* insert top word three down */
520 static void dup2_x1(intptr_t *tos); /* insert top 2 slots three down */
521 static void dup2_x2(intptr_t *tos); /* insert top 2 slots four down */
522 static void swap(intptr_t *tos); /* swap top two elements */
524 // umm don't like this method modifies its object
526 // The Interpreter used when
527 static void run(interpreterState istate);
528 // The interpreter used if JVMTI needs interpreter events
529 static void runWithChecks(interpreterState istate);
530 static void End_Of_Interpreter(void);
532 // Inline static functions for Java Stack and Local manipulation
534 static address stack_slot(intptr_t *tos, int offset);
535 static jint stack_int(intptr_t *tos, int offset);
536 static jfloat stack_float(intptr_t *tos, int offset);
537 static oop stack_object(intptr_t *tos, int offset);
538 static jdouble stack_double(intptr_t *tos, int offset);
539 static jlong stack_long(intptr_t *tos, int offset);
541 // only used for value types
542 static void set_stack_slot(intptr_t *tos, address value, int offset);
543 static void set_stack_int(intptr_t *tos, int value, int offset);
544 static void set_stack_float(intptr_t *tos, jfloat value, int offset);
545 static void set_stack_object(intptr_t *tos, oop value, int offset);
547 // needs to be platform dep for the 32 bit platforms.
548 static void set_stack_double(intptr_t *tos, jdouble value, int offset);
549 static void set_stack_long(intptr_t *tos, jlong value, int offset);
551 static void set_stack_double_from_addr(intptr_t *tos, address addr, int offset);
552 static void set_stack_long_from_addr(intptr_t *tos, address addr, int offset);
554 // Locals
556 static address locals_slot(intptr_t* locals, int offset);
557 static jint locals_int(intptr_t* locals, int offset);
558 static jfloat locals_float(intptr_t* locals, int offset);
559 static oop locals_object(intptr_t* locals, int offset);
560 static jdouble locals_double(intptr_t* locals, int offset);
561 static jlong locals_long(intptr_t* locals, int offset);
563 static address locals_long_at(intptr_t* locals, int offset);
564 static address locals_double_at(intptr_t* locals, int offset);
566 static void set_locals_slot(intptr_t *locals, address value, int offset);
567 static void set_locals_int(intptr_t *locals, jint value, int offset);
568 static void set_locals_float(intptr_t *locals, jfloat value, int offset);
569 static void set_locals_object(intptr_t *locals, oop value, int offset);
570 static void set_locals_double(intptr_t *locals, jdouble value, int offset);
571 static void set_locals_long(intptr_t *locals, jlong value, int offset);
572 static void set_locals_double_from_addr(intptr_t *locals,
573 address addr, int offset);
574 static void set_locals_long_from_addr(intptr_t *locals,
575 address addr, int offset);
577 static void astore(intptr_t* topOfStack, int stack_offset,
578 intptr_t* locals, int locals_offset);
580 // Support for dup and swap
581 static void copy_stack_slot(intptr_t *tos, int from_offset, int to_offset);
583 #ifndef PRODUCT
584 static const char* C_msg(BytecodeInterpreter::messages msg);
585 void print();
586 #endif // PRODUCT
588 // Platform fields/methods
589 #ifdef TARGET_ARCH_x86
590 # include "bytecodeInterpreter_x86.hpp"
591 #endif
592 #ifdef TARGET_ARCH_sparc
593 # include "bytecodeInterpreter_sparc.hpp"
594 #endif
595 #ifdef TARGET_ARCH_zero
596 # include "bytecodeInterpreter_zero.hpp"
597 #endif
598 #ifdef TARGET_ARCH_arm
599 # include "bytecodeInterpreter_arm.hpp"
600 #endif
601 #ifdef TARGET_ARCH_ppc
602 # include "bytecodeInterpreter_ppc.hpp"
603 #endif
606 }; // BytecodeInterpreter
608 #endif // CC_INTERP
610 #endif // SHARE_VM_INTERPRETER_BYTECODEINTERPRETER_HPP