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