1 /*
2 * Copyright (c) 1999, 2019, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_C1_C1_INSTRUCTION_HPP
26 #define SHARE_C1_C1_INSTRUCTION_HPP
27
28 #include "c1/c1_Compilation.hpp"
29 #include "c1/c1_LIR.hpp"
30 #include "c1/c1_ValueType.hpp"
31 #include "ci/ciField.hpp"
32
33 // Predefined classes
34 class ciField;
35 class ValueStack;
36 class InstructionPrinter;
37 class IRScope;
38 class LIR_OprDesc;
39 typedef LIR_OprDesc* LIR_Opr;
40
41
42 // Instruction class hierarchy
43 //
44 // All leaf classes in the class hierarchy are concrete classes
45 // (i.e., are instantiated). All other classes are abstract and
46 // serve factoring.
47
48 class Instruction;
49 class Phi;
50 class Local;
51 class Constant;
52 class AccessField;
53 class LoadField;
54 class StoreField;
55 class AccessArray;
56 class ArrayLength;
57 class AccessIndexed;
58 class LoadIndexed;
59 class StoreIndexed;
60 class NegateOp;
61 class Op2;
62 class ArithmeticOp;
63 class ShiftOp;
64 class LogicOp;
65 class CompareOp;
66 class IfOp;
67 class Convert;
68 class NullCheck;
69 class TypeCast;
70 class OsrEntry;
71 class ExceptionObject;
72 class StateSplit;
73 class Invoke;
74 class NewInstance;
75 class NewValueTypeInstance;
76 class NewArray;
77 class NewTypeArray;
78 class NewObjectArray;
79 class NewMultiArray;
80 class TypeCheck;
81 class CheckCast;
82 class InstanceOf;
83 class AccessMonitor;
84 class MonitorEnter;
85 class MonitorExit;
86 class Intrinsic;
87 class BlockBegin;
88 class BlockEnd;
89 class Goto;
90 class If;
91 class IfInstanceOf;
92 class Switch;
93 class TableSwitch;
94 class LookupSwitch;
95 class Return;
96 class Throw;
97 class Base;
98 class RoundFP;
99 class UnsafeOp;
100 class UnsafeRawOp;
101 class UnsafeGetRaw;
102 class UnsafePutRaw;
103 class UnsafeObjectOp;
104 class UnsafeGetObject;
105 class UnsafePutObject;
106 class UnsafeGetAndSetObject;
107 class ProfileCall;
108 class ProfileReturnType;
109 class ProfileInvoke;
110 class RuntimeCall;
111 class MemBar;
112 class RangeCheckPredicate;
113 #ifdef ASSERT
114 class Assert;
115 #endif
116
117 // A Value is a reference to the instruction creating the value
118 typedef Instruction* Value;
119 typedef GrowableArray<Value> Values;
120 typedef GrowableArray<ValueStack*> ValueStackStack;
121
122 // BlockClosure is the base class for block traversal/iteration.
123
124 class BlockClosure: public CompilationResourceObj {
125 public:
126 virtual void block_do(BlockBegin* block) = 0;
127 };
128
129
130 // A simple closure class for visiting the values of an Instruction
131 class ValueVisitor: public StackObj {
132 public:
133 virtual void visit(Value* v) = 0;
134 };
135
136
137 // Some array and list classes
138 typedef GrowableArray<BlockBegin*> BlockBeginArray;
139
140 class BlockList: public GrowableArray<BlockBegin*> {
141 public:
142 BlockList(): GrowableArray<BlockBegin*>() {}
143 BlockList(const int size): GrowableArray<BlockBegin*>(size) {}
144 BlockList(const int size, BlockBegin* init): GrowableArray<BlockBegin*>(size, size, init) {}
145
146 void iterate_forward(BlockClosure* closure);
147 void iterate_backward(BlockClosure* closure);
148 void blocks_do(void f(BlockBegin*));
149 void values_do(ValueVisitor* f);
150 void print(bool cfg_only = false, bool live_only = false) PRODUCT_RETURN;
151 };
152
153
154 // InstructionVisitors provide type-based dispatch for instructions.
155 // For each concrete Instruction class X, a virtual function do_X is
156 // provided. Functionality that needs to be implemented for all classes
157 // (e.g., printing, code generation) is factored out into a specialised
158 // visitor instead of added to the Instruction classes itself.
159
160 class InstructionVisitor: public StackObj {
161 public:
162 virtual void do_Phi (Phi* x) = 0;
163 virtual void do_Local (Local* x) = 0;
164 virtual void do_Constant (Constant* x) = 0;
165 virtual void do_LoadField (LoadField* x) = 0;
166 virtual void do_StoreField (StoreField* x) = 0;
167 virtual void do_ArrayLength (ArrayLength* x) = 0;
168 virtual void do_LoadIndexed (LoadIndexed* x) = 0;
169 virtual void do_StoreIndexed (StoreIndexed* x) = 0;
170 virtual void do_NegateOp (NegateOp* x) = 0;
171 virtual void do_ArithmeticOp (ArithmeticOp* x) = 0;
172 virtual void do_ShiftOp (ShiftOp* x) = 0;
173 virtual void do_LogicOp (LogicOp* x) = 0;
174 virtual void do_CompareOp (CompareOp* x) = 0;
175 virtual void do_IfOp (IfOp* x) = 0;
176 virtual void do_Convert (Convert* x) = 0;
177 virtual void do_NullCheck (NullCheck* x) = 0;
178 virtual void do_TypeCast (TypeCast* x) = 0;
179 virtual void do_Invoke (Invoke* x) = 0;
180 virtual void do_NewInstance (NewInstance* x) = 0;
181 virtual void do_NewValueTypeInstance(NewValueTypeInstance* x) = 0;
182 virtual void do_NewTypeArray (NewTypeArray* x) = 0;
183 virtual void do_NewObjectArray (NewObjectArray* x) = 0;
184 virtual void do_NewMultiArray (NewMultiArray* x) = 0;
185 virtual void do_CheckCast (CheckCast* x) = 0;
186 virtual void do_InstanceOf (InstanceOf* x) = 0;
187 virtual void do_MonitorEnter (MonitorEnter* x) = 0;
188 virtual void do_MonitorExit (MonitorExit* x) = 0;
189 virtual void do_Intrinsic (Intrinsic* x) = 0;
190 virtual void do_BlockBegin (BlockBegin* x) = 0;
191 virtual void do_Goto (Goto* x) = 0;
192 virtual void do_If (If* x) = 0;
193 virtual void do_IfInstanceOf (IfInstanceOf* x) = 0;
194 virtual void do_TableSwitch (TableSwitch* x) = 0;
195 virtual void do_LookupSwitch (LookupSwitch* x) = 0;
196 virtual void do_Return (Return* x) = 0;
197 virtual void do_Throw (Throw* x) = 0;
198 virtual void do_Base (Base* x) = 0;
199 virtual void do_OsrEntry (OsrEntry* x) = 0;
200 virtual void do_ExceptionObject(ExceptionObject* x) = 0;
201 virtual void do_RoundFP (RoundFP* x) = 0;
202 virtual void do_UnsafeGetRaw (UnsafeGetRaw* x) = 0;
203 virtual void do_UnsafePutRaw (UnsafePutRaw* x) = 0;
204 virtual void do_UnsafeGetObject(UnsafeGetObject* x) = 0;
205 virtual void do_UnsafePutObject(UnsafePutObject* x) = 0;
206 virtual void do_UnsafeGetAndSetObject(UnsafeGetAndSetObject* x) = 0;
207 virtual void do_ProfileCall (ProfileCall* x) = 0;
208 virtual void do_ProfileReturnType (ProfileReturnType* x) = 0;
209 virtual void do_ProfileInvoke (ProfileInvoke* x) = 0;
210 virtual void do_RuntimeCall (RuntimeCall* x) = 0;
211 virtual void do_MemBar (MemBar* x) = 0;
212 virtual void do_RangeCheckPredicate(RangeCheckPredicate* x) = 0;
213 #ifdef ASSERT
214 virtual void do_Assert (Assert* x) = 0;
215 #endif
216 };
217
218
219 // Hashing support
220 //
221 // Note: This hash functions affect the performance
222 // of ValueMap - make changes carefully!
223
224 #define HASH1(x1 ) ((intx)(x1))
225 #define HASH2(x1, x2 ) ((HASH1(x1 ) << 7) ^ HASH1(x2))
226 #define HASH3(x1, x2, x3 ) ((HASH2(x1, x2 ) << 7) ^ HASH1(x3))
227 #define HASH4(x1, x2, x3, x4) ((HASH3(x1, x2, x3) << 7) ^ HASH1(x4))
228
229
230 // The following macros are used to implement instruction-specific hashing.
231 // By default, each instruction implements hash() and is_equal(Value), used
232 // for value numbering/common subexpression elimination. The default imple-
233 // mentation disables value numbering. Each instruction which can be value-
234 // numbered, should define corresponding hash() and is_equal(Value) functions
235 // via the macros below. The f arguments specify all the values/op codes, etc.
236 // that need to be identical for two instructions to be identical.
237 //
238 // Note: The default implementation of hash() returns 0 in order to indicate
239 // that the instruction should not be considered for value numbering.
240 // The currently used hash functions do not guarantee that never a 0
241 // is produced. While this is still correct, it may be a performance
242 // bug (no value numbering for that node). However, this situation is
243 // so unlikely, that we are not going to handle it specially.
244
245 #define HASHING1(class_name, enabled, f1) \
246 virtual intx hash() const { \
247 return (enabled) ? HASH2(name(), f1) : 0; \
248 } \
249 virtual bool is_equal(Value v) const { \
250 if (!(enabled) ) return false; \
251 class_name* _v = v->as_##class_name(); \
252 if (_v == NULL ) return false; \
253 if (f1 != _v->f1) return false; \
254 return true; \
255 } \
256
257
258 #define HASHING2(class_name, enabled, f1, f2) \
259 virtual intx hash() const { \
260 return (enabled) ? HASH3(name(), f1, f2) : 0; \
261 } \
262 virtual bool is_equal(Value v) const { \
263 if (!(enabled) ) return false; \
264 class_name* _v = v->as_##class_name(); \
265 if (_v == NULL ) return false; \
266 if (f1 != _v->f1) return false; \
267 if (f2 != _v->f2) return false; \
268 return true; \
269 } \
270
271
272 #define HASHING3(class_name, enabled, f1, f2, f3) \
273 virtual intx hash() const { \
274 return (enabled) ? HASH4(name(), f1, f2, f3) : 0; \
275 } \
276 virtual bool is_equal(Value v) const { \
277 if (!(enabled) ) return false; \
278 class_name* _v = v->as_##class_name(); \
279 if (_v == NULL ) return false; \
280 if (f1 != _v->f1) return false; \
281 if (f2 != _v->f2) return false; \
282 if (f3 != _v->f3) return false; \
283 return true; \
284 } \
285
286
287 // The mother of all instructions...
288
289 class Instruction: public CompilationResourceObj {
290 private:
291 int _id; // the unique instruction id
292 #ifndef PRODUCT
293 int _printable_bci; // the bci of the instruction for printing
294 #endif
295 int _use_count; // the number of instructions refering to this value (w/o prev/next); only roots can have use count = 0 or > 1
296 int _pin_state; // set of PinReason describing the reason for pinning
297 ValueType* _type; // the instruction value type
298 Instruction* _next; // the next instruction if any (NULL for BlockEnd instructions)
299 Instruction* _subst; // the substitution instruction if any
300 LIR_Opr _operand; // LIR specific information
301 unsigned int _flags; // Flag bits
302
303 ValueStack* _state_before; // Copy of state with input operands still on stack (or NULL)
304 ValueStack* _exception_state; // Copy of state for exception handling
305 XHandlers* _exception_handlers; // Flat list of exception handlers covering this instruction
306
307 friend class UseCountComputer;
308 friend class BlockBegin;
309
310 void update_exception_state(ValueStack* state);
311
312 protected:
313 BlockBegin* _block; // Block that contains this instruction
314
315 void set_type(ValueType* type) {
316 assert(type != NULL, "type must exist");
317 _type = type;
318 }
319
320 // Helper class to keep track of which arguments need a null check
321 class ArgsNonNullState {
322 private:
323 int _nonnull_state; // mask identifying which args are nonnull
324 public:
325 ArgsNonNullState()
326 : _nonnull_state(AllBits) {}
327
328 // Does argument number i needs a null check?
329 bool arg_needs_null_check(int i) const {
330 // No data is kept for arguments starting at position 33 so
331 // conservatively assume that they need a null check.
332 if (i >= 0 && i < (int)sizeof(_nonnull_state) * BitsPerByte) {
333 return is_set_nth_bit(_nonnull_state, i);
334 }
335 return true;
336 }
337
338 // Set whether argument number i needs a null check or not
339 void set_arg_needs_null_check(int i, bool check) {
340 if (i >= 0 && i < (int)sizeof(_nonnull_state) * BitsPerByte) {
341 if (check) {
342 _nonnull_state |= nth_bit(i);
343 } else {
344 _nonnull_state &= ~(nth_bit(i));
345 }
346 }
347 }
348 };
349
350 public:
351 void* operator new(size_t size) throw() {
352 Compilation* c = Compilation::current();
353 void* res = c->arena()->Amalloc(size);
354 ((Instruction*)res)->_id = c->get_next_id();
355 return res;
356 }
357
358 static const int no_bci = -99;
359
360 enum InstructionFlag {
361 NeedsNullCheckFlag = 0,
362 NeverNullFlag, // For "Q" signatures
363 CanTrapFlag,
364 DirectCompareFlag,
365 IsEliminatedFlag,
366 IsSafepointFlag,
367 IsStaticFlag,
368 IsStrictfpFlag,
369 NeedsStoreCheckFlag,
370 NeedsWriteBarrierFlag,
371 PreservesStateFlag,
372 TargetIsFinalFlag,
373 TargetIsLoadedFlag,
374 TargetIsStrictfpFlag,
375 UnorderedIsTrueFlag,
376 NeedsPatchingFlag,
377 ThrowIncompatibleClassChangeErrorFlag,
378 InvokeSpecialReceiverCheckFlag,
379 ProfileMDOFlag,
380 IsLinkedInBlockFlag,
381 NeedsRangeCheckFlag,
382 InWorkListFlag,
383 DeoptimizeOnException,
384 InstructionLastFlag
385 };
386
387 public:
388 bool check_flag(InstructionFlag id) const { return (_flags & (1 << id)) != 0; }
389 void set_flag(InstructionFlag id, bool f) { _flags = f ? (_flags | (1 << id)) : (_flags & ~(1 << id)); };
390
391 // 'globally' used condition values
392 enum Condition {
393 eql, neq, lss, leq, gtr, geq, aeq, beq
394 };
395
396 // Instructions may be pinned for many reasons and under certain conditions
397 // with enough knowledge it's possible to safely unpin them.
398 enum PinReason {
399 PinUnknown = 1 << 0
400 , PinExplicitNullCheck = 1 << 3
401 , PinStackForStateSplit= 1 << 12
402 , PinStateSplitConstructor= 1 << 13
403 , PinGlobalValueNumbering= 1 << 14
404 };
405
406 static Condition mirror(Condition cond);
407 static Condition negate(Condition cond);
408
409 // initialization
410 static int number_of_instructions() {
411 return Compilation::current()->number_of_instructions();
412 }
413
414 // creation
415 Instruction(ValueType* type, ValueStack* state_before = NULL, bool type_is_constant = false)
416 :
417 #ifndef PRODUCT
418 _printable_bci(-99),
419 #endif
420 _use_count(0)
421 , _pin_state(0)
422 , _type(type)
423 , _next(NULL)
424 , _subst(NULL)
425 , _operand(LIR_OprFact::illegalOpr)
426 , _flags(0)
427 , _state_before(state_before)
428 , _exception_handlers(NULL)
429 , _block(NULL)
430 {
431 check_state(state_before);
432 assert(type != NULL && (!type->is_constant() || type_is_constant), "type must exist");
433 update_exception_state(_state_before);
434 }
435
436 // accessors
437 int id() const { return _id; }
438 #ifndef PRODUCT
439 bool has_printable_bci() const { return _printable_bci != -99; }
440 int printable_bci() const { assert(has_printable_bci(), "_printable_bci should have been set"); return _printable_bci; }
441 void set_printable_bci(int bci) { _printable_bci = bci; }
442 #endif
443 int dominator_depth();
444 int use_count() const { return _use_count; }
445 int pin_state() const { return _pin_state; }
446 bool is_pinned() const { return _pin_state != 0 || PinAllInstructions; }
447 ValueType* type() const { return _type; }
448 BlockBegin *block() const { return _block; }
449 Instruction* prev(); // use carefully, expensive operation
450 Instruction* next() const { return _next; }
451 bool has_subst() const { return _subst != NULL; }
452 Instruction* subst() { return _subst == NULL ? this : _subst->subst(); }
453 LIR_Opr operand() const { return _operand; }
454
455 void set_needs_null_check(bool f) { set_flag(NeedsNullCheckFlag, f); }
456 bool needs_null_check() const { return check_flag(NeedsNullCheckFlag); }
457 void set_never_null(bool f) { set_flag(NeverNullFlag, f); }
458 bool is_never_null() const { return check_flag(NeverNullFlag); }
459 bool is_linked() const { return check_flag(IsLinkedInBlockFlag); }
460 bool can_be_linked() { return as_Local() == NULL && as_Phi() == NULL; }
461
462 bool has_uses() const { return use_count() > 0; }
463 ValueStack* state_before() const { return _state_before; }
464 ValueStack* exception_state() const { return _exception_state; }
465 virtual bool needs_exception_state() const { return true; }
466 XHandlers* exception_handlers() const { return _exception_handlers; }
467 ciKlass* as_loaded_klass_or_null() const;
468
469 // manipulation
470 void pin(PinReason reason) { _pin_state |= reason; }
471 void pin() { _pin_state |= PinUnknown; }
472 // DANGEROUS: only used by EliminateStores
473 void unpin(PinReason reason) { assert((reason & PinUnknown) == 0, "can't unpin unknown state"); _pin_state &= ~reason; }
474
475 Instruction* set_next(Instruction* next) {
476 assert(next->has_printable_bci(), "_printable_bci should have been set");
477 assert(next != NULL, "must not be NULL");
478 assert(as_BlockEnd() == NULL, "BlockEnd instructions must have no next");
479 assert(next->can_be_linked(), "shouldn't link these instructions into list");
480
481 BlockBegin *block = this->block();
482 next->_block = block;
483
484 next->set_flag(Instruction::IsLinkedInBlockFlag, true);
485 _next = next;
486 return next;
487 }
488
489 Instruction* set_next(Instruction* next, int bci) {
490 #ifndef PRODUCT
491 next->set_printable_bci(bci);
492 #endif
493 return set_next(next);
494 }
495
496 // when blocks are merged
497 void fixup_block_pointers() {
498 Instruction *cur = next()->next(); // next()'s block is set in set_next
499 while (cur && cur->_block != block()) {
500 cur->_block = block();
501 cur = cur->next();
502 }
503 }
504
505 Instruction *insert_after(Instruction *i) {
506 Instruction* n = _next;
507 set_next(i);
508 i->set_next(n);
509 return _next;
510 }
511
512 bool is_flattened_array() const; // FIXME -- remove it
513
514 bool is_loaded_flattened_array() const;
515 bool maybe_flattened_array();
516
517 Instruction *insert_after_same_bci(Instruction *i) {
518 #ifndef PRODUCT
519 i->set_printable_bci(printable_bci());
520 #endif
521 return insert_after(i);
522 }
523
524 void set_subst(Instruction* subst) {
525 assert(subst == NULL ||
526 type()->base() == subst->type()->base() ||
527 subst->type()->base() == illegalType, "type can't change");
528 _subst = subst;
529 }
530 void set_exception_handlers(XHandlers *xhandlers) { _exception_handlers = xhandlers; }
531 void set_exception_state(ValueStack* s) { check_state(s); _exception_state = s; }
532 void set_state_before(ValueStack* s) { check_state(s); _state_before = s; }
533
534 // machine-specifics
535 void set_operand(LIR_Opr operand) { assert(operand != LIR_OprFact::illegalOpr, "operand must exist"); _operand = operand; }
536 void clear_operand() { _operand = LIR_OprFact::illegalOpr; }
537
538 // generic
539 virtual Instruction* as_Instruction() { return this; } // to satisfy HASHING1 macro
540 virtual Phi* as_Phi() { return NULL; }
541 virtual Local* as_Local() { return NULL; }
542 virtual Constant* as_Constant() { return NULL; }
543 virtual AccessField* as_AccessField() { return NULL; }
544 virtual LoadField* as_LoadField() { return NULL; }
545 virtual StoreField* as_StoreField() { return NULL; }
546 virtual AccessArray* as_AccessArray() { return NULL; }
547 virtual ArrayLength* as_ArrayLength() { return NULL; }
548 virtual AccessIndexed* as_AccessIndexed() { return NULL; }
549 virtual LoadIndexed* as_LoadIndexed() { return NULL; }
550 virtual StoreIndexed* as_StoreIndexed() { return NULL; }
551 virtual NegateOp* as_NegateOp() { return NULL; }
552 virtual Op2* as_Op2() { return NULL; }
553 virtual ArithmeticOp* as_ArithmeticOp() { return NULL; }
554 virtual ShiftOp* as_ShiftOp() { return NULL; }
555 virtual LogicOp* as_LogicOp() { return NULL; }
556 virtual CompareOp* as_CompareOp() { return NULL; }
557 virtual IfOp* as_IfOp() { return NULL; }
558 virtual Convert* as_Convert() { return NULL; }
559 virtual NullCheck* as_NullCheck() { return NULL; }
560 virtual OsrEntry* as_OsrEntry() { return NULL; }
561 virtual StateSplit* as_StateSplit() { return NULL; }
562 virtual Invoke* as_Invoke() { return NULL; }
563 virtual NewInstance* as_NewInstance() { return NULL; }
564 virtual NewValueTypeInstance* as_NewValueTypeInstance() { return NULL; }
565 virtual NewArray* as_NewArray() { return NULL; }
566 virtual NewTypeArray* as_NewTypeArray() { return NULL; }
567 virtual NewObjectArray* as_NewObjectArray() { return NULL; }
568 virtual NewMultiArray* as_NewMultiArray() { return NULL; }
569 virtual TypeCheck* as_TypeCheck() { return NULL; }
570 virtual CheckCast* as_CheckCast() { return NULL; }
571 virtual InstanceOf* as_InstanceOf() { return NULL; }
572 virtual TypeCast* as_TypeCast() { return NULL; }
573 virtual AccessMonitor* as_AccessMonitor() { return NULL; }
574 virtual MonitorEnter* as_MonitorEnter() { return NULL; }
575 virtual MonitorExit* as_MonitorExit() { return NULL; }
576 virtual Intrinsic* as_Intrinsic() { return NULL; }
577 virtual BlockBegin* as_BlockBegin() { return NULL; }
578 virtual BlockEnd* as_BlockEnd() { return NULL; }
579 virtual Goto* as_Goto() { return NULL; }
580 virtual If* as_If() { return NULL; }
581 virtual IfInstanceOf* as_IfInstanceOf() { return NULL; }
582 virtual TableSwitch* as_TableSwitch() { return NULL; }
583 virtual LookupSwitch* as_LookupSwitch() { return NULL; }
584 virtual Return* as_Return() { return NULL; }
585 virtual Throw* as_Throw() { return NULL; }
586 virtual Base* as_Base() { return NULL; }
587 virtual RoundFP* as_RoundFP() { return NULL; }
588 virtual ExceptionObject* as_ExceptionObject() { return NULL; }
589 virtual UnsafeOp* as_UnsafeOp() { return NULL; }
590 virtual ProfileInvoke* as_ProfileInvoke() { return NULL; }
591 virtual RangeCheckPredicate* as_RangeCheckPredicate() { return NULL; }
592
593 #ifdef ASSERT
594 virtual Assert* as_Assert() { return NULL; }
595 #endif
596
597 virtual void visit(InstructionVisitor* v) = 0;
598
599 virtual bool can_trap() const { return false; }
600
601 virtual void input_values_do(ValueVisitor* f) = 0;
602 virtual void state_values_do(ValueVisitor* f);
603 virtual void other_values_do(ValueVisitor* f) { /* usually no other - override on demand */ }
604 void values_do(ValueVisitor* f) { input_values_do(f); state_values_do(f); other_values_do(f); }
605
606 virtual ciType* exact_type() const;
607 virtual ciType* declared_type() const { return NULL; }
608
609 // hashing
610 virtual const char* name() const = 0;
611 HASHING1(Instruction, false, id()) // hashing disabled by default
612
613 // debugging
614 static void check_state(ValueStack* state) PRODUCT_RETURN;
615 void print() PRODUCT_RETURN;
616 void print_line() PRODUCT_RETURN;
617 void print(InstructionPrinter& ip) PRODUCT_RETURN;
618 };
619
620
621 // The following macros are used to define base (i.e., non-leaf)
622 // and leaf instruction classes. They define class-name related
623 // generic functionality in one place.
624
625 #define BASE(class_name, super_class_name) \
626 class class_name: public super_class_name { \
627 public: \
628 virtual class_name* as_##class_name() { return this; } \
629
630
631 #define LEAF(class_name, super_class_name) \
632 BASE(class_name, super_class_name) \
633 public: \
634 virtual const char* name() const { return #class_name; } \
635 virtual void visit(InstructionVisitor* v) { v->do_##class_name(this); } \
636
637
638 // Debugging support
639
640
641 #ifdef ASSERT
642 class AssertValues: public ValueVisitor {
643 void visit(Value* x) { assert((*x) != NULL, "value must exist"); }
644 };
645 #define ASSERT_VALUES { AssertValues assert_value; values_do(&assert_value); }
646 #else
647 #define ASSERT_VALUES
648 #endif // ASSERT
649
650
651 // A Phi is a phi function in the sense of SSA form. It stands for
652 // the value of a local variable at the beginning of a join block.
653 // A Phi consists of n operands, one for every incoming branch.
654
655 LEAF(Phi, Instruction)
656 private:
657 int _pf_flags; // the flags of the phi function
658 int _index; // to value on operand stack (index < 0) or to local
659 ciType* _exact_type; // currently is set only for flattened arrays, NULL otherwise.
660 public:
661 // creation
662 Phi(ValueType* type, BlockBegin* b, int index, ciType* exact_type)
663 : Instruction(type->base())
664 , _pf_flags(0)
665 , _index(index)
666 , _exact_type(exact_type)
667 {
668 _block = b;
669 NOT_PRODUCT(set_printable_bci(Value(b)->printable_bci()));
670 if (type->is_illegal()) {
671 make_illegal();
672 }
673 }
674
675 virtual ciType* exact_type() const {
676 return _exact_type;
677 }
678
679 virtual ciType* declared_type() const {
680 return _exact_type;
681 }
682
683 // flags
684 enum Flag {
685 no_flag = 0,
686 visited = 1 << 0,
687 cannot_simplify = 1 << 1
688 };
689
690 // accessors
691 bool is_local() const { return _index >= 0; }
692 bool is_on_stack() const { return !is_local(); }
693 int local_index() const { assert(is_local(), ""); return _index; }
694 int stack_index() const { assert(is_on_stack(), ""); return -(_index+1); }
695
696 Value operand_at(int i) const;
697 int operand_count() const;
698
699 void set(Flag f) { _pf_flags |= f; }
700 void clear(Flag f) { _pf_flags &= ~f; }
701 bool is_set(Flag f) const { return (_pf_flags & f) != 0; }
702
703 // Invalidates phis corresponding to merges of locals of two different types
704 // (these should never be referenced, otherwise the bytecodes are illegal)
705 void make_illegal() {
706 set(cannot_simplify);
707 set_type(illegalType);
708 }
709
710 bool is_illegal() const {
711 return type()->is_illegal();
712 }
713
714 // generic
715 virtual void input_values_do(ValueVisitor* f) {
716 }
717 };
718
719
720 // A local is a placeholder for an incoming argument to a function call.
721 LEAF(Local, Instruction)
722 private:
723 int _java_index; // the local index within the method to which the local belongs
724 bool _is_receiver; // if local variable holds the receiver: "this" for non-static methods
725 ciType* _declared_type;
726 public:
727 // creation
728 Local(ciType* declared, ValueType* type, int index, bool receiver, bool never_null)
729 : Instruction(type)
730 , _java_index(index)
731 , _is_receiver(receiver)
732 , _declared_type(declared)
733 {
734 set_never_null(never_null);
735 NOT_PRODUCT(set_printable_bci(-1));
736 }
737
738 // accessors
739 int java_index() const { return _java_index; }
740 bool is_receiver() const { return _is_receiver; }
741
742 virtual ciType* declared_type() const { return _declared_type; }
743
744 // generic
745 virtual void input_values_do(ValueVisitor* f) { /* no values */ }
746 };
747
748
749 LEAF(Constant, Instruction)
750 public:
751 // creation
752 Constant(ValueType* type):
753 Instruction(type, NULL, /*type_is_constant*/ true)
754 {
755 assert(type->is_constant(), "must be a constant");
756 }
757
758 Constant(ValueType* type, ValueStack* state_before):
759 Instruction(type, state_before, /*type_is_constant*/ true)
760 {
761 assert(state_before != NULL, "only used for constants which need patching");
762 assert(type->is_constant(), "must be a constant");
763 // since it's patching it needs to be pinned
764 pin();
765 }
766
767 // generic
768 virtual bool can_trap() const { return state_before() != NULL; }
769 virtual void input_values_do(ValueVisitor* f) { /* no values */ }
770
771 virtual intx hash() const;
772 virtual bool is_equal(Value v) const;
773
774 virtual ciType* exact_type() const;
775
776 enum CompareResult { not_comparable = -1, cond_false, cond_true };
777
778 virtual CompareResult compare(Instruction::Condition condition, Value right) const;
779 BlockBegin* compare(Instruction::Condition cond, Value right,
780 BlockBegin* true_sux, BlockBegin* false_sux) const {
781 switch (compare(cond, right)) {
782 case not_comparable:
783 return NULL;
784 case cond_false:
785 return false_sux;
786 case cond_true:
787 return true_sux;
788 default:
789 ShouldNotReachHere();
790 return NULL;
791 }
792 }
793 };
794
795
796 BASE(AccessField, Instruction)
797 private:
798 Value _obj;
799 int _offset;
800 ciField* _field;
801 NullCheck* _explicit_null_check; // For explicit null check elimination
802
803 public:
804 // creation
805 AccessField(Value obj, int offset, ciField* field, bool is_static,
806 ValueStack* state_before, bool needs_patching)
807 : Instruction(as_ValueType(field->type()->basic_type()), state_before)
808 , _obj(obj)
809 , _offset(offset)
810 , _field(field)
811 , _explicit_null_check(NULL)
812 {
813 set_needs_null_check(!is_static);
814 set_flag(IsStaticFlag, is_static);
815 set_flag(NeedsPatchingFlag, needs_patching);
816 ASSERT_VALUES
817 // pin of all instructions with memory access
818 pin();
819 }
820
821 // accessors
822 Value obj() const { return _obj; }
823 int offset() const { return _offset; }
824 ciField* field() const { return _field; }
825 BasicType field_type() const { return _field->type()->basic_type(); }
826 bool is_static() const { return check_flag(IsStaticFlag); }
827 NullCheck* explicit_null_check() const { return _explicit_null_check; }
828 bool needs_patching() const { return check_flag(NeedsPatchingFlag); }
829
830 // Unresolved getstatic and putstatic can cause initialization.
831 // Technically it occurs at the Constant that materializes the base
832 // of the static fields but it's simpler to model it here.
833 bool is_init_point() const { return is_static() && (needs_patching() || !_field->holder()->is_initialized()); }
834
835 // manipulation
836
837 // Under certain circumstances, if a previous NullCheck instruction
838 // proved the target object non-null, we can eliminate the explicit
839 // null check and do an implicit one, simply specifying the debug
840 // information from the NullCheck. This field should only be consulted
841 // if needs_null_check() is true.
842 void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
843
844 // generic
845 virtual bool can_trap() const { return needs_null_check() || needs_patching(); }
846 virtual void input_values_do(ValueVisitor* f) { f->visit(&_obj); }
847 };
848
849
850 LEAF(LoadField, AccessField)
851 public:
852 // creation
853 LoadField(Value obj, int offset, ciField* field, bool is_static,
854 ValueStack* state_before, bool needs_patching,
855 ciValueKlass* value_klass = NULL, Value default_value = NULL )
856 : AccessField(obj, offset, field, is_static, state_before, needs_patching)
857 {}
858
859 ciType* declared_type() const;
860
861 // generic
862 HASHING2(LoadField, !needs_patching() && !field()->is_volatile(), obj()->subst(), offset()) // cannot be eliminated if needs patching or if volatile
863 };
864
865
866 LEAF(StoreField, AccessField)
867 private:
868 Value _value;
869
870 public:
871 // creation
872 StoreField(Value obj, int offset, ciField* field, Value value, bool is_static,
873 ValueStack* state_before, bool needs_patching)
874 : AccessField(obj, offset, field, is_static, state_before, needs_patching)
875 , _value(value)
876 {
877 set_flag(NeedsWriteBarrierFlag, as_ValueType(field_type())->is_object());
878 ASSERT_VALUES
879 pin();
880 }
881
882 // accessors
883 Value value() const { return _value; }
884 bool needs_write_barrier() const { return check_flag(NeedsWriteBarrierFlag); }
885
886 // generic
887 virtual void input_values_do(ValueVisitor* f) { AccessField::input_values_do(f); f->visit(&_value); }
888 };
889
890
891 BASE(AccessArray, Instruction)
892 private:
893 Value _array;
894
895 public:
896 // creation
897 AccessArray(ValueType* type, Value array, ValueStack* state_before)
898 : Instruction(type, state_before)
899 , _array(array)
900 {
901 set_needs_null_check(true);
902 ASSERT_VALUES
903 pin(); // instruction with side effect (null exception or range check throwing)
904 }
905
906 Value array() const { return _array; }
907
908 // generic
909 virtual bool can_trap() const { return needs_null_check(); }
910 virtual void input_values_do(ValueVisitor* f) { f->visit(&_array); }
911 };
912
913
914 LEAF(ArrayLength, AccessArray)
915 private:
916 NullCheck* _explicit_null_check; // For explicit null check elimination
917
918 public:
919 // creation
920 ArrayLength(Value array, ValueStack* state_before)
921 : AccessArray(intType, array, state_before)
922 , _explicit_null_check(NULL) {}
923
924 // accessors
925 NullCheck* explicit_null_check() const { return _explicit_null_check; }
926
927 // setters
928 // See LoadField::set_explicit_null_check for documentation
929 void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
930
931 // generic
932 HASHING1(ArrayLength, true, array()->subst())
933 };
934
935
936 BASE(AccessIndexed, AccessArray)
937 private:
938 Value _index;
939 Value _length;
940 BasicType _elt_type;
941 bool _mismatched;
942
943 public:
944 // creation
945 AccessIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* state_before, bool mismatched)
946 : AccessArray(as_ValueType(elt_type), array, state_before)
947 , _index(index)
948 , _length(length)
949 , _elt_type(elt_type)
950 , _mismatched(mismatched)
951 {
952 set_flag(Instruction::NeedsRangeCheckFlag, true);
953 ASSERT_VALUES
954 }
955
956 // accessors
957 Value index() const { return _index; }
958 Value length() const { return _length; }
959 BasicType elt_type() const { return _elt_type; }
960 bool mismatched() const { return _mismatched; }
961
962 void clear_length() { _length = NULL; }
963 // perform elimination of range checks involving constants
964 bool compute_needs_range_check();
965
966 // generic
967 virtual void input_values_do(ValueVisitor* f) { AccessArray::input_values_do(f); f->visit(&_index); if (_length != NULL) f->visit(&_length); }
968 };
969
970
971 LEAF(LoadIndexed, AccessIndexed)
972 private:
973 NullCheck* _explicit_null_check; // For explicit null check elimination
974 NewValueTypeInstance* _vt;
975
976 public:
977 // creation
978 LoadIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* state_before, bool mismatched = false)
979 : AccessIndexed(array, index, length, elt_type, state_before, mismatched)
980 , _explicit_null_check(NULL) {}
981
982 // accessors
983 NullCheck* explicit_null_check() const { return _explicit_null_check; }
984
985 // setters
986 // See LoadField::set_explicit_null_check for documentation
987 void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
988
989 ciType* exact_type() const;
990 ciType* declared_type() const;
991
992 NewValueTypeInstance* vt() { return _vt; }
993 void set_vt(NewValueTypeInstance* vt) { _vt = vt; }
994
995 // generic
996 HASHING2(LoadIndexed, true, array()->subst(), index()->subst())
997 };
998
999
1000 LEAF(StoreIndexed, AccessIndexed)
1001 private:
1002 Value _value;
1003
1004 ciMethod* _profiled_method;
1005 int _profiled_bci;
1006 bool _check_boolean;
1007
1008 public:
1009 // creation
1010 StoreIndexed(Value array, Value index, Value length, BasicType elt_type, Value value, ValueStack* state_before,
1011 bool check_boolean, bool mismatched = false)
1012 : AccessIndexed(array, index, length, elt_type, state_before, mismatched)
1013 , _value(value), _profiled_method(NULL), _profiled_bci(0), _check_boolean(check_boolean)
1014 {
1015 set_flag(NeedsWriteBarrierFlag, (as_ValueType(elt_type)->is_object()));
1016 set_flag(NeedsStoreCheckFlag, (as_ValueType(elt_type)->is_object()));
1017 ASSERT_VALUES
1018 pin();
1019 }
1020
1021 // accessors
1022 Value value() const { return _value; }
1023 bool needs_write_barrier() const { return check_flag(NeedsWriteBarrierFlag); }
1024 bool needs_store_check() const { return check_flag(NeedsStoreCheckFlag); }
1025 bool check_boolean() const { return _check_boolean; }
1026 // Helpers for MethodData* profiling
1027 void set_should_profile(bool value) { set_flag(ProfileMDOFlag, value); }
1028 void set_profiled_method(ciMethod* method) { _profiled_method = method; }
1029 void set_profiled_bci(int bci) { _profiled_bci = bci; }
1030 bool should_profile() const { return check_flag(ProfileMDOFlag); }
1031 ciMethod* profiled_method() const { return _profiled_method; }
1032 int profiled_bci() const { return _profiled_bci; }
1033 // Flattened array support
1034 bool is_exact_flattened_array_store() const;
1035 // generic
1036 virtual void input_values_do(ValueVisitor* f) { AccessIndexed::input_values_do(f); f->visit(&_value); }
1037 };
1038
1039
1040 LEAF(NegateOp, Instruction)
1041 private:
1042 Value _x;
1043
1044 public:
1045 // creation
1046 NegateOp(Value x) : Instruction(x->type()->base()), _x(x) {
1047 ASSERT_VALUES
1048 }
1049
1050 // accessors
1051 Value x() const { return _x; }
1052
1053 // generic
1054 virtual void input_values_do(ValueVisitor* f) { f->visit(&_x); }
1055 };
1056
1057
1058 BASE(Op2, Instruction)
1059 private:
1060 Bytecodes::Code _op;
1061 Value _x;
1062 Value _y;
1063
1064 public:
1065 // creation
1066 Op2(ValueType* type, Bytecodes::Code op, Value x, Value y, ValueStack* state_before = NULL)
1067 : Instruction(type, state_before)
1068 , _op(op)
1069 , _x(x)
1070 , _y(y)
1071 {
1072 ASSERT_VALUES
1073 }
1074
1075 // accessors
1076 Bytecodes::Code op() const { return _op; }
1077 Value x() const { return _x; }
1078 Value y() const { return _y; }
1079
1080 // manipulators
1081 void swap_operands() {
1082 assert(is_commutative(), "operation must be commutative");
1083 Value t = _x; _x = _y; _y = t;
1084 }
1085
1086 // generic
1087 virtual bool is_commutative() const { return false; }
1088 virtual void input_values_do(ValueVisitor* f) { f->visit(&_x); f->visit(&_y); }
1089 };
1090
1091
1092 LEAF(ArithmeticOp, Op2)
1093 public:
1094 // creation
1095 ArithmeticOp(Bytecodes::Code op, Value x, Value y, bool is_strictfp, ValueStack* state_before)
1096 : Op2(x->type()->meet(y->type()), op, x, y, state_before)
1097 {
1098 set_flag(IsStrictfpFlag, is_strictfp);
1099 if (can_trap()) pin();
1100 }
1101
1102 // accessors
1103 bool is_strictfp() const { return check_flag(IsStrictfpFlag); }
1104
1105 // generic
1106 virtual bool is_commutative() const;
1107 virtual bool can_trap() const;
1108 HASHING3(Op2, true, op(), x()->subst(), y()->subst())
1109 };
1110
1111
1112 LEAF(ShiftOp, Op2)
1113 public:
1114 // creation
1115 ShiftOp(Bytecodes::Code op, Value x, Value s) : Op2(x->type()->base(), op, x, s) {}
1116
1117 // generic
1118 HASHING3(Op2, true, op(), x()->subst(), y()->subst())
1119 };
1120
1121
1122 LEAF(LogicOp, Op2)
1123 public:
1124 // creation
1125 LogicOp(Bytecodes::Code op, Value x, Value y) : Op2(x->type()->meet(y->type()), op, x, y) {}
1126
1127 // generic
1128 virtual bool is_commutative() const;
1129 HASHING3(Op2, true, op(), x()->subst(), y()->subst())
1130 };
1131
1132
1133 LEAF(CompareOp, Op2)
1134 public:
1135 // creation
1136 CompareOp(Bytecodes::Code op, Value x, Value y, ValueStack* state_before)
1137 : Op2(intType, op, x, y, state_before)
1138 {}
1139
1140 // generic
1141 HASHING3(Op2, true, op(), x()->subst(), y()->subst())
1142 };
1143
1144
1145 LEAF(IfOp, Op2)
1146 private:
1147 Value _tval;
1148 Value _fval;
1149 bool _substituability_check;
1150
1151 public:
1152 // creation
1153 IfOp(Value x, Condition cond, Value y, Value tval, Value fval, ValueStack* state_before, bool substituability_check)
1154 : Op2(tval->type()->meet(fval->type()), (Bytecodes::Code)cond, x, y)
1155 , _tval(tval)
1156 , _fval(fval)
1157 , _substituability_check(substituability_check)
1158 {
1159 ASSERT_VALUES
1160 assert(tval->type()->tag() == fval->type()->tag(), "types must match");
1161 set_state_before(state_before);
1162 }
1163
1164 // accessors
1165 virtual bool is_commutative() const;
1166 Bytecodes::Code op() const { ShouldNotCallThis(); return Bytecodes::_illegal; }
1167 Condition cond() const { return (Condition)Op2::op(); }
1168 Value tval() const { return _tval; }
1169 Value fval() const { return _fval; }
1170 bool substituability_check() const { return _substituability_check; }
1171 // generic
1172 virtual void input_values_do(ValueVisitor* f) { Op2::input_values_do(f); f->visit(&_tval); f->visit(&_fval); }
1173 };
1174
1175
1176 LEAF(Convert, Instruction)
1177 private:
1178 Bytecodes::Code _op;
1179 Value _value;
1180
1181 public:
1182 // creation
1183 Convert(Bytecodes::Code op, Value value, ValueType* to_type) : Instruction(to_type), _op(op), _value(value) {
1184 ASSERT_VALUES
1185 }
1186
1187 // accessors
1188 Bytecodes::Code op() const { return _op; }
1189 Value value() const { return _value; }
1190
1191 // generic
1192 virtual void input_values_do(ValueVisitor* f) { f->visit(&_value); }
1193 HASHING2(Convert, true, op(), value()->subst())
1194 };
1195
1196
1197 LEAF(NullCheck, Instruction)
1198 private:
1199 Value _obj;
1200
1201 public:
1202 // creation
1203 NullCheck(Value obj, ValueStack* state_before)
1204 : Instruction(obj->type()->base(), state_before)
1205 , _obj(obj)
1206 {
1207 ASSERT_VALUES
1208 set_can_trap(true);
1209 assert(_obj->type()->is_object(), "null check must be applied to objects only");
1210 pin(Instruction::PinExplicitNullCheck);
1211 }
1212
1213 // accessors
1214 Value obj() const { return _obj; }
1215
1216 // setters
1217 void set_can_trap(bool can_trap) { set_flag(CanTrapFlag, can_trap); }
1218
1219 // generic
1220 virtual bool can_trap() const { return check_flag(CanTrapFlag); /* null-check elimination sets to false */ }
1221 virtual void input_values_do(ValueVisitor* f) { f->visit(&_obj); }
1222 HASHING1(NullCheck, true, obj()->subst())
1223 };
1224
1225
1226 // This node is supposed to cast the type of another node to a more precise
1227 // declared type.
1228 LEAF(TypeCast, Instruction)
1229 private:
1230 ciType* _declared_type;
1231 Value _obj;
1232
1233 public:
1234 // The type of this node is the same type as the object type (and it might be constant).
1235 TypeCast(ciType* type, Value obj, ValueStack* state_before)
1236 : Instruction(obj->type(), state_before, obj->type()->is_constant()),
1237 _declared_type(type),
1238 _obj(obj) {}
1239
1240 // accessors
1241 ciType* declared_type() const { return _declared_type; }
1242 Value obj() const { return _obj; }
1243
1244 // generic
1245 virtual void input_values_do(ValueVisitor* f) { f->visit(&_obj); }
1246 };
1247
1248
1249 BASE(StateSplit, Instruction)
1250 private:
1251 ValueStack* _state;
1252
1253 protected:
1254 static void substitute(BlockList& list, BlockBegin* old_block, BlockBegin* new_block);
1255
1256 public:
1257 // creation
1258 StateSplit(ValueType* type, ValueStack* state_before = NULL)
1259 : Instruction(type, state_before)
1260 , _state(NULL)
1261 {
1262 pin(PinStateSplitConstructor);
1263 }
1264
1265 // accessors
1266 ValueStack* state() const { return _state; }
1267 IRScope* scope() const; // the state's scope
1268
1269 // manipulation
1270 void set_state(ValueStack* state) { assert(_state == NULL, "overwriting existing state"); check_state(state); _state = state; }
1271
1272 // generic
1273 virtual void input_values_do(ValueVisitor* f) { /* no values */ }
1274 virtual void state_values_do(ValueVisitor* f);
1275 };
1276
1277
1278 LEAF(Invoke, StateSplit)
1279 private:
1280 Bytecodes::Code _code;
1281 Value _recv;
1282 Values* _args;
1283 BasicTypeList* _signature;
1284 int _vtable_index;
1285 ciMethod* _target;
1286
1287 public:
1288 // creation
1289 Invoke(Bytecodes::Code code, ValueType* result_type, Value recv, Values* args,
1290 int vtable_index, ciMethod* target, ValueStack* state_before, bool never_null);
1291
1292 // accessors
1293 Bytecodes::Code code() const { return _code; }
1294 Value receiver() const { return _recv; }
1295 bool has_receiver() const { return receiver() != NULL; }
1296 int number_of_arguments() const { return _args->length(); }
1297 Value argument_at(int i) const { return _args->at(i); }
1298 int vtable_index() const { return _vtable_index; }
1299 BasicTypeList* signature() const { return _signature; }
1300 ciMethod* target() const { return _target; }
1301
1302 ciType* declared_type() const;
1303
1304 // Returns false if target is not loaded
1305 bool target_is_final() const { return check_flag(TargetIsFinalFlag); }
1306 bool target_is_loaded() const { return check_flag(TargetIsLoadedFlag); }
1307 // Returns false if target is not loaded
1308 bool target_is_strictfp() const { return check_flag(TargetIsStrictfpFlag); }
1309
1310 // JSR 292 support
1311 bool is_invokedynamic() const { return code() == Bytecodes::_invokedynamic; }
1312 bool is_method_handle_intrinsic() const { return target()->is_method_handle_intrinsic(); }
1313
1314 virtual bool needs_exception_state() const { return false; }
1315
1316 // generic
1317 virtual bool can_trap() const { return true; }
1318 virtual void input_values_do(ValueVisitor* f) {
1319 StateSplit::input_values_do(f);
1320 if (has_receiver()) f->visit(&_recv);
1321 for (int i = 0; i < _args->length(); i++) f->visit(_args->adr_at(i));
1322 }
1323 virtual void state_values_do(ValueVisitor *f);
1324 };
1325
1326
1327 LEAF(NewInstance, StateSplit)
1328 private:
1329 ciInstanceKlass* _klass;
1330 bool _is_unresolved;
1331
1332 public:
1333 // creation
1334 NewInstance(ciInstanceKlass* klass, ValueStack* state_before, bool is_unresolved)
1335 : StateSplit(instanceType, state_before)
1336 , _klass(klass), _is_unresolved(is_unresolved)
1337 {}
1338
1339 // accessors
1340 ciInstanceKlass* klass() const { return _klass; }
1341 bool is_unresolved() const { return _is_unresolved; }
1342
1343 virtual bool needs_exception_state() const { return false; }
1344
1345 // generic
1346 virtual bool can_trap() const { return true; }
1347 ciType* exact_type() const;
1348 ciType* declared_type() const;
1349 };
1350
1351 LEAF(NewValueTypeInstance, StateSplit)
1352 bool _is_unresolved;
1353 ciValueKlass* _klass;
1354 Value _depends_on; // Link to instance on with withfield was called on
1355
1356 public:
1357
1358 // Default creation, always allocated for now
1359 NewValueTypeInstance(ciValueKlass* klass, ValueStack* state_before, bool is_unresolved, Value depends_on = NULL)
1360 : StateSplit(instanceType, state_before)
1361 , _is_unresolved(is_unresolved)
1362 , _klass(klass)
1363 {
1364 if (depends_on == NULL) {
1365 _depends_on = this;
1366 } else {
1367 _depends_on = depends_on;
1368 }
1369 set_never_null(true);
1370 }
1371
1372 // accessors
1373 bool is_unresolved() const { return _is_unresolved; }
1374 Value depends_on();
1375
1376 ciValueKlass* klass() const { return _klass; }
1377
1378 virtual bool needs_exception_state() const { return false; }
1379
1380 // generic
1381 virtual bool can_trap() const { return true; }
1382 ciType* exact_type() const;
1383 ciType* declared_type() const;
1384
1385 // Only done in LIR Generator -> map everything to object
1386 void set_to_object_type() { set_type(instanceType); }
1387 };
1388
1389 BASE(NewArray, StateSplit)
1390 private:
1391 Value _length;
1392
1393 public:
1394 // creation
1395 NewArray(Value length, ValueStack* state_before)
1396 : StateSplit(objectType, state_before)
1397 , _length(length)
1398 {
1399 // Do not ASSERT_VALUES since length is NULL for NewMultiArray
1400 }
1401
1402 // accessors
1403 Value length() const { return _length; }
1404
1405 virtual bool needs_exception_state() const { return false; }
1406
1407 ciType* exact_type() const { return NULL; }
1408 ciType* declared_type() const;
1409
1410 // generic
1411 virtual bool can_trap() const { return true; }
1412 virtual void input_values_do(ValueVisitor* f) { StateSplit::input_values_do(f); f->visit(&_length); }
1413 };
1414
1415
1416 LEAF(NewTypeArray, NewArray)
1417 private:
1418 BasicType _elt_type;
1419
1420 public:
1421 // creation
1422 NewTypeArray(Value length, BasicType elt_type, ValueStack* state_before)
1423 : NewArray(length, state_before)
1424 , _elt_type(elt_type)
1425 {}
1426
1427 // accessors
1428 BasicType elt_type() const { return _elt_type; }
1429 ciType* exact_type() const;
1430 };
1431
1432
1433 LEAF(NewObjectArray, NewArray)
1434 private:
1435 ciKlass* _klass;
1436
1437 public:
1438 // creation
1439 NewObjectArray(ciKlass* klass, Value length, ValueStack* state_before) : NewArray(length, state_before), _klass(klass) {}
1440
1441 // accessors
1442 ciKlass* klass() const { return _klass; }
1443 ciType* exact_type() const;
1444 };
1445
1446
1447 LEAF(NewMultiArray, NewArray)
1448 private:
1449 ciKlass* _klass;
1450 Values* _dims;
1451
1452 public:
1453 // creation
1454 NewMultiArray(ciKlass* klass, Values* dims, ValueStack* state_before) : NewArray(NULL, state_before), _klass(klass), _dims(dims) {
1455 ASSERT_VALUES
1456 }
1457
1458 // accessors
1459 ciKlass* klass() const { return _klass; }
1460 Values* dims() const { return _dims; }
1461 int rank() const { return dims()->length(); }
1462
1463 // generic
1464 virtual void input_values_do(ValueVisitor* f) {
1465 // NOTE: we do not call NewArray::input_values_do since "length"
1466 // is meaningless for a multi-dimensional array; passing the
1467 // zeroth element down to NewArray as its length is a bad idea
1468 // since there will be a copy in the "dims" array which doesn't
1469 // get updated, and the value must not be traversed twice. Was bug
1470 // - kbr 4/10/2001
1471 StateSplit::input_values_do(f);
1472 for (int i = 0; i < _dims->length(); i++) f->visit(_dims->adr_at(i));
1473 }
1474
1475 ciType* exact_type() const;
1476 };
1477
1478
1479 BASE(TypeCheck, StateSplit)
1480 private:
1481 ciKlass* _klass;
1482 Value _obj;
1483
1484 ciMethod* _profiled_method;
1485 int _profiled_bci;
1486
1487 public:
1488 // creation
1489 TypeCheck(ciKlass* klass, Value obj, ValueType* type, ValueStack* state_before)
1490 : StateSplit(type, state_before), _klass(klass), _obj(obj),
1491 _profiled_method(NULL), _profiled_bci(0) {
1492 ASSERT_VALUES
1493 set_direct_compare(false);
1494 }
1495
1496 // accessors
1497 ciKlass* klass() const { return _klass; }
1498 Value obj() const { return _obj; }
1499 bool is_loaded() const { return klass() != NULL; }
1500 bool direct_compare() const { return check_flag(DirectCompareFlag); }
1501
1502 // manipulation
1503 void set_direct_compare(bool flag) { set_flag(DirectCompareFlag, flag); }
1504
1505 // generic
1506 virtual bool can_trap() const { return true; }
1507 virtual void input_values_do(ValueVisitor* f) { StateSplit::input_values_do(f); f->visit(&_obj); }
1508
1509 // Helpers for MethodData* profiling
1510 void set_should_profile(bool value) { set_flag(ProfileMDOFlag, value); }
1511 void set_profiled_method(ciMethod* method) { _profiled_method = method; }
1512 void set_profiled_bci(int bci) { _profiled_bci = bci; }
1513 bool should_profile() const { return check_flag(ProfileMDOFlag); }
1514 ciMethod* profiled_method() const { return _profiled_method; }
1515 int profiled_bci() const { return _profiled_bci; }
1516 };
1517
1518
1519 LEAF(CheckCast, TypeCheck)
1520 public:
1521 // creation
1522 CheckCast(ciKlass* klass, Value obj, ValueStack* state_before, bool never_null = false)
1523 : TypeCheck(klass, obj, objectType, state_before) {
1524 set_never_null(never_null);
1525 }
1526
1527 void set_incompatible_class_change_check() {
1528 set_flag(ThrowIncompatibleClassChangeErrorFlag, true);
1529 }
1530 bool is_incompatible_class_change_check() const {
1531 return check_flag(ThrowIncompatibleClassChangeErrorFlag);
1532 }
1533 void set_invokespecial_receiver_check() {
1534 set_flag(InvokeSpecialReceiverCheckFlag, true);
1535 }
1536 bool is_invokespecial_receiver_check() const {
1537 return check_flag(InvokeSpecialReceiverCheckFlag);
1538 }
1539
1540 virtual bool needs_exception_state() const {
1541 return !is_invokespecial_receiver_check();
1542 }
1543
1544 ciType* declared_type() const;
1545 };
1546
1547
1548 LEAF(InstanceOf, TypeCheck)
1549 public:
1550 // creation
1551 InstanceOf(ciKlass* klass, Value obj, ValueStack* state_before) : TypeCheck(klass, obj, intType, state_before) {}
1552
1553 virtual bool needs_exception_state() const { return false; }
1554 };
1555
1556
1557 BASE(AccessMonitor, StateSplit)
1558 private:
1559 Value _obj;
1560 int _monitor_no;
1561
1562 public:
1563 // creation
1564 AccessMonitor(Value obj, int monitor_no, ValueStack* state_before = NULL)
1565 : StateSplit(illegalType, state_before)
1566 , _obj(obj)
1567 , _monitor_no(monitor_no)
1568 {
1569 set_needs_null_check(true);
1570 ASSERT_VALUES
1571 }
1572
1573 // accessors
1574 Value obj() const { return _obj; }
1575 int monitor_no() const { return _monitor_no; }
1576
1577 // generic
1578 virtual void input_values_do(ValueVisitor* f) { StateSplit::input_values_do(f); f->visit(&_obj); }
1579 };
1580
1581
1582 LEAF(MonitorEnter, AccessMonitor)
1583 bool _maybe_valuetype;
1584 public:
1585 // creation
1586 MonitorEnter(Value obj, int monitor_no, ValueStack* state_before, bool maybe_valuetype)
1587 : AccessMonitor(obj, monitor_no, state_before)
1588 , _maybe_valuetype(maybe_valuetype)
1589 {
1590 ASSERT_VALUES
1591 }
1592
1593 // accessors
1594 bool maybe_valuetype() const { return _maybe_valuetype; }
1595
1596 // generic
1597 virtual bool can_trap() const { return true; }
1598 };
1599
1600
1601 LEAF(MonitorExit, AccessMonitor)
1602 public:
1603 // creation
1604 MonitorExit(Value obj, int monitor_no)
1605 : AccessMonitor(obj, monitor_no, NULL)
1606 {
1607 ASSERT_VALUES
1608 }
1609 };
1610
1611
1612 LEAF(Intrinsic, StateSplit)
1613 private:
1614 vmIntrinsics::ID _id;
1615 Values* _args;
1616 Value _recv;
1617 ArgsNonNullState _nonnull_state;
1618
1619 public:
1620 // preserves_state can be set to true for Intrinsics
1621 // which are guaranteed to preserve register state across any slow
1622 // cases; setting it to true does not mean that the Intrinsic can
1623 // not trap, only that if we continue execution in the same basic
1624 // block after the Intrinsic, all of the registers are intact. This
1625 // allows load elimination and common expression elimination to be
1626 // performed across the Intrinsic. The default value is false.
1627 Intrinsic(ValueType* type,
1628 vmIntrinsics::ID id,
1629 Values* args,
1630 bool has_receiver,
1631 ValueStack* state_before,
1632 bool preserves_state,
1633 bool cantrap = true)
1634 : StateSplit(type, state_before)
1635 , _id(id)
1636 , _args(args)
1637 , _recv(NULL)
1638 {
1639 assert(args != NULL, "args must exist");
1640 ASSERT_VALUES
1641 set_flag(PreservesStateFlag, preserves_state);
1642 set_flag(CanTrapFlag, cantrap);
1643 if (has_receiver) {
1644 _recv = argument_at(0);
1645 }
1646 set_needs_null_check(has_receiver);
1647
1648 // some intrinsics can't trap, so don't force them to be pinned
1649 if (!can_trap() && !vmIntrinsics::should_be_pinned(_id)) {
1650 unpin(PinStateSplitConstructor);
1651 }
1652 }
1653
1654 // accessors
1655 vmIntrinsics::ID id() const { return _id; }
1656 int number_of_arguments() const { return _args->length(); }
1657 Value argument_at(int i) const { return _args->at(i); }
1658
1659 bool has_receiver() const { return (_recv != NULL); }
1660 Value receiver() const { assert(has_receiver(), "must have receiver"); return _recv; }
1661 bool preserves_state() const { return check_flag(PreservesStateFlag); }
1662
1663 bool arg_needs_null_check(int i) const {
1664 return _nonnull_state.arg_needs_null_check(i);
1665 }
1666
1667 void set_arg_needs_null_check(int i, bool check) {
1668 _nonnull_state.set_arg_needs_null_check(i, check);
1669 }
1670
1671 // generic
1672 virtual bool can_trap() const { return check_flag(CanTrapFlag); }
1673 virtual void input_values_do(ValueVisitor* f) {
1674 StateSplit::input_values_do(f);
1675 for (int i = 0; i < _args->length(); i++) f->visit(_args->adr_at(i));
1676 }
1677 };
1678
1679
1680 class LIR_List;
1681
1682 LEAF(BlockBegin, StateSplit)
1683 private:
1684 int _block_id; // the unique block id
1685 int _bci; // start-bci of block
1686 int _depth_first_number; // number of this block in a depth-first ordering
1687 int _linear_scan_number; // number of this block in linear-scan ordering
1688 int _dominator_depth;
1689 int _loop_depth; // the loop nesting level of this block
1690 int _loop_index; // number of the innermost loop of this block
1691 int _flags; // the flags associated with this block
1692
1693 // fields used by BlockListBuilder
1694 int _total_preds; // number of predecessors found by BlockListBuilder
1695 ResourceBitMap _stores_to_locals; // bit is set when a local variable is stored in the block
1696
1697 // SSA specific fields: (factor out later)
1698 BlockList _successors; // the successors of this block
1699 BlockList _predecessors; // the predecessors of this block
1700 BlockList _dominates; // list of blocks that are dominated by this block
1701 BlockBegin* _dominator; // the dominator of this block
1702 // SSA specific ends
1703 BlockEnd* _end; // the last instruction of this block
1704 BlockList _exception_handlers; // the exception handlers potentially invoked by this block
1705 ValueStackStack* _exception_states; // only for xhandler entries: states of all instructions that have an edge to this xhandler
1706 int _exception_handler_pco; // if this block is the start of an exception handler,
1707 // this records the PC offset in the assembly code of the
1708 // first instruction in this block
1709 Label _label; // the label associated with this block
1710 LIR_List* _lir; // the low level intermediate representation for this block
1711
1712 ResourceBitMap _live_in; // set of live LIR_Opr registers at entry to this block
1713 ResourceBitMap _live_out; // set of live LIR_Opr registers at exit from this block
1714 ResourceBitMap _live_gen; // set of registers used before any redefinition in this block
1715 ResourceBitMap _live_kill; // set of registers defined in this block
1716
1717 ResourceBitMap _fpu_register_usage;
1718 intArray* _fpu_stack_state; // For x86 FPU code generation with UseLinearScan
1719 int _first_lir_instruction_id; // ID of first LIR instruction in this block
1720 int _last_lir_instruction_id; // ID of last LIR instruction in this block
1721
1722 void iterate_preorder (boolArray& mark, BlockClosure* closure);
1723 void iterate_postorder(boolArray& mark, BlockClosure* closure);
1724
1725 friend class SuxAndWeightAdjuster;
1726
1727 public:
1728 void* operator new(size_t size) throw() {
1729 Compilation* c = Compilation::current();
1730 void* res = c->arena()->Amalloc(size);
1731 ((BlockBegin*)res)->_id = c->get_next_id();
1732 ((BlockBegin*)res)->_block_id = c->get_next_block_id();
1733 return res;
1734 }
1735
1736 // initialization/counting
1737 static int number_of_blocks() {
1738 return Compilation::current()->number_of_blocks();
1739 }
1740
1741 // creation
1742 BlockBegin(int bci)
1743 : StateSplit(illegalType)
1744 , _bci(bci)
1745 , _depth_first_number(-1)
1746 , _linear_scan_number(-1)
1747 , _dominator_depth(-1)
1748 , _loop_depth(0)
1749 , _loop_index(-1)
1750 , _flags(0)
1751 , _total_preds(0)
1752 , _stores_to_locals()
1753 , _successors(2)
1754 , _predecessors(2)
1755 , _dominates(2)
1756 , _dominator(NULL)
1757 , _end(NULL)
1758 , _exception_handlers(1)
1759 , _exception_states(NULL)
1760 , _exception_handler_pco(-1)
1761 , _lir(NULL)
1762 , _live_in()
1763 , _live_out()
1764 , _live_gen()
1765 , _live_kill()
1766 , _fpu_register_usage()
1767 , _fpu_stack_state(NULL)
1768 , _first_lir_instruction_id(-1)
1769 , _last_lir_instruction_id(-1)
1770 {
1771 _block = this;
1772 #ifndef PRODUCT
1773 set_printable_bci(bci);
1774 #endif
1775 }
1776
1777 // accessors
1778 int block_id() const { return _block_id; }
1779 int bci() const { return _bci; }
1780 BlockList* successors() { return &_successors; }
1781 BlockList* dominates() { return &_dominates; }
1782 BlockBegin* dominator() const { return _dominator; }
1783 int loop_depth() const { return _loop_depth; }
1784 int dominator_depth() const { return _dominator_depth; }
1785 int depth_first_number() const { return _depth_first_number; }
1786 int linear_scan_number() const { return _linear_scan_number; }
1787 BlockEnd* end() const { return _end; }
1788 Label* label() { return &_label; }
1789 LIR_List* lir() const { return _lir; }
1790 int exception_handler_pco() const { return _exception_handler_pco; }
1791 ResourceBitMap& live_in() { return _live_in; }
1792 ResourceBitMap& live_out() { return _live_out; }
1793 ResourceBitMap& live_gen() { return _live_gen; }
1794 ResourceBitMap& live_kill() { return _live_kill; }
1795 ResourceBitMap& fpu_register_usage() { return _fpu_register_usage; }
1796 intArray* fpu_stack_state() const { return _fpu_stack_state; }
1797 int first_lir_instruction_id() const { return _first_lir_instruction_id; }
1798 int last_lir_instruction_id() const { return _last_lir_instruction_id; }
1799 int total_preds() const { return _total_preds; }
1800 BitMap& stores_to_locals() { return _stores_to_locals; }
1801
1802 // manipulation
1803 void set_dominator(BlockBegin* dom) { _dominator = dom; }
1804 void set_loop_depth(int d) { _loop_depth = d; }
1805 void set_dominator_depth(int d) { _dominator_depth = d; }
1806 void set_depth_first_number(int dfn) { _depth_first_number = dfn; }
1807 void set_linear_scan_number(int lsn) { _linear_scan_number = lsn; }
1808 void set_end(BlockEnd* end);
1809 void clear_end();
1810 void disconnect_from_graph();
1811 static void disconnect_edge(BlockBegin* from, BlockBegin* to);
1812 BlockBegin* insert_block_between(BlockBegin* sux);
1813 void substitute_sux(BlockBegin* old_sux, BlockBegin* new_sux);
1814 void set_lir(LIR_List* lir) { _lir = lir; }
1815 void set_exception_handler_pco(int pco) { _exception_handler_pco = pco; }
1816 void set_live_in (const ResourceBitMap& map) { _live_in = map; }
1817 void set_live_out (const ResourceBitMap& map) { _live_out = map; }
1818 void set_live_gen (const ResourceBitMap& map) { _live_gen = map; }
1819 void set_live_kill(const ResourceBitMap& map) { _live_kill = map; }
1820 void set_fpu_register_usage(const ResourceBitMap& map) { _fpu_register_usage = map; }
1821 void set_fpu_stack_state(intArray* state) { _fpu_stack_state = state; }
1822 void set_first_lir_instruction_id(int id) { _first_lir_instruction_id = id; }
1823 void set_last_lir_instruction_id(int id) { _last_lir_instruction_id = id; }
1824 void increment_total_preds(int n = 1) { _total_preds += n; }
1825 void init_stores_to_locals(int locals_count) { _stores_to_locals.initialize(locals_count); }
1826
1827 // generic
1828 virtual void state_values_do(ValueVisitor* f);
1829
1830 // successors and predecessors
1831 int number_of_sux() const;
1832 BlockBegin* sux_at(int i) const;
1833 void add_successor(BlockBegin* sux);
1834 void remove_successor(BlockBegin* pred);
1835 bool is_successor(BlockBegin* sux) const { return _successors.contains(sux); }
1836
1837 void add_predecessor(BlockBegin* pred);
1838 void remove_predecessor(BlockBegin* pred);
1839 bool is_predecessor(BlockBegin* pred) const { return _predecessors.contains(pred); }
1840 int number_of_preds() const { return _predecessors.length(); }
1841 BlockBegin* pred_at(int i) const { return _predecessors.at(i); }
1842
1843 // exception handlers potentially invoked by this block
1844 void add_exception_handler(BlockBegin* b);
1845 bool is_exception_handler(BlockBegin* b) const { return _exception_handlers.contains(b); }
1846 int number_of_exception_handlers() const { return _exception_handlers.length(); }
1847 BlockBegin* exception_handler_at(int i) const { return _exception_handlers.at(i); }
1848
1849 // states of the instructions that have an edge to this exception handler
1850 int number_of_exception_states() { assert(is_set(exception_entry_flag), "only for xhandlers"); return _exception_states == NULL ? 0 : _exception_states->length(); }
1851 ValueStack* exception_state_at(int idx) const { assert(is_set(exception_entry_flag), "only for xhandlers"); return _exception_states->at(idx); }
1852 int add_exception_state(ValueStack* state);
1853
1854 // flags
1855 enum Flag {
1856 no_flag = 0,
1857 std_entry_flag = 1 << 0,
1858 osr_entry_flag = 1 << 1,
1859 exception_entry_flag = 1 << 2,
1860 subroutine_entry_flag = 1 << 3,
1861 backward_branch_target_flag = 1 << 4,
1862 is_on_work_list_flag = 1 << 5,
1863 was_visited_flag = 1 << 6,
1864 parser_loop_header_flag = 1 << 7, // set by parser to identify blocks where phi functions can not be created on demand
1865 critical_edge_split_flag = 1 << 8, // set for all blocks that are introduced when critical edges are split
1866 linear_scan_loop_header_flag = 1 << 9, // set during loop-detection for LinearScan
1867 linear_scan_loop_end_flag = 1 << 10, // set during loop-detection for LinearScan
1868 donot_eliminate_range_checks = 1 << 11 // Should be try to eliminate range checks in this block
1869 };
1870
1871 void set(Flag f) { _flags |= f; }
1872 void clear(Flag f) { _flags &= ~f; }
1873 bool is_set(Flag f) const { return (_flags & f) != 0; }
1874 bool is_entry_block() const {
1875 const int entry_mask = std_entry_flag | osr_entry_flag | exception_entry_flag;
1876 return (_flags & entry_mask) != 0;
1877 }
1878
1879 // iteration
1880 void iterate_preorder (BlockClosure* closure);
1881 void iterate_postorder (BlockClosure* closure);
1882
1883 void block_values_do(ValueVisitor* f);
1884
1885 // loops
1886 void set_loop_index(int ix) { _loop_index = ix; }
1887 int loop_index() const { return _loop_index; }
1888
1889 // merging
1890 bool try_merge(ValueStack* state); // try to merge states at block begin
1891 void merge(ValueStack* state) { bool b = try_merge(state); assert(b, "merge failed"); }
1892
1893 // debugging
1894 void print_block() PRODUCT_RETURN;
1895 void print_block(InstructionPrinter& ip, bool live_only = false) PRODUCT_RETURN;
1896 };
1897
1898
1899 BASE(BlockEnd, StateSplit)
1900 private:
1901 BlockList* _sux;
1902
1903 protected:
1904 BlockList* sux() const { return _sux; }
1905
1906 void set_sux(BlockList* sux) {
1907 #ifdef ASSERT
1908 assert(sux != NULL, "sux must exist");
1909 for (int i = sux->length() - 1; i >= 0; i--) assert(sux->at(i) != NULL, "sux must exist");
1910 #endif
1911 _sux = sux;
1912 }
1913
1914 public:
1915 // creation
1916 BlockEnd(ValueType* type, ValueStack* state_before, bool is_safepoint)
1917 : StateSplit(type, state_before)
1918 , _sux(NULL)
1919 {
1920 set_flag(IsSafepointFlag, is_safepoint);
1921 }
1922
1923 // accessors
1924 bool is_safepoint() const { return check_flag(IsSafepointFlag); }
1925 // For compatibility with old code, for new code use block()
1926 BlockBegin* begin() const { return _block; }
1927
1928 // manipulation
1929 void set_begin(BlockBegin* begin);
1930
1931 // successors
1932 int number_of_sux() const { return _sux != NULL ? _sux->length() : 0; }
1933 BlockBegin* sux_at(int i) const { return _sux->at(i); }
1934 BlockBegin* default_sux() const { return sux_at(number_of_sux() - 1); }
1935 BlockBegin** addr_sux_at(int i) const { return _sux->adr_at(i); }
1936 int sux_index(BlockBegin* sux) const { return _sux->find(sux); }
1937 void substitute_sux(BlockBegin* old_sux, BlockBegin* new_sux);
1938 };
1939
1940
1941 LEAF(Goto, BlockEnd)
1942 public:
1943 enum Direction {
1944 none, // Just a regular goto
1945 taken, not_taken // Goto produced from If
1946 };
1947 private:
1948 ciMethod* _profiled_method;
1949 int _profiled_bci;
1950 Direction _direction;
1951 public:
1952 // creation
1953 Goto(BlockBegin* sux, ValueStack* state_before, bool is_safepoint = false)
1954 : BlockEnd(illegalType, state_before, is_safepoint)
1955 , _profiled_method(NULL)
1956 , _profiled_bci(0)
1957 , _direction(none) {
1958 BlockList* s = new BlockList(1);
1959 s->append(sux);
1960 set_sux(s);
1961 }
1962
1963 Goto(BlockBegin* sux, bool is_safepoint) : BlockEnd(illegalType, NULL, is_safepoint)
1964 , _profiled_method(NULL)
1965 , _profiled_bci(0)
1966 , _direction(none) {
1967 BlockList* s = new BlockList(1);
1968 s->append(sux);
1969 set_sux(s);
1970 }
1971
1972 bool should_profile() const { return check_flag(ProfileMDOFlag); }
1973 ciMethod* profiled_method() const { return _profiled_method; } // set only for profiled branches
1974 int profiled_bci() const { return _profiled_bci; }
1975 Direction direction() const { return _direction; }
1976
1977 void set_should_profile(bool value) { set_flag(ProfileMDOFlag, value); }
1978 void set_profiled_method(ciMethod* method) { _profiled_method = method; }
1979 void set_profiled_bci(int bci) { _profiled_bci = bci; }
1980 void set_direction(Direction d) { _direction = d; }
1981 };
1982
1983 #ifdef ASSERT
1984 LEAF(Assert, Instruction)
1985 private:
1986 Value _x;
1987 Condition _cond;
1988 Value _y;
1989 char *_message;
1990
1991 public:
1992 // creation
1993 // unordered_is_true is valid for float/double compares only
1994 Assert(Value x, Condition cond, bool unordered_is_true, Value y);
1995
1996 // accessors
1997 Value x() const { return _x; }
1998 Condition cond() const { return _cond; }
1999 bool unordered_is_true() const { return check_flag(UnorderedIsTrueFlag); }
2000 Value y() const { return _y; }
2001 const char *message() const { return _message; }
2002
2003 // generic
2004 virtual void input_values_do(ValueVisitor* f) { f->visit(&_x); f->visit(&_y); }
2005 };
2006 #endif
2007
2008 LEAF(RangeCheckPredicate, StateSplit)
2009 private:
2010 Value _x;
2011 Condition _cond;
2012 Value _y;
2013
2014 void check_state();
2015
2016 public:
2017 // creation
2018 // unordered_is_true is valid for float/double compares only
2019 RangeCheckPredicate(Value x, Condition cond, bool unordered_is_true, Value y, ValueStack* state) : StateSplit(illegalType)
2020 , _x(x)
2021 , _cond(cond)
2022 , _y(y)
2023 {
2024 ASSERT_VALUES
2025 set_flag(UnorderedIsTrueFlag, unordered_is_true);
2026 assert(x->type()->tag() == y->type()->tag(), "types must match");
2027 this->set_state(state);
2028 check_state();
2029 }
2030
2031 // Always deoptimize
2032 RangeCheckPredicate(ValueStack* state) : StateSplit(illegalType)
2033 {
2034 this->set_state(state);
2035 _x = _y = NULL;
2036 check_state();
2037 }
2038
2039 // accessors
2040 Value x() const { return _x; }
2041 Condition cond() const { return _cond; }
2042 bool unordered_is_true() const { return check_flag(UnorderedIsTrueFlag); }
2043 Value y() const { return _y; }
2044
2045 void always_fail() { _x = _y = NULL; }
2046
2047 // generic
2048 virtual void input_values_do(ValueVisitor* f) { StateSplit::input_values_do(f); f->visit(&_x); f->visit(&_y); }
2049 HASHING3(RangeCheckPredicate, true, x()->subst(), y()->subst(), cond())
2050 };
2051
2052 LEAF(If, BlockEnd)
2053 private:
2054 Value _x;
2055 Condition _cond;
2056 Value _y;
2057 ciMethod* _profiled_method;
2058 int _profiled_bci; // Canonicalizer may alter bci of If node
2059 bool _swapped; // Is the order reversed with respect to the original If in the
2060 // bytecode stream?
2061 bool _substituability_check;
2062 public:
2063 // creation
2064 // unordered_is_true is valid for float/double compares only
2065 If(Value x, Condition cond, bool unordered_is_true, Value y, BlockBegin* tsux, BlockBegin* fsux, ValueStack* state_before, bool is_safepoint, bool substituability_check=false)
2066 : BlockEnd(illegalType, state_before, is_safepoint)
2067 , _x(x)
2068 , _cond(cond)
2069 , _y(y)
2070 , _profiled_method(NULL)
2071 , _profiled_bci(0)
2072 , _swapped(false)
2073 , _substituability_check(substituability_check)
2074 {
2075 ASSERT_VALUES
2076 set_flag(UnorderedIsTrueFlag, unordered_is_true);
2077 assert(x->type()->tag() == y->type()->tag(), "types must match");
2078 BlockList* s = new BlockList(2);
2079 s->append(tsux);
2080 s->append(fsux);
2081 set_sux(s);
2082 }
2083
2084 // accessors
2085 Value x() const { return _x; }
2086 Condition cond() const { return _cond; }
2087 bool unordered_is_true() const { return check_flag(UnorderedIsTrueFlag); }
2088 Value y() const { return _y; }
2089 BlockBegin* sux_for(bool is_true) const { return sux_at(is_true ? 0 : 1); }
2090 BlockBegin* tsux() const { return sux_for(true); }
2091 BlockBegin* fsux() const { return sux_for(false); }
2092 BlockBegin* usux() const { return sux_for(unordered_is_true()); }
2093 bool should_profile() const { return check_flag(ProfileMDOFlag); }
2094 ciMethod* profiled_method() const { return _profiled_method; } // set only for profiled branches
2095 int profiled_bci() const { return _profiled_bci; } // set for profiled branches and tiered
2096 bool is_swapped() const { return _swapped; }
2097
2098 // manipulation
2099 void swap_operands() {
2100 Value t = _x; _x = _y; _y = t;
2101 _cond = mirror(_cond);
2102 }
2103
2104 void swap_sux() {
2105 assert(number_of_sux() == 2, "wrong number of successors");
2106 BlockList* s = sux();
2107 BlockBegin* t = s->at(0); s->at_put(0, s->at(1)); s->at_put(1, t);
2108 _cond = negate(_cond);
2109 set_flag(UnorderedIsTrueFlag, !check_flag(UnorderedIsTrueFlag));
2110 }
2111
2112 void set_should_profile(bool value) { set_flag(ProfileMDOFlag, value); }
2113 void set_profiled_method(ciMethod* method) { _profiled_method = method; }
2114 void set_profiled_bci(int bci) { _profiled_bci = bci; }
2115 void set_swapped(bool value) { _swapped = value; }
2116 bool substituability_check() const { return _substituability_check; }
2117 // generic
2118 virtual void input_values_do(ValueVisitor* f) { BlockEnd::input_values_do(f); f->visit(&_x); f->visit(&_y); }
2119 };
2120
2121
2122 LEAF(IfInstanceOf, BlockEnd)
2123 private:
2124 ciKlass* _klass;
2125 Value _obj;
2126 bool _test_is_instance; // jump if instance
2127 int _instanceof_bci;
2128
2129 public:
2130 IfInstanceOf(ciKlass* klass, Value obj, bool test_is_instance, int instanceof_bci, BlockBegin* tsux, BlockBegin* fsux)
2131 : BlockEnd(illegalType, NULL, false) // temporary set to false
2132 , _klass(klass)
2133 , _obj(obj)
2134 , _test_is_instance(test_is_instance)
2135 , _instanceof_bci(instanceof_bci)
2136 {
2137 ASSERT_VALUES
2138 assert(instanceof_bci >= 0, "illegal bci");
2139 BlockList* s = new BlockList(2);
2140 s->append(tsux);
2141 s->append(fsux);
2142 set_sux(s);
2143 }
2144
2145 // accessors
2146 //
2147 // Note 1: If test_is_instance() is true, IfInstanceOf tests if obj *is* an
2148 // instance of klass; otherwise it tests if it is *not* and instance
2149 // of klass.
2150 //
2151 // Note 2: IfInstanceOf instructions are created by combining an InstanceOf
2152 // and an If instruction. The IfInstanceOf bci() corresponds to the
2153 // bci that the If would have had; the (this->) instanceof_bci() is
2154 // the bci of the original InstanceOf instruction.
2155 ciKlass* klass() const { return _klass; }
2156 Value obj() const { return _obj; }
2157 int instanceof_bci() const { return _instanceof_bci; }
2158 bool test_is_instance() const { return _test_is_instance; }
2159 BlockBegin* sux_for(bool is_true) const { return sux_at(is_true ? 0 : 1); }
2160 BlockBegin* tsux() const { return sux_for(true); }
2161 BlockBegin* fsux() const { return sux_for(false); }
2162
2163 // manipulation
2164 void swap_sux() {
2165 assert(number_of_sux() == 2, "wrong number of successors");
2166 BlockList* s = sux();
2167 BlockBegin* t = s->at(0); s->at_put(0, s->at(1)); s->at_put(1, t);
2168 _test_is_instance = !_test_is_instance;
2169 }
2170
2171 // generic
2172 virtual void input_values_do(ValueVisitor* f) { BlockEnd::input_values_do(f); f->visit(&_obj); }
2173 };
2174
2175
2176 BASE(Switch, BlockEnd)
2177 private:
2178 Value _tag;
2179
2180 public:
2181 // creation
2182 Switch(Value tag, BlockList* sux, ValueStack* state_before, bool is_safepoint)
2183 : BlockEnd(illegalType, state_before, is_safepoint)
2184 , _tag(tag) {
2185 ASSERT_VALUES
2186 set_sux(sux);
2187 }
2188
2189 // accessors
2190 Value tag() const { return _tag; }
2191 int length() const { return number_of_sux() - 1; }
2192
2193 virtual bool needs_exception_state() const { return false; }
2194
2195 // generic
2196 virtual void input_values_do(ValueVisitor* f) { BlockEnd::input_values_do(f); f->visit(&_tag); }
2197 };
2198
2199
2200 LEAF(TableSwitch, Switch)
2201 private:
2202 int _lo_key;
2203
2204 public:
2205 // creation
2206 TableSwitch(Value tag, BlockList* sux, int lo_key, ValueStack* state_before, bool is_safepoint)
2207 : Switch(tag, sux, state_before, is_safepoint)
2208 , _lo_key(lo_key) { assert(_lo_key <= hi_key(), "integer overflow"); }
2209
2210 // accessors
2211 int lo_key() const { return _lo_key; }
2212 int hi_key() const { return _lo_key + (length() - 1); }
2213 };
2214
2215
2216 LEAF(LookupSwitch, Switch)
2217 private:
2218 intArray* _keys;
2219
2220 public:
2221 // creation
2222 LookupSwitch(Value tag, BlockList* sux, intArray* keys, ValueStack* state_before, bool is_safepoint)
2223 : Switch(tag, sux, state_before, is_safepoint)
2224 , _keys(keys) {
2225 assert(keys != NULL, "keys must exist");
2226 assert(keys->length() == length(), "sux & keys have incompatible lengths");
2227 }
2228
2229 // accessors
2230 int key_at(int i) const { return _keys->at(i); }
2231 };
2232
2233
2234 LEAF(Return, BlockEnd)
2235 private:
2236 Value _result;
2237
2238 public:
2239 // creation
2240 Return(Value result) :
2241 BlockEnd(result == NULL ? voidType : result->type()->base(), NULL, true),
2242 _result(result) {}
2243
2244 // accessors
2245 Value result() const { return _result; }
2246 bool has_result() const { return result() != NULL; }
2247
2248 // generic
2249 virtual void input_values_do(ValueVisitor* f) {
2250 BlockEnd::input_values_do(f);
2251 if (has_result()) f->visit(&_result);
2252 }
2253 };
2254
2255
2256 LEAF(Throw, BlockEnd)
2257 private:
2258 Value _exception;
2259
2260 public:
2261 // creation
2262 Throw(Value exception, ValueStack* state_before) : BlockEnd(illegalType, state_before, true), _exception(exception) {
2263 ASSERT_VALUES
2264 }
2265
2266 // accessors
2267 Value exception() const { return _exception; }
2268
2269 // generic
2270 virtual bool can_trap() const { return true; }
2271 virtual void input_values_do(ValueVisitor* f) { BlockEnd::input_values_do(f); f->visit(&_exception); }
2272 };
2273
2274
2275 LEAF(Base, BlockEnd)
2276 public:
2277 // creation
2278 Base(BlockBegin* std_entry, BlockBegin* osr_entry) : BlockEnd(illegalType, NULL, false) {
2279 assert(std_entry->is_set(BlockBegin::std_entry_flag), "std entry must be flagged");
2280 assert(osr_entry == NULL || osr_entry->is_set(BlockBegin::osr_entry_flag), "osr entry must be flagged");
2281 BlockList* s = new BlockList(2);
2282 if (osr_entry != NULL) s->append(osr_entry);
2283 s->append(std_entry); // must be default sux!
2284 set_sux(s);
2285 }
2286
2287 // accessors
2288 BlockBegin* std_entry() const { return default_sux(); }
2289 BlockBegin* osr_entry() const { return number_of_sux() < 2 ? NULL : sux_at(0); }
2290 };
2291
2292
2293 LEAF(OsrEntry, Instruction)
2294 public:
2295 // creation
2296 #ifdef _LP64
2297 OsrEntry() : Instruction(longType) { pin(); }
2298 #else
2299 OsrEntry() : Instruction(intType) { pin(); }
2300 #endif
2301
2302 // generic
2303 virtual void input_values_do(ValueVisitor* f) { }
2304 };
2305
2306
2307 // Models the incoming exception at a catch site
2308 LEAF(ExceptionObject, Instruction)
2309 public:
2310 // creation
2311 ExceptionObject() : Instruction(objectType) {
2312 pin();
2313 }
2314
2315 // generic
2316 virtual void input_values_do(ValueVisitor* f) { }
2317 };
2318
2319
2320 // Models needed rounding for floating-point values on Intel.
2321 // Currently only used to represent rounding of double-precision
2322 // values stored into local variables, but could be used to model
2323 // intermediate rounding of single-precision values as well.
2324 LEAF(RoundFP, Instruction)
2325 private:
2326 Value _input; // floating-point value to be rounded
2327
2328 public:
2329 RoundFP(Value input)
2330 : Instruction(input->type()) // Note: should not be used for constants
2331 , _input(input)
2332 {
2333 ASSERT_VALUES
2334 }
2335
2336 // accessors
2337 Value input() const { return _input; }
2338
2339 // generic
2340 virtual void input_values_do(ValueVisitor* f) { f->visit(&_input); }
2341 };
2342
2343
2344 BASE(UnsafeOp, Instruction)
2345 private:
2346 BasicType _basic_type; // ValueType can not express byte-sized integers
2347
2348 protected:
2349 // creation
2350 UnsafeOp(BasicType basic_type, bool is_put)
2351 : Instruction(is_put ? voidType : as_ValueType(basic_type))
2352 , _basic_type(basic_type)
2353 {
2354 //Note: Unsafe ops are not not guaranteed to throw NPE.
2355 // Convservatively, Unsafe operations must be pinned though we could be
2356 // looser about this if we wanted to..
2357 pin();
2358 }
2359
2360 public:
2361 // accessors
2362 BasicType basic_type() { return _basic_type; }
2363
2364 // generic
2365 virtual void input_values_do(ValueVisitor* f) { }
2366 };
2367
2368
2369 BASE(UnsafeRawOp, UnsafeOp)
2370 private:
2371 Value _base; // Base address (a Java long)
2372 Value _index; // Index if computed by optimizer; initialized to NULL
2373 int _log2_scale; // Scale factor: 0, 1, 2, or 3.
2374 // Indicates log2 of number of bytes (1, 2, 4, or 8)
2375 // to scale index by.
2376
2377 protected:
2378 UnsafeRawOp(BasicType basic_type, Value addr, bool is_put)
2379 : UnsafeOp(basic_type, is_put)
2380 , _base(addr)
2381 , _index(NULL)
2382 , _log2_scale(0)
2383 {
2384 // Can not use ASSERT_VALUES because index may be NULL
2385 assert(addr != NULL && addr->type()->is_long(), "just checking");
2386 }
2387
2388 UnsafeRawOp(BasicType basic_type, Value base, Value index, int log2_scale, bool is_put)
2389 : UnsafeOp(basic_type, is_put)
2390 , _base(base)
2391 , _index(index)
2392 , _log2_scale(log2_scale)
2393 {
2394 }
2395
2396 public:
2397 // accessors
2398 Value base() { return _base; }
2399 Value index() { return _index; }
2400 bool has_index() { return (_index != NULL); }
2401 int log2_scale() { return _log2_scale; }
2402
2403 // setters
2404 void set_base (Value base) { _base = base; }
2405 void set_index(Value index) { _index = index; }
2406 void set_log2_scale(int log2_scale) { _log2_scale = log2_scale; }
2407
2408 // generic
2409 virtual void input_values_do(ValueVisitor* f) { UnsafeOp::input_values_do(f);
2410 f->visit(&_base);
2411 if (has_index()) f->visit(&_index); }
2412 };
2413
2414
2415 LEAF(UnsafeGetRaw, UnsafeRawOp)
2416 private:
2417 bool _may_be_unaligned, _is_wide; // For OSREntry
2418
2419 public:
2420 UnsafeGetRaw(BasicType basic_type, Value addr, bool may_be_unaligned, bool is_wide = false)
2421 : UnsafeRawOp(basic_type, addr, false) {
2422 _may_be_unaligned = may_be_unaligned;
2423 _is_wide = is_wide;
2424 }
2425
2426 UnsafeGetRaw(BasicType basic_type, Value base, Value index, int log2_scale, bool may_be_unaligned, bool is_wide = false)
2427 : UnsafeRawOp(basic_type, base, index, log2_scale, false) {
2428 _may_be_unaligned = may_be_unaligned;
2429 _is_wide = is_wide;
2430 }
2431
2432 bool may_be_unaligned() { return _may_be_unaligned; }
2433 bool is_wide() { return _is_wide; }
2434 };
2435
2436
2437 LEAF(UnsafePutRaw, UnsafeRawOp)
2438 private:
2439 Value _value; // Value to be stored
2440
2441 public:
2442 UnsafePutRaw(BasicType basic_type, Value addr, Value value)
2443 : UnsafeRawOp(basic_type, addr, true)
2444 , _value(value)
2445 {
2446 assert(value != NULL, "just checking");
2447 ASSERT_VALUES
2448 }
2449
2450 UnsafePutRaw(BasicType basic_type, Value base, Value index, int log2_scale, Value value)
2451 : UnsafeRawOp(basic_type, base, index, log2_scale, true)
2452 , _value(value)
2453 {
2454 assert(value != NULL, "just checking");
2455 ASSERT_VALUES
2456 }
2457
2458 // accessors
2459 Value value() { return _value; }
2460
2461 // generic
2462 virtual void input_values_do(ValueVisitor* f) { UnsafeRawOp::input_values_do(f);
2463 f->visit(&_value); }
2464 };
2465
2466
2467 BASE(UnsafeObjectOp, UnsafeOp)
2468 private:
2469 Value _object; // Object to be fetched from or mutated
2470 Value _offset; // Offset within object
2471 bool _is_volatile; // true if volatile - dl/JSR166
2472 public:
2473 UnsafeObjectOp(BasicType basic_type, Value object, Value offset, bool is_put, bool is_volatile)
2474 : UnsafeOp(basic_type, is_put), _object(object), _offset(offset), _is_volatile(is_volatile)
2475 {
2476 }
2477
2478 // accessors
2479 Value object() { return _object; }
2480 Value offset() { return _offset; }
2481 bool is_volatile() { return _is_volatile; }
2482 // generic
2483 virtual void input_values_do(ValueVisitor* f) { UnsafeOp::input_values_do(f);
2484 f->visit(&_object);
2485 f->visit(&_offset); }
2486 };
2487
2488
2489 LEAF(UnsafeGetObject, UnsafeObjectOp)
2490 public:
2491 UnsafeGetObject(BasicType basic_type, Value object, Value offset, bool is_volatile)
2492 : UnsafeObjectOp(basic_type, object, offset, false, is_volatile)
2493 {
2494 ASSERT_VALUES
2495 }
2496 };
2497
2498
2499 LEAF(UnsafePutObject, UnsafeObjectOp)
2500 private:
2501 Value _value; // Value to be stored
2502 public:
2503 UnsafePutObject(BasicType basic_type, Value object, Value offset, Value value, bool is_volatile)
2504 : UnsafeObjectOp(basic_type, object, offset, true, is_volatile)
2505 , _value(value)
2506 {
2507 ASSERT_VALUES
2508 }
2509
2510 // accessors
2511 Value value() { return _value; }
2512
2513 // generic
2514 virtual void input_values_do(ValueVisitor* f) { UnsafeObjectOp::input_values_do(f);
2515 f->visit(&_value); }
2516 };
2517
2518 LEAF(UnsafeGetAndSetObject, UnsafeObjectOp)
2519 private:
2520 Value _value; // Value to be stored
2521 bool _is_add;
2522 public:
2523 UnsafeGetAndSetObject(BasicType basic_type, Value object, Value offset, Value value, bool is_add)
2524 : UnsafeObjectOp(basic_type, object, offset, false, false)
2525 , _value(value)
2526 , _is_add(is_add)
2527 {
2528 ASSERT_VALUES
2529 }
2530
2531 // accessors
2532 bool is_add() const { return _is_add; }
2533 Value value() { return _value; }
2534
2535 // generic
2536 virtual void input_values_do(ValueVisitor* f) { UnsafeObjectOp::input_values_do(f);
2537 f->visit(&_value); }
2538 };
2539
2540 LEAF(ProfileCall, Instruction)
2541 private:
2542 ciMethod* _method;
2543 int _bci_of_invoke;
2544 ciMethod* _callee; // the method that is called at the given bci
2545 Value _recv;
2546 ciKlass* _known_holder;
2547 Values* _obj_args; // arguments for type profiling
2548 ArgsNonNullState _nonnull_state; // Do we know whether some arguments are never null?
2549 bool _inlined; // Are we profiling a call that is inlined
2550
2551 public:
2552 ProfileCall(ciMethod* method, int bci, ciMethod* callee, Value recv, ciKlass* known_holder, Values* obj_args, bool inlined)
2553 : Instruction(voidType)
2554 , _method(method)
2555 , _bci_of_invoke(bci)
2556 , _callee(callee)
2557 , _recv(recv)
2558 , _known_holder(known_holder)
2559 , _obj_args(obj_args)
2560 , _inlined(inlined)
2561 {
2562 // The ProfileCall has side-effects and must occur precisely where located
2563 pin();
2564 }
2565
2566 ciMethod* method() const { return _method; }
2567 int bci_of_invoke() const { return _bci_of_invoke; }
2568 ciMethod* callee() const { return _callee; }
2569 Value recv() const { return _recv; }
2570 ciKlass* known_holder() const { return _known_holder; }
2571 int nb_profiled_args() const { return _obj_args == NULL ? 0 : _obj_args->length(); }
2572 Value profiled_arg_at(int i) const { return _obj_args->at(i); }
2573 bool arg_needs_null_check(int i) const {
2574 return _nonnull_state.arg_needs_null_check(i);
2575 }
2576 bool inlined() const { return _inlined; }
2577
2578 void set_arg_needs_null_check(int i, bool check) {
2579 _nonnull_state.set_arg_needs_null_check(i, check);
2580 }
2581
2582 virtual void input_values_do(ValueVisitor* f) {
2583 if (_recv != NULL) {
2584 f->visit(&_recv);
2585 }
2586 for (int i = 0; i < nb_profiled_args(); i++) {
2587 f->visit(_obj_args->adr_at(i));
2588 }
2589 }
2590 };
2591
2592 LEAF(ProfileReturnType, Instruction)
2593 private:
2594 ciMethod* _method;
2595 ciMethod* _callee;
2596 int _bci_of_invoke;
2597 Value _ret;
2598
2599 public:
2600 ProfileReturnType(ciMethod* method, int bci, ciMethod* callee, Value ret)
2601 : Instruction(voidType)
2602 , _method(method)
2603 , _callee(callee)
2604 , _bci_of_invoke(bci)
2605 , _ret(ret)
2606 {
2607 set_needs_null_check(true);
2608 // The ProfileType has side-effects and must occur precisely where located
2609 pin();
2610 }
2611
2612 ciMethod* method() const { return _method; }
2613 ciMethod* callee() const { return _callee; }
2614 int bci_of_invoke() const { return _bci_of_invoke; }
2615 Value ret() const { return _ret; }
2616
2617 virtual void input_values_do(ValueVisitor* f) {
2618 if (_ret != NULL) {
2619 f->visit(&_ret);
2620 }
2621 }
2622 };
2623
2624 // Call some C runtime function that doesn't safepoint,
2625 // optionally passing the current thread as the first argument.
2626 LEAF(RuntimeCall, Instruction)
2627 private:
2628 const char* _entry_name;
2629 address _entry;
2630 Values* _args;
2631 bool _pass_thread; // Pass the JavaThread* as an implicit first argument
2632
2633 public:
2634 RuntimeCall(ValueType* type, const char* entry_name, address entry, Values* args, bool pass_thread = true)
2635 : Instruction(type)
2636 , _entry_name(entry_name)
2637 , _entry(entry)
2638 , _args(args)
2639 , _pass_thread(pass_thread) {
2640 ASSERT_VALUES
2641 pin();
2642 }
2643
2644 const char* entry_name() const { return _entry_name; }
2645 address entry() const { return _entry; }
2646 int number_of_arguments() const { return _args->length(); }
2647 Value argument_at(int i) const { return _args->at(i); }
2648 bool pass_thread() const { return _pass_thread; }
2649
2650 virtual void input_values_do(ValueVisitor* f) {
2651 for (int i = 0; i < _args->length(); i++) f->visit(_args->adr_at(i));
2652 }
2653 };
2654
2655 // Use to trip invocation counter of an inlined method
2656
2657 LEAF(ProfileInvoke, Instruction)
2658 private:
2659 ciMethod* _inlinee;
2660 ValueStack* _state;
2661
2662 public:
2663 ProfileInvoke(ciMethod* inlinee, ValueStack* state)
2664 : Instruction(voidType)
2665 , _inlinee(inlinee)
2666 , _state(state)
2667 {
2668 // The ProfileInvoke has side-effects and must occur precisely where located QQQ???
2669 pin();
2670 }
2671
2672 ciMethod* inlinee() { return _inlinee; }
2673 ValueStack* state() { return _state; }
2674 virtual void input_values_do(ValueVisitor*) {}
2675 virtual void state_values_do(ValueVisitor*);
2676 };
2677
2678 LEAF(MemBar, Instruction)
2679 private:
2680 LIR_Code _code;
2681
2682 public:
2683 MemBar(LIR_Code code)
2684 : Instruction(voidType)
2685 , _code(code)
2686 {
2687 pin();
2688 }
2689
2690 LIR_Code code() { return _code; }
2691
2692 virtual void input_values_do(ValueVisitor*) {}
2693 };
2694
2695 class BlockPair: public CompilationResourceObj {
2696 private:
2697 BlockBegin* _from;
2698 BlockBegin* _to;
2699 public:
2700 BlockPair(BlockBegin* from, BlockBegin* to): _from(from), _to(to) {}
2701 BlockBegin* from() const { return _from; }
2702 BlockBegin* to() const { return _to; }
2703 bool is_same(BlockBegin* from, BlockBegin* to) const { return _from == from && _to == to; }
2704 bool is_same(BlockPair* p) const { return _from == p->from() && _to == p->to(); }
2705 void set_to(BlockBegin* b) { _to = b; }
2706 void set_from(BlockBegin* b) { _from = b; }
2707 };
2708
2709 typedef GrowableArray<BlockPair*> BlockPairList;
2710
2711 inline int BlockBegin::number_of_sux() const { assert(_end == NULL || _end->number_of_sux() == _successors.length(), "mismatch"); return _successors.length(); }
2712 inline BlockBegin* BlockBegin::sux_at(int i) const { assert(_end == NULL || _end->sux_at(i) == _successors.at(i), "mismatch"); return _successors.at(i); }
2713 inline void BlockBegin::add_successor(BlockBegin* sux) { assert(_end == NULL, "Would create mismatch with successors of BlockEnd"); _successors.append(sux); }
2714
2715 #undef ASSERT_VALUES
2716
2717 #endif // SHARE_C1_C1_INSTRUCTION_HPP