|
1 /* |
|
2 * Copyright 1998-2007 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
|
20 * CA 95054 USA or visit www.sun.com if you need additional information or |
|
21 * have any questions. |
|
22 * |
|
23 */ |
|
24 |
|
25 //------------------------------OptoRuntime------------------------------------ |
|
26 // Opto compiler runtime routines |
|
27 // |
|
28 // These are all generated from Ideal graphs. They are called with the |
|
29 // Java calling convention. Internally they call C++. They are made once at |
|
30 // startup time and Opto compiles calls to them later. |
|
31 // Things are broken up into quads: the signature they will be called with, |
|
32 // the address of the generated code, the corresponding C++ code and an |
|
33 // nmethod. |
|
34 |
|
35 // The signature (returned by "xxx_Type()") is used at startup time by the |
|
36 // Generator to make the generated code "xxx_Java". Opto compiles calls |
|
37 // to the generated code "xxx_Java". When the compiled code gets executed, |
|
38 // it calls the C++ code "xxx_C". The generated nmethod is saved in the |
|
39 // CodeCache. Exception handlers use the nmethod to get the callee-save |
|
40 // register OopMaps. |
|
41 class CallInfo; |
|
42 |
|
43 // |
|
44 // NamedCounters are tagged counters which can be used for profiling |
|
45 // code in various ways. Currently they are used by the lock coarsening code |
|
46 // |
|
47 |
|
48 class NamedCounter : public CHeapObj { |
|
49 public: |
|
50 enum CounterTag { |
|
51 NoTag, |
|
52 LockCounter, |
|
53 EliminatedLockCounter, |
|
54 BiasedLockingCounter |
|
55 }; |
|
56 |
|
57 private: |
|
58 const char * _name; |
|
59 int _count; |
|
60 CounterTag _tag; |
|
61 NamedCounter* _next; |
|
62 |
|
63 public: |
|
64 NamedCounter(const char *n, CounterTag tag = NoTag): |
|
65 _name(n), |
|
66 _count(0), |
|
67 _next(NULL), |
|
68 _tag(tag) {} |
|
69 |
|
70 const char * name() const { return _name; } |
|
71 int count() const { return _count; } |
|
72 address addr() { return (address)&_count; } |
|
73 CounterTag tag() const { return _tag; } |
|
74 void set_tag(CounterTag tag) { _tag = tag; } |
|
75 |
|
76 NamedCounter* next() const { return _next; } |
|
77 void set_next(NamedCounter* next) { |
|
78 assert(_next == NULL, "already set"); |
|
79 _next = next; |
|
80 } |
|
81 |
|
82 }; |
|
83 |
|
84 class BiasedLockingNamedCounter : public NamedCounter { |
|
85 private: |
|
86 BiasedLockingCounters _counters; |
|
87 |
|
88 public: |
|
89 BiasedLockingNamedCounter(const char *n) : |
|
90 NamedCounter(n, BiasedLockingCounter), _counters() {} |
|
91 |
|
92 BiasedLockingCounters* counters() { return &_counters; } |
|
93 }; |
|
94 |
|
95 typedef const TypeFunc*(*TypeFunc_generator)(); |
|
96 |
|
97 class OptoRuntime : public AllStatic { |
|
98 friend class Matcher; // allow access to stub names |
|
99 |
|
100 private: |
|
101 // define stubs |
|
102 static address generate_stub(ciEnv* ci_env, TypeFunc_generator gen, address C_function, const char *name, int is_fancy_jump, bool pass_tls, bool save_arguments, bool return_pc); |
|
103 |
|
104 // References to generated stubs |
|
105 static address _new_instance_Java; |
|
106 static address _new_array_Java; |
|
107 static address _multianewarray2_Java; |
|
108 static address _multianewarray3_Java; |
|
109 static address _multianewarray4_Java; |
|
110 static address _multianewarray5_Java; |
|
111 static address _vtable_must_compile_Java; |
|
112 static address _complete_monitor_locking_Java; |
|
113 static address _rethrow_Java; |
|
114 |
|
115 static address _slow_arraycopy_Java; |
|
116 static address _register_finalizer_Java; |
|
117 |
|
118 # ifdef ENABLE_ZAP_DEAD_LOCALS |
|
119 static address _zap_dead_Java_locals_Java; |
|
120 static address _zap_dead_native_locals_Java; |
|
121 # endif |
|
122 |
|
123 |
|
124 // |
|
125 // Implementation of runtime methods |
|
126 // ================================= |
|
127 |
|
128 // Allocate storage for a Java instance. |
|
129 static void new_instance_C(klassOopDesc* instance_klass, JavaThread *thread); |
|
130 |
|
131 // Allocate storage for a objArray or typeArray |
|
132 static void new_array_C(klassOopDesc* array_klass, int len, JavaThread *thread); |
|
133 |
|
134 // Post-allocation step for implementing ReduceInitialCardMarks: |
|
135 static void do_eager_card_mark(JavaThread* thread); |
|
136 |
|
137 // Allocate storage for a multi-dimensional arrays |
|
138 // Note: needs to be fixed for arbitrary number of dimensions |
|
139 static void multianewarray2_C(klassOopDesc* klass, int len1, int len2, JavaThread *thread); |
|
140 static void multianewarray3_C(klassOopDesc* klass, int len1, int len2, int len3, JavaThread *thread); |
|
141 static void multianewarray4_C(klassOopDesc* klass, int len1, int len2, int len3, int len4, JavaThread *thread); |
|
142 static void multianewarray5_C(klassOopDesc* klass, int len1, int len2, int len3, int len4, int len5, JavaThread *thread); |
|
143 |
|
144 public: |
|
145 // Slow-path Locking and Unlocking |
|
146 static void complete_monitor_locking_C(oopDesc* obj, BasicLock* lock, JavaThread* thread); |
|
147 static void complete_monitor_unlocking_C(oopDesc* obj, BasicLock* lock); |
|
148 |
|
149 private: |
|
150 |
|
151 // Implicit exception support |
|
152 static void throw_null_exception_C(JavaThread* thread); |
|
153 |
|
154 // Exception handling |
|
155 static address handle_exception_C (JavaThread* thread); |
|
156 static address handle_exception_C_helper(JavaThread* thread, nmethod*& nm); |
|
157 static address rethrow_C (oopDesc* exception, JavaThread *thread, address return_pc ); |
|
158 static void deoptimize_caller_frame (JavaThread *thread, bool doit); |
|
159 |
|
160 // CodeBlob support |
|
161 // =================================================================== |
|
162 |
|
163 static ExceptionBlob* _exception_blob; |
|
164 static void generate_exception_blob(); |
|
165 |
|
166 static void register_finalizer(oopDesc* obj, JavaThread* thread); |
|
167 |
|
168 // zaping dead locals, either from Java frames or from native frames |
|
169 # ifdef ENABLE_ZAP_DEAD_LOCALS |
|
170 static void zap_dead_Java_locals_C( JavaThread* thread); |
|
171 static void zap_dead_native_locals_C( JavaThread* thread); |
|
172 |
|
173 static void zap_dead_java_or_native_locals( JavaThread*, bool (*)(frame*)); |
|
174 |
|
175 public: |
|
176 static int ZapDeadCompiledLocals_count; |
|
177 |
|
178 # endif |
|
179 |
|
180 |
|
181 public: |
|
182 |
|
183 static bool is_callee_saved_register(MachRegisterNumbers reg); |
|
184 |
|
185 // One time only generate runtime code stubs |
|
186 static void generate(ciEnv* env); |
|
187 |
|
188 // Returns the name of a stub |
|
189 static const char* stub_name(address entry); |
|
190 |
|
191 // access to runtime stubs entry points for java code |
|
192 static address new_instance_Java() { return _new_instance_Java; } |
|
193 static address new_array_Java() { return _new_array_Java; } |
|
194 static address multianewarray2_Java() { return _multianewarray2_Java; } |
|
195 static address multianewarray3_Java() { return _multianewarray3_Java; } |
|
196 static address multianewarray4_Java() { return _multianewarray4_Java; } |
|
197 static address multianewarray5_Java() { return _multianewarray5_Java; } |
|
198 static address vtable_must_compile_stub() { return _vtable_must_compile_Java; } |
|
199 static address complete_monitor_locking_Java() { return _complete_monitor_locking_Java; } |
|
200 |
|
201 static address slow_arraycopy_Java() { return _slow_arraycopy_Java; } |
|
202 static address register_finalizer_Java() { return _register_finalizer_Java; } |
|
203 |
|
204 |
|
205 # ifdef ENABLE_ZAP_DEAD_LOCALS |
|
206 static address zap_dead_locals_stub(bool is_native) { return is_native |
|
207 ? _zap_dead_native_locals_Java |
|
208 : _zap_dead_Java_locals_Java; } |
|
209 static MachNode* node_to_call_zap_dead_locals(Node* n, int block_num, bool is_native); |
|
210 # endif |
|
211 |
|
212 static ExceptionBlob* exception_blob() { return _exception_blob; } |
|
213 |
|
214 // Leaf routines helping with method data update |
|
215 static void profile_receiver_type_C(DataLayout* data, oopDesc* receiver); |
|
216 |
|
217 // Implicit exception support |
|
218 static void throw_div0_exception_C (JavaThread* thread); |
|
219 static void throw_stack_overflow_error_C(JavaThread* thread); |
|
220 |
|
221 // Exception handling |
|
222 static address rethrow_stub() { return _rethrow_Java; } |
|
223 |
|
224 |
|
225 // Type functions |
|
226 // ====================================================== |
|
227 |
|
228 static const TypeFunc* new_instance_Type(); // object allocation (slow case) |
|
229 static const TypeFunc* new_array_Type (); // [a]newarray (slow case) |
|
230 static const TypeFunc* multianewarray_Type(int ndim); // multianewarray |
|
231 static const TypeFunc* multianewarray2_Type(); // multianewarray |
|
232 static const TypeFunc* multianewarray3_Type(); // multianewarray |
|
233 static const TypeFunc* multianewarray4_Type(); // multianewarray |
|
234 static const TypeFunc* multianewarray5_Type(); // multianewarray |
|
235 static const TypeFunc* complete_monitor_enter_Type(); |
|
236 static const TypeFunc* complete_monitor_exit_Type(); |
|
237 static const TypeFunc* uncommon_trap_Type(); |
|
238 static const TypeFunc* athrow_Type(); |
|
239 static const TypeFunc* rethrow_Type(); |
|
240 static const TypeFunc* Math_D_D_Type(); // sin,cos & friends |
|
241 static const TypeFunc* Math_DD_D_Type(); // mod,pow & friends |
|
242 static const TypeFunc* modf_Type(); |
|
243 static const TypeFunc* l2f_Type(); |
|
244 static const TypeFunc* current_time_millis_Type(); |
|
245 |
|
246 static const TypeFunc* flush_windows_Type(); |
|
247 |
|
248 // arraycopy routine types |
|
249 static const TypeFunc* fast_arraycopy_Type(); // bit-blasters |
|
250 static const TypeFunc* checkcast_arraycopy_Type(); |
|
251 static const TypeFunc* generic_arraycopy_Type(); |
|
252 static const TypeFunc* slow_arraycopy_Type(); // the full routine |
|
253 |
|
254 // leaf on stack replacement interpreter accessor types |
|
255 static const TypeFunc* osr_end_Type(); |
|
256 |
|
257 // leaf methodData routine types |
|
258 static const TypeFunc* profile_receiver_type_Type(); |
|
259 |
|
260 // leaf on stack replacement interpreter accessor types |
|
261 static const TypeFunc* fetch_int_Type(); |
|
262 static const TypeFunc* fetch_long_Type(); |
|
263 static const TypeFunc* fetch_float_Type(); |
|
264 static const TypeFunc* fetch_double_Type(); |
|
265 static const TypeFunc* fetch_oop_Type(); |
|
266 static const TypeFunc* fetch_monitor_Type(); |
|
267 |
|
268 static const TypeFunc* register_finalizer_Type(); |
|
269 |
|
270 // Dtrace support |
|
271 static const TypeFunc* dtrace_method_entry_exit_Type(); |
|
272 static const TypeFunc* dtrace_object_alloc_Type(); |
|
273 |
|
274 # ifdef ENABLE_ZAP_DEAD_LOCALS |
|
275 static const TypeFunc* zap_dead_locals_Type(); |
|
276 # endif |
|
277 |
|
278 private: |
|
279 static NamedCounter * volatile _named_counters; |
|
280 |
|
281 public: |
|
282 // helper function which creates a named counter labeled with the |
|
283 // if they are available |
|
284 static NamedCounter* new_named_counter(JVMState* jvms, NamedCounter::CounterTag tag); |
|
285 |
|
286 // dumps all the named counters |
|
287 static void print_named_counters(); |
|
288 |
|
289 }; |