|
1692
|
1 /*
|
|
|
2 * Copyright (c) 1999, 2007, Oracle and/or its affiliates. All rights reserved.
|
|
|
3 * Copyright 2008, 2009, 2010 Red Hat, Inc.
|
|
|
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
|
5 *
|
|
|
6 * This code is free software; you can redistribute it and/or modify it
|
|
|
7 * under the terms of the GNU General Public License version 2 only, as
|
|
|
8 * published by the Free Software Foundation.
|
|
|
9 *
|
|
|
10 * This code is distributed in the hope that it will be useful, but WITHOUT
|
|
|
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
13 * version 2 for more details (a copy is included in the LICENSE file that
|
|
|
14 * accompanied this code).
|
|
|
15 *
|
|
|
16 * You should have received a copy of the GNU General Public License version
|
|
|
17 * 2 along with this work; if not, write to the Free Software Foundation,
|
|
|
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
19 *
|
|
|
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
|
21 * or visit www.oracle.com if you need additional information or have any
|
|
|
22 * questions.
|
|
|
23 *
|
|
|
24 */
|
|
|
25
|
|
|
26 class SharkTopLevelBlock : public SharkBlock {
|
|
|
27 public:
|
|
|
28 SharkTopLevelBlock(SharkFunction* function, ciTypeFlow::Block* ciblock)
|
|
|
29 : SharkBlock(function),
|
|
|
30 _function(function),
|
|
|
31 _ciblock(ciblock),
|
|
|
32 _entered(false),
|
|
|
33 _has_trap(false),
|
|
|
34 _needs_phis(false),
|
|
|
35 _entry_state(NULL),
|
|
|
36 _entry_block(NULL) {}
|
|
|
37
|
|
|
38 private:
|
|
|
39 SharkFunction* _function;
|
|
|
40 ciTypeFlow::Block* _ciblock;
|
|
|
41
|
|
|
42 public:
|
|
|
43 SharkFunction* function() const {
|
|
|
44 return _function;
|
|
|
45 }
|
|
|
46 ciTypeFlow::Block* ciblock() const {
|
|
|
47 return _ciblock;
|
|
|
48 }
|
|
|
49
|
|
|
50 // Function properties
|
|
|
51 public:
|
|
|
52 SharkStack* stack() const {
|
|
|
53 return function()->stack();
|
|
|
54 }
|
|
|
55
|
|
|
56 // Typeflow properties
|
|
|
57 public:
|
|
|
58 int index() const {
|
|
|
59 return ciblock()->pre_order();
|
|
|
60 }
|
|
|
61 bool is_backedge_copy() const {
|
|
|
62 return ciblock()->is_backedge_copy();
|
|
|
63 }
|
|
|
64 int stack_depth_at_entry() const {
|
|
|
65 return ciblock()->stack_size();
|
|
|
66 }
|
|
|
67 ciType* local_type_at_entry(int index) const {
|
|
|
68 return ciblock()->local_type_at(index);
|
|
|
69 }
|
|
|
70 ciType* stack_type_at_entry(int slot) const {
|
|
|
71 return ciblock()->stack_type_at(slot);
|
|
|
72 }
|
|
|
73 int start() const {
|
|
|
74 return ciblock()->start();
|
|
|
75 }
|
|
|
76 int limit() const {
|
|
|
77 return ciblock()->limit();
|
|
|
78 }
|
|
|
79 bool falls_through() const {
|
|
|
80 return ciblock()->control() == ciBlock::fall_through_bci;
|
|
|
81 }
|
|
|
82 int num_successors() const {
|
|
|
83 return ciblock()->successors()->length();
|
|
|
84 }
|
|
|
85 SharkTopLevelBlock* successor(int index) const {
|
|
|
86 return function()->block(ciblock()->successors()->at(index)->pre_order());
|
|
|
87 }
|
|
|
88 SharkTopLevelBlock* bci_successor(int bci) const;
|
|
|
89
|
|
|
90 // Exceptions
|
|
|
91 private:
|
|
|
92 GrowableArray<ciExceptionHandler*>* _exc_handlers;
|
|
|
93 GrowableArray<SharkTopLevelBlock*>* _exceptions;
|
|
|
94
|
|
|
95 private:
|
|
|
96 void compute_exceptions();
|
|
|
97
|
|
|
98 private:
|
|
|
99 int num_exceptions() const {
|
|
|
100 return _exc_handlers->length();
|
|
|
101 }
|
|
|
102 ciExceptionHandler* exc_handler(int index) const {
|
|
|
103 return _exc_handlers->at(index);
|
|
|
104 }
|
|
|
105 SharkTopLevelBlock* exception(int index) const {
|
|
|
106 return _exceptions->at(index);
|
|
|
107 }
|
|
|
108
|
|
|
109 // Traps
|
|
|
110 private:
|
|
|
111 bool _has_trap;
|
|
|
112 int _trap_request;
|
|
|
113 int _trap_bci;
|
|
|
114
|
|
|
115 void set_trap(int trap_request, int trap_bci) {
|
|
|
116 assert(!has_trap(), "shouldn't have");
|
|
|
117 _has_trap = true;
|
|
|
118 _trap_request = trap_request;
|
|
|
119 _trap_bci = trap_bci;
|
|
|
120 }
|
|
|
121
|
|
|
122 private:
|
|
|
123 bool has_trap() {
|
|
|
124 return _has_trap;
|
|
|
125 }
|
|
|
126 int trap_request() {
|
|
|
127 assert(has_trap(), "should have");
|
|
|
128 return _trap_request;
|
|
|
129 }
|
|
|
130 int trap_bci() {
|
|
|
131 assert(has_trap(), "should have");
|
|
|
132 return _trap_bci;
|
|
|
133 }
|
|
|
134
|
|
|
135 private:
|
|
|
136 void scan_for_traps();
|
|
|
137
|
|
|
138 private:
|
|
|
139 bool static_field_ok_in_clinit(ciField* field);
|
|
|
140
|
|
|
141 // Entry state
|
|
|
142 private:
|
|
|
143 bool _entered;
|
|
|
144 bool _needs_phis;
|
|
|
145
|
|
|
146 public:
|
|
|
147 bool entered() const {
|
|
|
148 return _entered;
|
|
|
149 }
|
|
|
150 bool needs_phis() const {
|
|
|
151 return _needs_phis;
|
|
|
152 }
|
|
|
153
|
|
|
154 private:
|
|
|
155 void enter(SharkTopLevelBlock* predecessor, bool is_exception);
|
|
|
156
|
|
|
157 public:
|
|
|
158 void enter() {
|
|
|
159 enter(NULL, false);
|
|
|
160 }
|
|
|
161
|
|
|
162 private:
|
|
|
163 SharkState* _entry_state;
|
|
|
164
|
|
|
165 private:
|
|
|
166 SharkState* entry_state();
|
|
|
167
|
|
|
168 private:
|
|
|
169 llvm::BasicBlock* _entry_block;
|
|
|
170
|
|
|
171 public:
|
|
|
172 llvm::BasicBlock* entry_block() const {
|
|
|
173 return _entry_block;
|
|
|
174 }
|
|
|
175
|
|
|
176 public:
|
|
|
177 void initialize();
|
|
|
178
|
|
|
179 public:
|
|
|
180 void add_incoming(SharkState* incoming_state);
|
|
|
181
|
|
|
182 // Method
|
|
|
183 public:
|
|
|
184 llvm::Value* method() {
|
|
|
185 return current_state()->method();
|
|
|
186 }
|
|
|
187
|
|
|
188 // Temporary oop storage
|
|
|
189 public:
|
|
|
190 void set_oop_tmp(llvm::Value* value) {
|
|
|
191 assert(value, "value must be non-NULL (will be reset by get_oop_tmp)");
|
|
|
192 assert(!current_state()->oop_tmp(), "oop_tmp gets and sets must match");
|
|
|
193 current_state()->set_oop_tmp(value);
|
|
|
194 }
|
|
|
195 llvm::Value* get_oop_tmp() {
|
|
|
196 llvm::Value* value = current_state()->oop_tmp();
|
|
|
197 assert(value, "oop_tmp gets and sets must match");
|
|
|
198 current_state()->set_oop_tmp(NULL);
|
|
|
199 return value;
|
|
|
200 }
|
|
|
201
|
|
|
202 // Cache and decache
|
|
|
203 private:
|
|
|
204 void decache_for_Java_call(ciMethod* callee);
|
|
|
205 void cache_after_Java_call(ciMethod* callee);
|
|
|
206 void decache_for_VM_call();
|
|
|
207 void cache_after_VM_call();
|
|
|
208 void decache_for_trap();
|
|
|
209
|
|
|
210 // Monitors
|
|
|
211 private:
|
|
|
212 int num_monitors() {
|
|
|
213 return current_state()->num_monitors();
|
|
|
214 }
|
|
|
215 int set_num_monitors(int num_monitors) {
|
|
|
216 current_state()->set_num_monitors(num_monitors);
|
|
|
217 }
|
|
|
218
|
|
|
219 // Code generation
|
|
|
220 public:
|
|
|
221 void emit_IR();
|
|
|
222
|
|
|
223 // Branch helpers
|
|
|
224 private:
|
|
|
225 void do_branch(int successor_index);
|
|
|
226
|
|
|
227 // Zero checks
|
|
|
228 private:
|
|
|
229 void do_zero_check(SharkValue* value);
|
|
|
230 void zero_check_value(SharkValue* value, llvm::BasicBlock* continue_block);
|
|
|
231
|
|
|
232 public:
|
|
|
233 void do_deferred_zero_check(SharkValue* value,
|
|
|
234 int bci,
|
|
|
235 SharkState* saved_state,
|
|
|
236 llvm::BasicBlock* continue_block);
|
|
|
237 // Exceptions
|
|
|
238 private:
|
|
|
239 llvm::Value* pending_exception_address() const {
|
|
|
240 return builder()->CreateAddressOfStructEntry(
|
|
|
241 thread(), Thread::pending_exception_offset(),
|
|
|
242 llvm::PointerType::getUnqual(SharkType::oop_type()),
|
|
|
243 "pending_exception_addr");
|
|
|
244 }
|
|
|
245 llvm::LoadInst* get_pending_exception() const {
|
|
|
246 return builder()->CreateLoad(
|
|
|
247 pending_exception_address(), "pending_exception");
|
|
|
248 }
|
|
|
249 void clear_pending_exception() const {
|
|
|
250 builder()->CreateStore(LLVMValue::null(), pending_exception_address());
|
|
|
251 }
|
|
|
252 public:
|
|
|
253 enum ExceptionActionMask {
|
|
|
254 // The actual bitmasks that things test against
|
|
|
255 EAM_CHECK = 1, // whether to check for pending exceptions
|
|
|
256 EAM_HANDLE = 2, // whether to attempt to handle pending exceptions
|
|
|
257 EAM_MONITOR_FUDGE = 4, // whether the monitor count needs adjusting
|
|
|
258
|
|
|
259 // More convenient values for passing
|
|
|
260 EX_CHECK_NONE = 0,
|
|
|
261 EX_CHECK_NO_CATCH = EAM_CHECK,
|
|
|
262 EX_CHECK_FULL = EAM_CHECK | EAM_HANDLE
|
|
|
263 };
|
|
|
264 void check_pending_exception(int action);
|
|
|
265 void handle_exception(llvm::Value* exception, int action);
|
|
|
266 void marshal_exception_fast(int num_options);
|
|
|
267 void marshal_exception_slow(int num_options);
|
|
|
268 llvm::BasicBlock* handler_for_exception(int index);
|
|
|
269
|
|
|
270 // VM calls
|
|
|
271 private:
|
|
|
272 llvm::CallInst* call_vm(llvm::Value* callee,
|
|
|
273 llvm::Value** args_start,
|
|
|
274 llvm::Value** args_end,
|
|
|
275 int exception_action) {
|
|
|
276 decache_for_VM_call();
|
|
|
277 stack()->CreateSetLastJavaFrame();
|
|
|
278 llvm::CallInst *res = builder()->CreateCall(callee, args_start, args_end);
|
|
|
279 stack()->CreateResetLastJavaFrame();
|
|
|
280 cache_after_VM_call();
|
|
|
281 if (exception_action & EAM_CHECK) {
|
|
|
282 check_pending_exception(exception_action);
|
|
|
283 current_state()->set_has_safepointed(true);
|
|
|
284 }
|
|
|
285 return res;
|
|
|
286 }
|
|
|
287
|
|
|
288 public:
|
|
|
289 llvm::CallInst* call_vm(llvm::Value* callee,
|
|
|
290 int exception_action) {
|
|
|
291 llvm::Value *args[] = {thread()};
|
|
|
292 return call_vm(callee, args, args + 1, exception_action);
|
|
|
293 }
|
|
|
294 llvm::CallInst* call_vm(llvm::Value* callee,
|
|
|
295 llvm::Value* arg1,
|
|
|
296 int exception_action) {
|
|
|
297 llvm::Value *args[] = {thread(), arg1};
|
|
|
298 return call_vm(callee, args, args + 2, exception_action);
|
|
|
299 }
|
|
|
300 llvm::CallInst* call_vm(llvm::Value* callee,
|
|
|
301 llvm::Value* arg1,
|
|
|
302 llvm::Value* arg2,
|
|
|
303 int exception_action) {
|
|
|
304 llvm::Value *args[] = {thread(), arg1, arg2};
|
|
|
305 return call_vm(callee, args, args + 3, exception_action);
|
|
|
306 }
|
|
|
307 llvm::CallInst* call_vm(llvm::Value* callee,
|
|
|
308 llvm::Value* arg1,
|
|
|
309 llvm::Value* arg2,
|
|
|
310 llvm::Value* arg3,
|
|
|
311 int exception_action) {
|
|
|
312 llvm::Value *args[] = {thread(), arg1, arg2, arg3};
|
|
|
313 return call_vm(callee, args, args + 4, exception_action);
|
|
|
314 }
|
|
|
315
|
|
|
316 // VM call oop return handling
|
|
|
317 private:
|
|
|
318 llvm::LoadInst* get_vm_result() const {
|
|
|
319 llvm::Value *addr = builder()->CreateAddressOfStructEntry(
|
|
|
320 thread(), JavaThread::vm_result_offset(),
|
|
|
321 llvm::PointerType::getUnqual(SharkType::oop_type()),
|
|
|
322 "vm_result_addr");
|
|
|
323 llvm::LoadInst *result = builder()->CreateLoad(addr, "vm_result");
|
|
|
324 builder()->CreateStore(LLVMValue::null(), addr);
|
|
|
325 return result;
|
|
|
326 }
|
|
|
327
|
|
|
328 // Synchronization
|
|
|
329 private:
|
|
|
330 void acquire_lock(llvm::Value* lockee, int exception_action);
|
|
|
331 void release_lock(int exception_action);
|
|
|
332
|
|
|
333 public:
|
|
|
334 void acquire_method_lock();
|
|
|
335
|
|
|
336 // Bounds checks
|
|
|
337 private:
|
|
|
338 void check_bounds(SharkValue* array, SharkValue* index);
|
|
|
339
|
|
|
340 // Safepoints
|
|
|
341 private:
|
|
|
342 void maybe_add_safepoint();
|
|
|
343 void maybe_add_backedge_safepoint();
|
|
|
344
|
|
|
345 // Loop safepoint removal
|
|
|
346 private:
|
|
|
347 bool _can_reach_visited;
|
|
|
348
|
|
|
349 bool can_reach(SharkTopLevelBlock* other);
|
|
|
350 bool can_reach_helper(SharkTopLevelBlock* other);
|
|
|
351
|
|
|
352 // Traps
|
|
|
353 private:
|
|
|
354 llvm::BasicBlock* make_trap(int trap_bci, int trap_request);
|
|
|
355 void do_trap(int trap_request);
|
|
|
356
|
|
|
357 // Returns
|
|
|
358 private:
|
|
|
359 void call_register_finalizer(llvm::Value* receiver);
|
|
|
360 void handle_return(BasicType type, llvm::Value* exception);
|
|
|
361
|
|
|
362 // arraylength
|
|
|
363 private:
|
|
|
364 void do_arraylength();
|
|
|
365
|
|
|
366 // *aload and *astore
|
|
|
367 private:
|
|
|
368 void do_aload(BasicType basic_type);
|
|
|
369 void do_astore(BasicType basic_type);
|
|
|
370
|
|
|
371 // *return and athrow
|
|
|
372 private:
|
|
|
373 void do_return(BasicType type);
|
|
|
374 void do_athrow();
|
|
|
375
|
|
|
376 // goto*
|
|
|
377 private:
|
|
|
378 void do_goto();
|
|
|
379
|
|
|
380 // jsr* and ret
|
|
|
381 private:
|
|
|
382 void do_jsr();
|
|
|
383 void do_ret();
|
|
|
384
|
|
|
385 // if*
|
|
|
386 private:
|
|
|
387 void do_if_helper(llvm::ICmpInst::Predicate p,
|
|
|
388 llvm::Value* b,
|
|
|
389 llvm::Value* a,
|
|
|
390 SharkState* if_taken_state,
|
|
|
391 SharkState* not_taken_state);
|
|
|
392 void do_if(llvm::ICmpInst::Predicate p, SharkValue* b, SharkValue* a);
|
|
|
393
|
|
|
394 // tableswitch and lookupswitch
|
|
|
395 private:
|
|
|
396 void do_switch();
|
|
|
397
|
|
|
398 // invoke*
|
|
|
399 private:
|
|
|
400 ciMethod* improve_virtual_call(ciMethod* caller,
|
|
|
401 ciInstanceKlass* klass,
|
|
|
402 ciMethod* dest_method,
|
|
|
403 ciType* receiver_type);
|
|
|
404 llvm::Value* get_direct_callee(ciMethod* method);
|
|
|
405 llvm::Value* get_virtual_callee(SharkValue* receiver, int vtable_index);
|
|
|
406 llvm::Value* get_interface_callee(SharkValue* receiver, ciMethod* method);
|
|
|
407
|
|
|
408 void do_call();
|
|
|
409
|
|
|
410 // checkcast and instanceof
|
|
|
411 private:
|
|
|
412 bool static_subtype_check(ciKlass* check_klass, ciKlass* object_klass);
|
|
|
413 void do_full_instance_check(ciKlass* klass);
|
|
|
414 void do_trapping_instance_check(ciKlass* klass);
|
|
|
415
|
|
|
416 void do_instance_check();
|
|
|
417 bool maybe_do_instanceof_if();
|
|
|
418
|
|
|
419 // new and *newarray
|
|
|
420 private:
|
|
|
421 void do_new();
|
|
|
422 void do_newarray();
|
|
|
423 void do_anewarray();
|
|
|
424 void do_multianewarray();
|
|
|
425
|
|
|
426 // monitorenter and monitorexit
|
|
|
427 private:
|
|
|
428 void do_monitorenter();
|
|
|
429 void do_monitorexit();
|
|
|
430 };
|
