Mercurial > hg > truffle
annotate src/share/vm/interpreter/abstractInterpreter.hpp @ 1721:413ad0331a0c
6977924: Changes for 6975078 produce build error with certain gcc versions
Summary: The changes introduced for 6975078 assign badHeapOopVal to the _allocation field in the ResourceObj class. In 32 bit linux builds with certain versions of gcc this assignment will be flagged as an error while compiling allocation.cpp. In 32 bit builds the constant value badHeapOopVal (which is cast to an intptr_t) is negative. The _allocation field is typed as an unsigned intptr_t and gcc catches this as an error.
Reviewed-by: jcoomes, ysr, phh
author | johnc |
---|---|
date | Wed, 18 Aug 2010 10:59:06 -0700 |
parents | c18cbe5936b8 |
children | f95d63e2154a |
rev | line source |
---|---|
0 | 1 /* |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1506
diff
changeset
|
2 * Copyright (c) 1997, 2010, 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 | |
605 | 25 // This file contains the platform-independent parts |
0 | 26 // of the abstract interpreter and the abstract interpreter generator. |
27 | |
28 // Organization of the interpreter(s). There exists two different interpreters in hotpot | |
29 // an assembly language version (aka template interpreter) and a high level language version | |
30 // (aka c++ interpreter). Th division of labor is as follows: | |
31 | |
32 // Template Interpreter C++ Interpreter Functionality | |
33 // | |
34 // templateTable* bytecodeInterpreter* actual interpretation of bytecodes | |
35 // | |
36 // templateInterpreter* cppInterpreter* generation of assembly code that creates | |
37 // and manages interpreter runtime frames. | |
38 // Also code for populating interpreter | |
39 // frames created during deoptimization. | |
40 // | |
41 // For both template and c++ interpreter. There are common files for aspects of the interpreter | |
42 // that are generic to both interpreters. This is the layout: | |
43 // | |
44 // abstractInterpreter.hpp: generic description of the interpreter. | |
45 // interpreter*: generic frame creation and handling. | |
46 // | |
47 | |
48 //------------------------------------------------------------------------------------------------------------------------ | |
49 // The C++ interface to the bytecode interpreter(s). | |
50 | |
51 class AbstractInterpreter: AllStatic { | |
52 friend class VMStructs; | |
53 friend class Interpreter; | |
54 friend class CppInterpreterGenerator; | |
55 public: | |
56 enum MethodKind { | |
57 zerolocals, // method needs locals initialization | |
58 zerolocals_synchronized, // method needs locals initialization & is synchronized | |
59 native, // native method | |
60 native_synchronized, // native method & is synchronized | |
61 empty, // empty method (code: _return) | |
62 accessor, // accessor method (code: _aload_0, _getfield, _(a|i)return) | |
63 abstract, // abstract method (throws an AbstractMethodException) | |
710 | 64 method_handle, // java.dyn.MethodHandles::invoke |
0 | 65 java_lang_math_sin, // implementation of java.lang.Math.sin (x) |
66 java_lang_math_cos, // implementation of java.lang.Math.cos (x) | |
67 java_lang_math_tan, // implementation of java.lang.Math.tan (x) | |
68 java_lang_math_abs, // implementation of java.lang.Math.abs (x) | |
69 java_lang_math_sqrt, // implementation of java.lang.Math.sqrt (x) | |
70 java_lang_math_log, // implementation of java.lang.Math.log (x) | |
71 java_lang_math_log10, // implementation of java.lang.Math.log10 (x) | |
72 number_of_method_entries, | |
73 invalid = -1 | |
74 }; | |
75 | |
76 enum SomeConstants { | |
77 number_of_result_handlers = 10 // number of result handlers for native calls | |
78 }; | |
79 | |
80 protected: | |
81 static StubQueue* _code; // the interpreter code (codelets) | |
82 | |
83 static bool _notice_safepoints; // true if safepoints are activated | |
84 | |
85 static address _native_entry_begin; // Region for native entry code | |
86 static address _native_entry_end; | |
87 | |
88 // method entry points | |
89 static address _entry_table[number_of_method_entries]; // entry points for a given method | |
90 static address _native_abi_to_tosca[number_of_result_handlers]; // for native method result handlers | |
91 static address _slow_signature_handler; // the native method generic (slow) signature handler | |
92 | |
93 static address _rethrow_exception_entry; // rethrows an activation in previous frame | |
94 | |
95 friend class AbstractInterpreterGenerator; | |
96 friend class InterpreterGenerator; | |
97 friend class InterpreterMacroAssembler; | |
98 | |
99 public: | |
100 // Initialization/debugging | |
101 static void initialize(); | |
102 static StubQueue* code() { return _code; } | |
103 | |
104 | |
105 // Method activation | |
106 static MethodKind method_kind(methodHandle m); | |
107 static address entry_for_kind(MethodKind k) { assert(0 <= k && k < number_of_method_entries, "illegal kind"); return _entry_table[k]; } | |
108 static address entry_for_method(methodHandle m) { return _entry_table[method_kind(m)]; } | |
109 | |
110 static void print_method_kind(MethodKind kind) PRODUCT_RETURN; | |
111 | |
1174
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
900
diff
changeset
|
112 static bool can_be_compiled(methodHandle m); |
ddb7834449d0
6849984: Value methods for platform dependent math functions constant fold incorrectly
never
parents:
900
diff
changeset
|
113 |
0 | 114 // Runtime support |
115 | |
116 // length = invoke bytecode length (to advance to next bytecode) | |
117 static address deopt_entry (TosState state, int length) { ShouldNotReachHere(); return NULL; } | |
118 static address return_entry (TosState state, int length) { ShouldNotReachHere(); return NULL; } | |
119 | |
120 static address rethrow_exception_entry() { return _rethrow_exception_entry; } | |
121 | |
122 // Activation size in words for a method that is just being called. | |
123 // Parameters haven't been pushed so count them too. | |
124 static int size_top_interpreter_activation(methodOop method); | |
125 | |
126 // Deoptimization support | |
900
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
726
diff
changeset
|
127 // Compute the entry address for continuation after |
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
726
diff
changeset
|
128 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
|
129 address bcp, |
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
726
diff
changeset
|
130 int callee_parameters, |
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
726
diff
changeset
|
131 bool is_top_frame); |
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
726
diff
changeset
|
132 // Compute the entry address for reexecution |
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
726
diff
changeset
|
133 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
|
134 // Deoptimization should reexecute this bytecode |
9987d9d5eb0e
6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot
cfang
parents:
726
diff
changeset
|
135 static bool bytecode_should_reexecute(Bytecodes::Code code); |
0 | 136 |
137 // share implementation of size_activation and layout_activation: | |
138 static int size_activation(methodOop method, | |
139 int temps, | |
140 int popframe_args, | |
141 int monitors, | |
142 int callee_params, | |
143 int callee_locals, | |
144 bool is_top_frame); | |
145 | |
146 static int layout_activation(methodOop method, | |
147 int temps, | |
148 int popframe_args, | |
149 int monitors, | |
150 int callee_params, | |
151 int callee_locals, | |
152 frame* caller, | |
153 frame* interpreter_frame, | |
154 bool is_top_frame); | |
155 | |
156 // Runtime support | |
157 static bool is_not_reached( methodHandle method, int bci); | |
158 // Safepoint support | |
159 static void notice_safepoints() { ShouldNotReachHere(); } // stops the thread when reaching a safepoint | |
160 static void ignore_safepoints() { ShouldNotReachHere(); } // ignores safepoints | |
161 | |
162 // Support for native calls | |
163 static address slow_signature_handler() { return _slow_signature_handler; } | |
164 static address result_handler(BasicType type) { return _native_abi_to_tosca[BasicType_as_index(type)]; } | |
165 static int BasicType_as_index(BasicType type); // computes index into result_handler_by_index table | |
166 static bool in_native_entry(address pc) { return _native_entry_begin <= pc && pc < _native_entry_end; } | |
167 // Debugging/printing | |
168 static void print(); // prints the interpreter code | |
169 | |
170 public: | |
1506 | 171 // Interpreter helpers |
172 const static int stackElementWords = 1; | |
173 const static int stackElementSize = stackElementWords * wordSize; | |
174 const static int logStackElementSize = LogBytesPerWord; | |
0 | 175 |
176 // Local values relative to locals[n] | |
177 static int local_offset_in_bytes(int n) { | |
1506 | 178 return ((frame::interpreter_frame_expression_stack_direction() * n) * stackElementSize); |
0 | 179 } |
180 | |
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
181 // access to stacked values according to type: |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
182 static oop* oop_addr_in_slot(intptr_t* slot_addr) { |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
183 return (oop*) slot_addr; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
184 } |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
185 static jint* int_addr_in_slot(intptr_t* slot_addr) { |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
186 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
|
187 // big-endian LP64 |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
188 return (jint*)(slot_addr + 1) - 1; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
189 else |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
190 return (jint*) slot_addr; |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
191 } |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
192 static jlong long_in_slot(intptr_t* slot_addr) { |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
193 if (sizeof(intptr_t) >= sizeof(jlong)) { |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
194 return *(jlong*) slot_addr; |
1506 | 195 } else { |
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
196 return Bytes::get_native_u8((address)slot_addr); |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
197 } |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
198 } |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
199 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
|
200 if (sizeof(intptr_t) >= sizeof(jlong)) { |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
201 *(jlong*) slot_addr = value; |
1506 | 202 } else { |
726
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
203 Bytes::put_native_u8((address)slot_addr, value); |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
204 } |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
205 } |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
206 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
|
207 switch (type) { |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
208 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
|
209 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
|
210 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
|
211 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
|
212 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
|
213 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
|
214 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
|
215 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
|
216 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
|
217 default: ShouldNotReachHere(); |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
218 } |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
219 } |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
220 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
|
221 switch (type) { |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
222 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
|
223 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
|
224 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
|
225 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
|
226 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
|
227 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
|
228 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
|
229 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
|
230 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
|
231 default: ShouldNotReachHere(); |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
232 } |
be93aad57795
6655646: dynamic languages need dynamically linked call sites
jrose
parents:
710
diff
changeset
|
233 } |
0 | 234 }; |
235 | |
236 //------------------------------------------------------------------------------------------------------------------------ | |
237 // The interpreter generator. | |
238 | |
239 class Template; | |
240 class AbstractInterpreterGenerator: public StackObj { | |
241 protected: | |
242 InterpreterMacroAssembler* _masm; | |
243 | |
244 // shared code sequences | |
245 // Converter for native abi result to tosca result | |
246 address generate_result_handler_for(BasicType type); | |
247 address generate_slow_signature_handler(); | |
248 | |
249 // entry point generator | |
250 address generate_method_entry(AbstractInterpreter::MethodKind kind); | |
251 | |
252 void bang_stack_shadow_pages(bool native_call); | |
253 | |
254 void generate_all(); | |
255 | |
256 public: | |
257 AbstractInterpreterGenerator(StubQueue* _code); | |
258 }; |