Mercurial > hg > truffle

annotate src/share/vm/interpreter/abstractInterpreter.hpp @ 1721:413ad0331a0c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
605
98cb887364d3 6810672: Comment typos
twisti
parents: 0
diff changeset
25 // This file contains the platform-independent parts
0
a61af66fc99e Initial load
duke
parents:
diff changeset
26 // of the abstract interpreter and the abstract interpreter generator.
a61af66fc99e Initial load
duke
parents:
diff changeset
27
a61af66fc99e Initial load
duke
parents:
diff changeset
28 // Organization of the interpreter(s). There exists two different interpreters in hotpot
a61af66fc99e Initial load
duke
parents:
diff changeset
29 // an assembly language version (aka template interpreter) and a high level language version
a61af66fc99e Initial load
duke
parents:
diff changeset
30 // (aka c++ interpreter). Th division of labor is as follows:
a61af66fc99e Initial load
duke
parents:
diff changeset
31
a61af66fc99e Initial load
duke
parents:
diff changeset
32 // Template Interpreter C++ Interpreter Functionality
a61af66fc99e Initial load
duke
parents:
diff changeset
33 //
a61af66fc99e Initial load
duke
parents:
diff changeset
34 // templateTable* bytecodeInterpreter* actual interpretation of bytecodes
a61af66fc99e Initial load
duke
parents:
diff changeset
35 //
a61af66fc99e Initial load
duke
parents:
diff changeset
36 // templateInterpreter* cppInterpreter* generation of assembly code that creates
a61af66fc99e Initial load
duke
parents:
diff changeset
37 // and manages interpreter runtime frames.
a61af66fc99e Initial load
duke
parents:
diff changeset
38 // Also code for populating interpreter
a61af66fc99e Initial load
duke
parents:
diff changeset
39 // frames created during deoptimization.
a61af66fc99e Initial load
duke
parents:
diff changeset
40 //
a61af66fc99e Initial load
duke
parents:
diff changeset
41 // For both template and c++ interpreter. There are common files for aspects of the interpreter
a61af66fc99e Initial load
duke
parents:
diff changeset
42 // that are generic to both interpreters. This is the layout:
a61af66fc99e Initial load
duke
parents:
diff changeset
43 //
a61af66fc99e Initial load
duke
parents:
diff changeset
44 // abstractInterpreter.hpp: generic description of the interpreter.
a61af66fc99e Initial load
duke
parents:
diff changeset
45 // interpreter*: generic frame creation and handling.
a61af66fc99e Initial load
duke
parents:
diff changeset
46 //
a61af66fc99e Initial load
duke
parents:
diff changeset
47
a61af66fc99e Initial load
duke
parents:
diff changeset
48 //------------------------------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
49 // The C++ interface to the bytecode interpreter(s).
a61af66fc99e Initial load
duke
parents:
diff changeset
50
a61af66fc99e Initial load
duke
parents:
diff changeset
51 class AbstractInterpreter: AllStatic {
a61af66fc99e Initial load
duke
parents:
diff changeset
52 friend class VMStructs;
a61af66fc99e Initial load
duke
parents:
diff changeset
53 friend class Interpreter;
a61af66fc99e Initial load
duke
parents:
diff changeset
54 friend class CppInterpreterGenerator;
a61af66fc99e Initial load
duke
parents:
diff changeset
55 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
56 enum MethodKind {
a61af66fc99e Initial load
duke
parents:
diff changeset
57 zerolocals, // method needs locals initialization
a61af66fc99e Initial load
duke
parents:
diff changeset
58 zerolocals_synchronized, // method needs locals initialization & is synchronized
a61af66fc99e Initial load
duke
parents:
diff changeset
59 native, // native method
a61af66fc99e Initial load
duke
parents:
diff changeset
60 native_synchronized, // native method & is synchronized
a61af66fc99e Initial load
duke
parents:
diff changeset
61 empty, // empty method (code: _return)
a61af66fc99e Initial load
duke
parents:
diff changeset
62 accessor, // accessor method (code: _aload_0, _getfield, _(a|i)return)
a61af66fc99e Initial load
duke
parents:
diff changeset
63 abstract, // abstract method (throws an AbstractMethodException)
710
e5b0439ef4ae 6655638: dynamic languages need method handles
jrose
parents: 605
diff changeset
64 method_handle, // java.dyn.MethodHandles::invoke
0
a61af66fc99e Initial load
duke
parents:
diff changeset
65 java_lang_math_sin, // implementation of java.lang.Math.sin (x)
a61af66fc99e Initial load
duke
parents:
diff changeset
66 java_lang_math_cos, // implementation of java.lang.Math.cos (x)
a61af66fc99e Initial load
duke
parents:
diff changeset
67 java_lang_math_tan, // implementation of java.lang.Math.tan (x)
a61af66fc99e Initial load
duke
parents:
diff changeset
68 java_lang_math_abs, // implementation of java.lang.Math.abs (x)
a61af66fc99e Initial load
duke
parents:
diff changeset
69 java_lang_math_sqrt, // implementation of java.lang.Math.sqrt (x)
a61af66fc99e Initial load
duke
parents:
diff changeset
70 java_lang_math_log, // implementation of java.lang.Math.log (x)
a61af66fc99e Initial load
duke
parents:
diff changeset
71 java_lang_math_log10, // implementation of java.lang.Math.log10 (x)
a61af66fc99e Initial load
duke
parents:
diff changeset
72 number_of_method_entries,
a61af66fc99e Initial load
duke
parents:
diff changeset
73 invalid = -1
a61af66fc99e Initial load
duke
parents:
diff changeset
74 };
a61af66fc99e Initial load
duke
parents:
diff changeset
75
a61af66fc99e Initial load
duke
parents:
diff changeset
76 enum SomeConstants {
a61af66fc99e Initial load
duke
parents:
diff changeset
77 number_of_result_handlers = 10 // number of result handlers for native calls
a61af66fc99e Initial load
duke
parents:
diff changeset
78 };
a61af66fc99e Initial load
duke
parents:
diff changeset
79
a61af66fc99e Initial load
duke
parents:
diff changeset
80 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
81 static StubQueue* _code; // the interpreter code (codelets)
a61af66fc99e Initial load
duke
parents:
diff changeset
82
a61af66fc99e Initial load
duke
parents:
diff changeset
83 static bool _notice_safepoints; // true if safepoints are activated
a61af66fc99e Initial load
duke
parents:
diff changeset
84
a61af66fc99e Initial load
duke
parents:
diff changeset
85 static address _native_entry_begin; // Region for native entry code
a61af66fc99e Initial load
duke
parents:
diff changeset
86 static address _native_entry_end;
a61af66fc99e Initial load
duke
parents:
diff changeset
87
a61af66fc99e Initial load
duke
parents:
diff changeset
88 // method entry points
a61af66fc99e Initial load
duke
parents:
diff changeset
89 static address _entry_table[number_of_method_entries]; // entry points for a given method
a61af66fc99e Initial load
duke
parents:
diff changeset
90 static address _native_abi_to_tosca[number_of_result_handlers]; // for native method result handlers
a61af66fc99e Initial load
duke
parents:
diff changeset
91 static address _slow_signature_handler; // the native method generic (slow) signature handler
a61af66fc99e Initial load
duke
parents:
diff changeset
92
a61af66fc99e Initial load
duke
parents:
diff changeset
93 static address _rethrow_exception_entry; // rethrows an activation in previous frame
a61af66fc99e Initial load
duke
parents:
diff changeset
94
a61af66fc99e Initial load
duke
parents:
diff changeset
95 friend class AbstractInterpreterGenerator;
a61af66fc99e Initial load
duke
parents:
diff changeset
96 friend class InterpreterGenerator;
a61af66fc99e Initial load
duke
parents:
diff changeset
97 friend class InterpreterMacroAssembler;
a61af66fc99e Initial load
duke
parents:
diff changeset
98
a61af66fc99e Initial load
duke
parents:
diff changeset
99 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
100 // Initialization/debugging
a61af66fc99e Initial load
duke
parents:
diff changeset
101 static void initialize();
a61af66fc99e Initial load
duke
parents:
diff changeset
102 static StubQueue* code() { return _code; }
a61af66fc99e Initial load
duke
parents:
diff changeset
103
a61af66fc99e Initial load
duke
parents:
diff changeset
104
a61af66fc99e Initial load
duke
parents:
diff changeset
105 // Method activation
a61af66fc99e Initial load
duke
parents:
diff changeset
106 static MethodKind method_kind(methodHandle m);
a61af66fc99e Initial load
duke
parents:
diff changeset
107 static address entry_for_kind(MethodKind k) { assert(0 <= k && k < number_of_method_entries, "illegal kind"); return _entry_table[k]; }
a61af66fc99e Initial load
duke
parents:
diff changeset
108 static address entry_for_method(methodHandle m) { return _entry_table[method_kind(m)]; }
a61af66fc99e Initial load
duke
parents:
diff changeset
109
a61af66fc99e Initial load
duke
parents:
diff changeset
110 static void print_method_kind(MethodKind kind) PRODUCT_RETURN;
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
114 // Runtime support
a61af66fc99e Initial load
duke
parents:
diff changeset
115
a61af66fc99e Initial load
duke
parents:
diff changeset
116 // length = invoke bytecode length (to advance to next bytecode)
a61af66fc99e Initial load
duke
parents:
diff changeset
117 static address deopt_entry (TosState state, int length) { ShouldNotReachHere(); return NULL; }
a61af66fc99e Initial load
duke
parents:
diff changeset
118 static address return_entry (TosState state, int length) { ShouldNotReachHere(); return NULL; }
a61af66fc99e Initial load
duke
parents:
diff changeset
119
a61af66fc99e Initial load
duke
parents:
diff changeset
120 static address rethrow_exception_entry() { return _rethrow_exception_entry; }
a61af66fc99e Initial load
duke
parents:
diff changeset
121
a61af66fc99e Initial load
duke
parents:
diff changeset
122 // Activation size in words for a method that is just being called.
a61af66fc99e Initial load
duke
parents:
diff changeset
123 // Parameters haven't been pushed so count them too.
a61af66fc99e Initial load
duke
parents:
diff changeset
124 static int size_top_interpreter_activation(methodOop method);
a61af66fc99e Initial load
duke
parents:
diff changeset
125
a61af66fc99e Initial load
duke
parents:
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
136
a61af66fc99e Initial load
duke
parents:
diff changeset
137 // share implementation of size_activation and layout_activation:
a61af66fc99e Initial load
duke
parents:
diff changeset
138 static int size_activation(methodOop method,
a61af66fc99e Initial load
duke
parents:
diff changeset
139 int temps,
a61af66fc99e Initial load
duke
parents:
diff changeset
140 int popframe_args,
a61af66fc99e Initial load
duke
parents:
diff changeset
141 int monitors,
a61af66fc99e Initial load
duke
parents:
diff changeset
142 int callee_params,
a61af66fc99e Initial load
duke
parents:
diff changeset
143 int callee_locals,
a61af66fc99e Initial load
duke
parents:
diff changeset
144 bool is_top_frame);
a61af66fc99e Initial load
duke
parents:
diff changeset
145
a61af66fc99e Initial load
duke
parents:
diff changeset
146 static int layout_activation(methodOop method,
a61af66fc99e Initial load
duke
parents:
diff changeset
147 int temps,
a61af66fc99e Initial load
duke
parents:
diff changeset
148 int popframe_args,
a61af66fc99e Initial load
duke
parents:
diff changeset
149 int monitors,
a61af66fc99e Initial load
duke
parents:
diff changeset
150 int callee_params,
a61af66fc99e Initial load
duke
parents:
diff changeset
151 int callee_locals,
a61af66fc99e Initial load
duke
parents:
diff changeset
152 frame* caller,
a61af66fc99e Initial load
duke
parents:
diff changeset
153 frame* interpreter_frame,
a61af66fc99e Initial load
duke
parents:
diff changeset
154 bool is_top_frame);
a61af66fc99e Initial load
duke
parents:
diff changeset
155
a61af66fc99e Initial load
duke
parents:
diff changeset
156 // Runtime support
a61af66fc99e Initial load
duke
parents:
diff changeset
157 static bool is_not_reached( methodHandle method, int bci);
a61af66fc99e Initial load
duke
parents:
diff changeset
158 // Safepoint support
a61af66fc99e Initial load
duke
parents:
diff changeset
159 static void notice_safepoints() { ShouldNotReachHere(); } // stops the thread when reaching a safepoint
a61af66fc99e Initial load
duke
parents:
diff changeset
160 static void ignore_safepoints() { ShouldNotReachHere(); } // ignores safepoints
a61af66fc99e Initial load
duke
parents:
diff changeset
161
a61af66fc99e Initial load
duke
parents:
diff changeset
162 // Support for native calls
a61af66fc99e Initial load
duke
parents:
diff changeset
163 static address slow_signature_handler() { return _slow_signature_handler; }
a61af66fc99e Initial load
duke
parents:
diff changeset
164 static address result_handler(BasicType type) { return _native_abi_to_tosca[BasicType_as_index(type)]; }
a61af66fc99e Initial load
duke
parents:
diff changeset
165 static int BasicType_as_index(BasicType type); // computes index into result_handler_by_index table
a61af66fc99e Initial load
duke
parents:
diff changeset
166 static bool in_native_entry(address pc) { return _native_entry_begin <= pc && pc < _native_entry_end; }
a61af66fc99e Initial load
duke
parents:
diff changeset
167 // Debugging/printing
a61af66fc99e Initial load
duke
parents:
diff changeset
168 static void print(); // prints the interpreter code
a61af66fc99e Initial load
duke
parents:
diff changeset
169
a61af66fc99e Initial load
duke
parents:
diff changeset
170 public:
1506
2338d41fbd81 6943304: remove tagged stack interpreter
twisti
parents: 1174
diff changeset
171 // Interpreter helpers
2338d41fbd81 6943304: remove tagged stack interpreter
twisti
parents: 1174
diff changeset
172 const static int stackElementWords = 1;
2338d41fbd81 6943304: remove tagged stack interpreter
twisti
parents: 1174
diff changeset
173 const static int stackElementSize = stackElementWords * wordSize;
2338d41fbd81 6943304: remove tagged stack interpreter
twisti
parents: 1174
diff changeset
174 const static int logStackElementSize = LogBytesPerWord;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
175
a61af66fc99e Initial load
duke
parents:
diff changeset
176 // Local values relative to locals[n]
a61af66fc99e Initial load
duke
parents:
diff changeset
177 static int local_offset_in_bytes(int n) {
1506
2338d41fbd81 6943304: remove tagged stack interpreter
twisti
parents: 1174
diff changeset
178 return ((frame::interpreter_frame_expression_stack_direction() * n) * stackElementSize);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
179 }
a61af66fc99e Initial load
duke
parents:
diff changeset
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
2338d41fbd81 6943304: remove tagged stack interpreter
twisti
parents: 1174
diff changeset
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
2338d41fbd81 6943304: remove tagged stack interpreter
twisti
parents: 1174
diff changeset
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
a61af66fc99e Initial load
duke
parents:
diff changeset
234 };
a61af66fc99e Initial load
duke
parents:
diff changeset
235
a61af66fc99e Initial load
duke
parents:
diff changeset
236 //------------------------------------------------------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
237 // The interpreter generator.
a61af66fc99e Initial load
duke
parents:
diff changeset
238
a61af66fc99e Initial load
duke
parents:
diff changeset
239 class Template;
a61af66fc99e Initial load
duke
parents:
diff changeset
240 class AbstractInterpreterGenerator: public StackObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
241 protected:
a61af66fc99e Initial load
duke
parents:
diff changeset
242 InterpreterMacroAssembler* _masm;
a61af66fc99e Initial load
duke
parents:
diff changeset
243
a61af66fc99e Initial load
duke
parents:
diff changeset
244 // shared code sequences
a61af66fc99e Initial load
duke
parents:
diff changeset
245 // Converter for native abi result to tosca result
a61af66fc99e Initial load
duke
parents:
diff changeset
246 address generate_result_handler_for(BasicType type);
a61af66fc99e Initial load
duke
parents:
diff changeset
247 address generate_slow_signature_handler();
a61af66fc99e Initial load
duke
parents:
diff changeset
248
a61af66fc99e Initial load
duke
parents:
diff changeset
249 // entry point generator
a61af66fc99e Initial load
duke
parents:
diff changeset
250 address generate_method_entry(AbstractInterpreter::MethodKind kind);
a61af66fc99e Initial load
duke
parents:
diff changeset
251
a61af66fc99e Initial load
duke
parents:
diff changeset
252 void bang_stack_shadow_pages(bool native_call);
a61af66fc99e Initial load
duke
parents:
diff changeset
253
a61af66fc99e Initial load
duke
parents:
diff changeset
254 void generate_all();
a61af66fc99e Initial load
duke
parents:
diff changeset
255
a61af66fc99e Initial load
duke
parents:
diff changeset
256 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
257 AbstractInterpreterGenerator(StubQueue* _code);
a61af66fc99e Initial load
duke
parents:
diff changeset
258 };