Mercurial > hg > graal-compiler
annotate src/share/vm/interpreter/abstractInterpreter.hpp @ 3992:d1bdeef3e3e2
7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
Summary: There is a race between one thread successfully forwarding and copying the klass mirror for the SoftReference class (including the static master clock) and another thread attempting to use the master clock while attempting to discover a soft reference object. Maintain a shadow copy of the soft reference master clock and use the shadow during reference discovery and reference processing.
Reviewed-by: tonyp, brutisso, ysr
author | johnc |
---|---|
date | Wed, 12 Oct 2011 10:25:51 -0700 |
parents | f08d439fab8c |
children | 6759698e3140 |
rev | line source |
---|---|
0 | 1 /* |
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2192
diff
changeset
|
2 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. |
0 | 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 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1506
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1506
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1506
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #ifndef SHARE_VM_INTERPRETER_ABSTRACTINTERPRETER_HPP |
26 #define SHARE_VM_INTERPRETER_ABSTRACTINTERPRETER_HPP | |
27 | |
28 #include "code/stubs.hpp" | |
29 #include "interpreter/bytecodes.hpp" | |
30 #include "runtime/vmThread.hpp" | |
31 #include "utilities/top.hpp" | |
32 #ifdef TARGET_ARCH_MODEL_x86_32 | |
33 # include "interp_masm_x86_32.hpp" | |
34 #endif | |
35 #ifdef TARGET_ARCH_MODEL_x86_64 | |
36 # include "interp_masm_x86_64.hpp" | |
37 #endif | |
38 #ifdef TARGET_ARCH_MODEL_sparc | |
39 # include "interp_masm_sparc.hpp" | |
40 #endif | |
41 #ifdef TARGET_ARCH_MODEL_zero | |
42 # include "interp_masm_zero.hpp" | |
43 #endif | |
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
44 #ifdef TARGET_ARCH_MODEL_arm |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
45 # include "interp_masm_arm.hpp" |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
46 #endif |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
47 #ifdef TARGET_ARCH_MODEL_ppc |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
48 # include "interp_masm_ppc.hpp" |
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
49 #endif |
1972 | 50 #ifdef TARGET_OS_FAMILY_linux |
51 # include "thread_linux.inline.hpp" | |
52 #endif | |
53 #ifdef TARGET_OS_FAMILY_solaris | |
54 # include "thread_solaris.inline.hpp" | |
55 #endif | |
56 #ifdef TARGET_OS_FAMILY_windows | |
57 # include "thread_windows.inline.hpp" | |
58 #endif | |
3960 | 59 #ifdef TARGET_OS_FAMILY_bsd |
60 # include "thread_bsd.inline.hpp" | |
61 #endif | |
1972 | 62 |
605 | 63 // This file contains the platform-independent parts |
0 | 64 // of the abstract interpreter and the abstract interpreter generator. |
65 | |
66 // Organization of the interpreter(s). There exists two different interpreters in hotpot | |
67 // an assembly language version (aka template interpreter) and a high level language version | |
68 // (aka c++ interpreter). Th division of labor is as follows: | |
69 | |
70 // Template Interpreter C++ Interpreter Functionality | |
71 // | |
72 // templateTable* bytecodeInterpreter* actual interpretation of bytecodes | |
73 // | |
74 // templateInterpreter* cppInterpreter* generation of assembly code that creates | |
75 // and manages interpreter runtime frames. | |
76 // Also code for populating interpreter | |
77 // frames created during deoptimization. | |
78 // | |
79 // For both template and c++ interpreter. There are common files for aspects of the interpreter | |
80 // that are generic to both interpreters. This is the layout: | |
81 // | |
82 // abstractInterpreter.hpp: generic description of the interpreter. | |
83 // interpreter*: generic frame creation and handling. | |
84 // | |
85 | |
86 //------------------------------------------------------------------------------------------------------------------------ | |
87 // The C++ interface to the bytecode interpreter(s). | |
88 | |
89 class AbstractInterpreter: AllStatic { | |
90 friend class VMStructs; | |
91 friend class Interpreter; | |
92 friend class CppInterpreterGenerator; | |
93 public: | |
94 enum MethodKind { | |
95 zerolocals, // method needs locals initialization | |
96 zerolocals_synchronized, // method needs locals initialization & is synchronized | |
97 native, // native method | |
98 native_synchronized, // native method & is synchronized | |
99 empty, // empty method (code: _return) | |
100 accessor, // accessor method (code: _aload_0, _getfield, _(a|i)return) | |
101 abstract, // abstract method (throws an AbstractMethodException) | |
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2192
diff
changeset
|
102 method_handle, // java.lang.invoke.MethodHandles::invoke |
0 | 103 java_lang_math_sin, // implementation of java.lang.Math.sin (x) |
104 java_lang_math_cos, // implementation of java.lang.Math.cos (x) | |
105 java_lang_math_tan, // implementation of java.lang.Math.tan (x) | |
106 java_lang_math_abs, // implementation of java.lang.Math.abs (x) | |
107 java_lang_math_sqrt, // implementation of java.lang.Math.sqrt (x) | |
108 java_lang_math_log, // implementation of java.lang.Math.log (x) | |
109 java_lang_math_log10, // implementation of java.lang.Math.log10 (x) | |
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
110 java_lang_ref_reference_get, // implementation of java.lang.ref.Reference.get() |
0 | 111 number_of_method_entries, |
112 invalid = -1 | |
113 }; | |
114 | |
115 enum SomeConstants { | |
116 number_of_result_handlers = 10 // number of result handlers for native calls | |
117 }; | |
118 | |
119 protected: | |
120 static StubQueue* _code; // the interpreter code (codelets) | |
121 | |
122 static bool _notice_safepoints; // true if safepoints are activated | |
123 | |
124 static address _native_entry_begin; // Region for native entry code | |
125 static address _native_entry_end; | |
126 | |
127 // method entry points | |
128 static address _entry_table[number_of_method_entries]; // entry points for a given method | |
129 static address _native_abi_to_tosca[number_of_result_handlers]; // for native method result handlers | |
130 static address _slow_signature_handler; // the native method generic (slow) signature handler | |
131 | |
132 static address _rethrow_exception_entry; // rethrows an activation in previous frame | |
133 | |
134 friend class AbstractInterpreterGenerator; | |
135 friend class InterpreterGenerator; | |
136 friend class InterpreterMacroAssembler; | |
137 | |
138 public: | |
139 // Initialization/debugging | |
140 static void initialize(); | |
141 static StubQueue* code() { return _code; } | |
142 | |
143 | |
144 // Method activation | |
145 static MethodKind method_kind(methodHandle m); | |
146 static address entry_for_kind(MethodKind k) { assert(0 <= k && k < number_of_method_entries, "illegal kind"); return _entry_table[k]; } | |
3249
e1162778c1c8
7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents:
2357
diff
changeset
|
147 static address entry_for_method(methodHandle m) { return entry_for_kind(method_kind(m)); } |
0 | 148 |
149 static void print_method_kind(MethodKind kind) PRODUCT_RETURN; | |
150 | |
1174
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
900
diff
changeset
|
151 static bool can_be_compiled(methodHandle m); |
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
900
diff
changeset
|
152 |
0 | 153 // Runtime support |
154 | |
155 // length = invoke bytecode length (to advance to next bytecode) | |
156 static address deopt_entry (TosState state, int length) { ShouldNotReachHere(); return NULL; } | |
157 static address return_entry (TosState state, int length) { ShouldNotReachHere(); return NULL; } | |
158 | |
159 static address rethrow_exception_entry() { return _rethrow_exception_entry; } | |
160 | |
161 // Activation size in words for a method that is just being called. | |
162 // Parameters haven't been pushed so count them too. | |
163 static int size_top_interpreter_activation(methodOop method); | |
164 | |
165 // Deoptimization support | |
900
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
726
diff
changeset
|
166 // Compute the entry address for continuation after |
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
726
diff
changeset
|
167 static address deopt_continue_after_entry(methodOop method, |
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
726
diff
changeset
|
168 address bcp, |
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
726
diff
changeset
|
169 int callee_parameters, |
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
726
diff
changeset
|
170 bool is_top_frame); |
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
726
diff
changeset
|
171 // Compute the entry address for reexecution |
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
726
diff
changeset
|
172 static address deopt_reexecute_entry(methodOop method, address bcp); |
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
726
diff
changeset
|
173 // Deoptimization should reexecute this bytecode |
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
726
diff
changeset
|
174 static bool bytecode_should_reexecute(Bytecodes::Code code); |
0 | 175 |
176 // share implementation of size_activation and layout_activation: | |
177 static int size_activation(methodOop method, | |
178 int temps, | |
179 int popframe_args, | |
180 int monitors, | |
3369
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
181 int caller_actual_parameters, |
0 | 182 int callee_params, |
183 int callee_locals, | |
3369
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
184 bool is_top_frame) { |
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
185 return layout_activation(method, |
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
186 temps, |
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
187 popframe_args, |
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
188 monitors, |
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
189 caller_actual_parameters, |
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
190 callee_params, |
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
191 callee_locals, |
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
192 (frame*)NULL, |
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
193 (frame*)NULL, |
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
194 is_top_frame); |
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
195 } |
0 | 196 |
197 static int layout_activation(methodOop method, | |
3369
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
198 int temps, |
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
199 int popframe_args, |
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
200 int monitors, |
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
201 int caller_actual_parameters, |
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
202 int callee_params, |
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
203 int callee_locals, |
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
204 frame* caller, |
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
205 frame* interpreter_frame, |
3d2ab563047a
7043461: VM crashes in void LinkResolver::runtime_resolve_virtual_method
never
parents:
3249
diff
changeset
|
206 bool is_top_frame); |
0 | 207 |
208 // Runtime support | |
209 static bool is_not_reached( methodHandle method, int bci); | |
210 // Safepoint support | |
211 static void notice_safepoints() { ShouldNotReachHere(); } // stops the thread when reaching a safepoint | |
212 static void ignore_safepoints() { ShouldNotReachHere(); } // ignores safepoints | |
213 | |
214 // Support for native calls | |
215 static address slow_signature_handler() { return _slow_signature_handler; } | |
216 static address result_handler(BasicType type) { return _native_abi_to_tosca[BasicType_as_index(type)]; } | |
217 static int BasicType_as_index(BasicType type); // computes index into result_handler_by_index table | |
218 static bool in_native_entry(address pc) { return _native_entry_begin <= pc && pc < _native_entry_end; } | |
219 // Debugging/printing | |
220 static void print(); // prints the interpreter code | |
221 | |
222 public: | |
1506 | 223 // Interpreter helpers |
224 const static int stackElementWords = 1; | |
225 const static int stackElementSize = stackElementWords * wordSize; | |
226 const static int logStackElementSize = LogBytesPerWord; | |
0 | 227 |
228 // Local values relative to locals[n] | |
229 static int local_offset_in_bytes(int n) { | |
1506 | 230 return ((frame::interpreter_frame_expression_stack_direction() * n) * stackElementSize); |
0 | 231 } |
232 | |
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
233 // access to stacked values according to type: |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
234 static oop* oop_addr_in_slot(intptr_t* slot_addr) { |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
235 return (oop*) slot_addr; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
236 } |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
237 static jint* int_addr_in_slot(intptr_t* slot_addr) { |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
238 if ((int) sizeof(jint) < wordSize && !Bytes::is_Java_byte_ordering_different()) |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
239 // big-endian LP64 |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
240 return (jint*)(slot_addr + 1) - 1; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
241 else |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
242 return (jint*) slot_addr; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
243 } |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
244 static jlong long_in_slot(intptr_t* slot_addr) { |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
245 if (sizeof(intptr_t) >= sizeof(jlong)) { |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
246 return *(jlong*) slot_addr; |
1506 | 247 } else { |
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
248 return Bytes::get_native_u8((address)slot_addr); |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
249 } |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
250 } |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
251 static void set_long_in_slot(intptr_t* slot_addr, jlong value) { |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
252 if (sizeof(intptr_t) >= sizeof(jlong)) { |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
253 *(jlong*) slot_addr = value; |
1506 | 254 } else { |
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
255 Bytes::put_native_u8((address)slot_addr, value); |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
256 } |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
257 } |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
258 static void get_jvalue_in_slot(intptr_t* slot_addr, BasicType type, jvalue* value) { |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
259 switch (type) { |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
260 case T_BOOLEAN: value->z = *int_addr_in_slot(slot_addr); break; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
261 case T_CHAR: value->c = *int_addr_in_slot(slot_addr); break; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
262 case T_BYTE: value->b = *int_addr_in_slot(slot_addr); break; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
263 case T_SHORT: value->s = *int_addr_in_slot(slot_addr); break; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
264 case T_INT: value->i = *int_addr_in_slot(slot_addr); break; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
265 case T_LONG: value->j = long_in_slot(slot_addr); break; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
266 case T_FLOAT: value->f = *(jfloat*)int_addr_in_slot(slot_addr); break; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
267 case T_DOUBLE: value->d = jdouble_cast(long_in_slot(slot_addr)); break; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
268 case T_OBJECT: value->l = (jobject)*oop_addr_in_slot(slot_addr); break; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
269 default: ShouldNotReachHere(); |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
270 } |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
271 } |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
272 static void set_jvalue_in_slot(intptr_t* slot_addr, BasicType type, jvalue* value) { |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
273 switch (type) { |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
274 case T_BOOLEAN: *int_addr_in_slot(slot_addr) = (value->z != 0); break; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
275 case T_CHAR: *int_addr_in_slot(slot_addr) = value->c; break; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
276 case T_BYTE: *int_addr_in_slot(slot_addr) = value->b; break; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
277 case T_SHORT: *int_addr_in_slot(slot_addr) = value->s; break; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
278 case T_INT: *int_addr_in_slot(slot_addr) = value->i; break; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
279 case T_LONG: set_long_in_slot(slot_addr, value->j); break; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
280 case T_FLOAT: *(jfloat*)int_addr_in_slot(slot_addr) = value->f; break; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
281 case T_DOUBLE: set_long_in_slot(slot_addr, jlong_cast(value->d)); break; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
282 case T_OBJECT: *oop_addr_in_slot(slot_addr) = (oop) value->l; break; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
283 default: ShouldNotReachHere(); |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
284 } |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
285 } |
0 | 286 }; |
287 | |
288 //------------------------------------------------------------------------------------------------------------------------ | |
289 // The interpreter generator. | |
290 | |
291 class Template; | |
292 class AbstractInterpreterGenerator: public StackObj { | |
293 protected: | |
294 InterpreterMacroAssembler* _masm; | |
295 | |
296 // shared code sequences | |
297 // Converter for native abi result to tosca result | |
298 address generate_result_handler_for(BasicType type); | |
299 address generate_slow_signature_handler(); | |
300 | |
301 // entry point generator | |
302 address generate_method_entry(AbstractInterpreter::MethodKind kind); | |
303 | |
304 void bang_stack_shadow_pages(bool native_call); | |
305 | |
306 void generate_all(); | |
307 | |
308 public: | |
309 AbstractInterpreterGenerator(StubQueue* _code); | |
310 }; | |
1972 | 311 |
312 #endif // SHARE_VM_INTERPRETER_ABSTRACTINTERPRETER_HPP |