Fri, 29 Jan 2010 12:13:05 +0100
6917766: JSR 292 needs its own deopt handler
Summary: We need to introduce a new MH deopt handler so we can easily determine if the deopt happened at a MH call site or not.
Reviewed-by: never, jrose
1 /*
2 * Copyright 1999-2006 Sun Microsystems, Inc. All Rights Reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 *
23 */
25 // Predefined classes
26 class ciField;
27 class ValueStack;
28 class InstructionPrinter;
29 class IRScope;
30 class LIR_OprDesc;
31 typedef LIR_OprDesc* LIR_Opr;
34 // Instruction class hierarchy
35 //
36 // All leaf classes in the class hierarchy are concrete classes
37 // (i.e., are instantiated). All other classes are abstract and
38 // serve factoring.
40 class Instruction;
41 class HiWord;
42 class Phi;
43 class Local;
44 class Constant;
45 class AccessField;
46 class LoadField;
47 class StoreField;
48 class AccessArray;
49 class ArrayLength;
50 class AccessIndexed;
51 class LoadIndexed;
52 class StoreIndexed;
53 class NegateOp;
54 class Op2;
55 class ArithmeticOp;
56 class ShiftOp;
57 class LogicOp;
58 class CompareOp;
59 class IfOp;
60 class Convert;
61 class NullCheck;
62 class OsrEntry;
63 class ExceptionObject;
64 class StateSplit;
65 class Invoke;
66 class NewInstance;
67 class NewArray;
68 class NewTypeArray;
69 class NewObjectArray;
70 class NewMultiArray;
71 class TypeCheck;
72 class CheckCast;
73 class InstanceOf;
74 class AccessMonitor;
75 class MonitorEnter;
76 class MonitorExit;
77 class Intrinsic;
78 class BlockBegin;
79 class BlockEnd;
80 class Goto;
81 class If;
82 class IfInstanceOf;
83 class Switch;
84 class TableSwitch;
85 class LookupSwitch;
86 class Return;
87 class Throw;
88 class Base;
89 class RoundFP;
90 class UnsafeOp;
91 class UnsafeRawOp;
92 class UnsafeGetRaw;
93 class UnsafePutRaw;
94 class UnsafeObjectOp;
95 class UnsafeGetObject;
96 class UnsafePutObject;
97 class UnsafePrefetch;
98 class UnsafePrefetchRead;
99 class UnsafePrefetchWrite;
100 class ProfileCall;
101 class ProfileCounter;
103 // A Value is a reference to the instruction creating the value
104 typedef Instruction* Value;
105 define_array(ValueArray, Value)
106 define_stack(Values, ValueArray)
108 define_array(ValueStackArray, ValueStack*)
109 define_stack(ValueStackStack, ValueStackArray)
111 // BlockClosure is the base class for block traversal/iteration.
113 class BlockClosure: public CompilationResourceObj {
114 public:
115 virtual void block_do(BlockBegin* block) = 0;
116 };
119 // Some array and list classes
120 define_array(BlockBeginArray, BlockBegin*)
121 define_stack(_BlockList, BlockBeginArray)
123 class BlockList: public _BlockList {
124 public:
125 BlockList(): _BlockList() {}
126 BlockList(const int size): _BlockList(size) {}
127 BlockList(const int size, BlockBegin* init): _BlockList(size, init) {}
129 void iterate_forward(BlockClosure* closure);
130 void iterate_backward(BlockClosure* closure);
131 void blocks_do(void f(BlockBegin*));
132 void values_do(void f(Value*));
133 void print(bool cfg_only = false, bool live_only = false) PRODUCT_RETURN;
134 };
137 // InstructionVisitors provide type-based dispatch for instructions.
138 // For each concrete Instruction class X, a virtual function do_X is
139 // provided. Functionality that needs to be implemented for all classes
140 // (e.g., printing, code generation) is factored out into a specialised
141 // visitor instead of added to the Instruction classes itself.
143 class InstructionVisitor: public StackObj {
144 public:
145 void do_HiWord (HiWord* x) { ShouldNotReachHere(); }
146 virtual void do_Phi (Phi* x) = 0;
147 virtual void do_Local (Local* x) = 0;
148 virtual void do_Constant (Constant* x) = 0;
149 virtual void do_LoadField (LoadField* x) = 0;
150 virtual void do_StoreField (StoreField* x) = 0;
151 virtual void do_ArrayLength (ArrayLength* x) = 0;
152 virtual void do_LoadIndexed (LoadIndexed* x) = 0;
153 virtual void do_StoreIndexed (StoreIndexed* x) = 0;
154 virtual void do_NegateOp (NegateOp* x) = 0;
155 virtual void do_ArithmeticOp (ArithmeticOp* x) = 0;
156 virtual void do_ShiftOp (ShiftOp* x) = 0;
157 virtual void do_LogicOp (LogicOp* x) = 0;
158 virtual void do_CompareOp (CompareOp* x) = 0;
159 virtual void do_IfOp (IfOp* x) = 0;
160 virtual void do_Convert (Convert* x) = 0;
161 virtual void do_NullCheck (NullCheck* x) = 0;
162 virtual void do_Invoke (Invoke* x) = 0;
163 virtual void do_NewInstance (NewInstance* x) = 0;
164 virtual void do_NewTypeArray (NewTypeArray* x) = 0;
165 virtual void do_NewObjectArray (NewObjectArray* x) = 0;
166 virtual void do_NewMultiArray (NewMultiArray* x) = 0;
167 virtual void do_CheckCast (CheckCast* x) = 0;
168 virtual void do_InstanceOf (InstanceOf* x) = 0;
169 virtual void do_MonitorEnter (MonitorEnter* x) = 0;
170 virtual void do_MonitorExit (MonitorExit* x) = 0;
171 virtual void do_Intrinsic (Intrinsic* x) = 0;
172 virtual void do_BlockBegin (BlockBegin* x) = 0;
173 virtual void do_Goto (Goto* x) = 0;
174 virtual void do_If (If* x) = 0;
175 virtual void do_IfInstanceOf (IfInstanceOf* x) = 0;
176 virtual void do_TableSwitch (TableSwitch* x) = 0;
177 virtual void do_LookupSwitch (LookupSwitch* x) = 0;
178 virtual void do_Return (Return* x) = 0;
179 virtual void do_Throw (Throw* x) = 0;
180 virtual void do_Base (Base* x) = 0;
181 virtual void do_OsrEntry (OsrEntry* x) = 0;
182 virtual void do_ExceptionObject(ExceptionObject* x) = 0;
183 virtual void do_RoundFP (RoundFP* x) = 0;
184 virtual void do_UnsafeGetRaw (UnsafeGetRaw* x) = 0;
185 virtual void do_UnsafePutRaw (UnsafePutRaw* x) = 0;
186 virtual void do_UnsafeGetObject(UnsafeGetObject* x) = 0;
187 virtual void do_UnsafePutObject(UnsafePutObject* x) = 0;
188 virtual void do_UnsafePrefetchRead (UnsafePrefetchRead* x) = 0;
189 virtual void do_UnsafePrefetchWrite(UnsafePrefetchWrite* x) = 0;
190 virtual void do_ProfileCall (ProfileCall* x) = 0;
191 virtual void do_ProfileCounter (ProfileCounter* x) = 0;
192 };
195 // Hashing support
196 //
197 // Note: This hash functions affect the performance
198 // of ValueMap - make changes carefully!
200 #define HASH1(x1 ) ((intx)(x1))
201 #define HASH2(x1, x2 ) ((HASH1(x1 ) << 7) ^ HASH1(x2))
202 #define HASH3(x1, x2, x3 ) ((HASH2(x1, x2 ) << 7) ^ HASH1(x3))
203 #define HASH4(x1, x2, x3, x4) ((HASH3(x1, x2, x3) << 7) ^ HASH1(x4))
206 // The following macros are used to implement instruction-specific hashing.
207 // By default, each instruction implements hash() and is_equal(Value), used
208 // for value numbering/common subexpression elimination. The default imple-
209 // mentation disables value numbering. Each instruction which can be value-
210 // numbered, should define corresponding hash() and is_equal(Value) functions
211 // via the macros below. The f arguments specify all the values/op codes, etc.
212 // that need to be identical for two instructions to be identical.
213 //
214 // Note: The default implementation of hash() returns 0 in order to indicate
215 // that the instruction should not be considered for value numbering.
216 // The currently used hash functions do not guarantee that never a 0
217 // is produced. While this is still correct, it may be a performance
218 // bug (no value numbering for that node). However, this situation is
219 // so unlikely, that we are not going to handle it specially.
221 #define HASHING1(class_name, enabled, f1) \
222 virtual intx hash() const { \
223 return (enabled) ? HASH2(name(), f1) : 0; \
224 } \
225 virtual bool is_equal(Value v) const { \
226 if (!(enabled) ) return false; \
227 class_name* _v = v->as_##class_name(); \
228 if (_v == NULL ) return false; \
229 if (f1 != _v->f1) return false; \
230 return true; \
231 } \
234 #define HASHING2(class_name, enabled, f1, f2) \
235 virtual intx hash() const { \
236 return (enabled) ? HASH3(name(), f1, f2) : 0; \
237 } \
238 virtual bool is_equal(Value v) const { \
239 if (!(enabled) ) return false; \
240 class_name* _v = v->as_##class_name(); \
241 if (_v == NULL ) return false; \
242 if (f1 != _v->f1) return false; \
243 if (f2 != _v->f2) return false; \
244 return true; \
245 } \
248 #define HASHING3(class_name, enabled, f1, f2, f3) \
249 virtual intx hash() const { \
250 return (enabled) ? HASH4(name(), f1, f2, f3) : 0; \
251 } \
252 virtual bool is_equal(Value v) const { \
253 if (!(enabled) ) return false; \
254 class_name* _v = v->as_##class_name(); \
255 if (_v == NULL ) return false; \
256 if (f1 != _v->f1) return false; \
257 if (f2 != _v->f2) return false; \
258 if (f3 != _v->f3) return false; \
259 return true; \
260 } \
263 // The mother of all instructions...
265 class Instruction: public CompilationResourceObj {
266 private:
267 static int _next_id; // the node counter
269 int _id; // the unique instruction id
270 int _bci; // the instruction bci
271 int _use_count; // the number of instructions refering to this value (w/o prev/next); only roots can have use count = 0 or > 1
272 int _pin_state; // set of PinReason describing the reason for pinning
273 ValueType* _type; // the instruction value type
274 Instruction* _next; // the next instruction if any (NULL for BlockEnd instructions)
275 Instruction* _subst; // the substitution instruction if any
276 LIR_Opr _operand; // LIR specific information
277 unsigned int _flags; // Flag bits
279 XHandlers* _exception_handlers; // Flat list of exception handlers covering this instruction
281 #ifdef ASSERT
282 HiWord* _hi_word;
283 #endif
285 friend class UseCountComputer;
287 protected:
288 void set_bci(int bci) { assert(bci == SynchronizationEntryBCI || bci >= 0, "illegal bci"); _bci = bci; }
289 void set_type(ValueType* type) {
290 assert(type != NULL, "type must exist");
291 _type = type;
292 }
294 public:
295 enum InstructionFlag {
296 NeedsNullCheckFlag = 0,
297 CanTrapFlag,
298 DirectCompareFlag,
299 IsEliminatedFlag,
300 IsInitializedFlag,
301 IsLoadedFlag,
302 IsSafepointFlag,
303 IsStaticFlag,
304 IsStrictfpFlag,
305 NeedsStoreCheckFlag,
306 NeedsWriteBarrierFlag,
307 PreservesStateFlag,
308 TargetIsFinalFlag,
309 TargetIsLoadedFlag,
310 TargetIsStrictfpFlag,
311 UnorderedIsTrueFlag,
312 NeedsPatchingFlag,
313 ThrowIncompatibleClassChangeErrorFlag,
314 ProfileMDOFlag,
315 InstructionLastFlag
316 };
318 public:
319 bool check_flag(InstructionFlag id) const { return (_flags & (1 << id)) != 0; }
320 void set_flag(InstructionFlag id, bool f) { _flags = f ? (_flags | (1 << id)) : (_flags & ~(1 << id)); };
322 // 'globally' used condition values
323 enum Condition {
324 eql, neq, lss, leq, gtr, geq
325 };
327 // Instructions may be pinned for many reasons and under certain conditions
328 // with enough knowledge it's possible to safely unpin them.
329 enum PinReason {
330 PinUnknown = 1 << 0
331 , PinExplicitNullCheck = 1 << 3
332 , PinStackForStateSplit= 1 << 12
333 , PinStateSplitConstructor= 1 << 13
334 , PinGlobalValueNumbering= 1 << 14
335 };
337 static Condition mirror(Condition cond);
338 static Condition negate(Condition cond);
340 // initialization
341 static void initialize() { _next_id = 0; }
342 static int number_of_instructions() { return _next_id; }
344 // creation
345 Instruction(ValueType* type, bool type_is_constant = false, bool create_hi = true)
346 : _id(_next_id++)
347 , _bci(-99)
348 , _use_count(0)
349 , _pin_state(0)
350 , _type(type)
351 , _next(NULL)
352 , _subst(NULL)
353 , _flags(0)
354 , _operand(LIR_OprFact::illegalOpr)
355 , _exception_handlers(NULL)
356 #ifdef ASSERT
357 , _hi_word(NULL)
358 #endif
359 {
360 assert(type != NULL && (!type->is_constant() || type_is_constant), "type must exist");
361 #ifdef ASSERT
362 if (create_hi && type->is_double_word()) {
363 create_hi_word();
364 }
365 #endif
366 }
368 // accessors
369 int id() const { return _id; }
370 int bci() const { return _bci; }
371 int use_count() const { return _use_count; }
372 int pin_state() const { return _pin_state; }
373 bool is_pinned() const { return _pin_state != 0 || PinAllInstructions; }
374 ValueType* type() const { return _type; }
375 Instruction* prev(BlockBegin* block); // use carefully, expensive operation
376 Instruction* next() const { return _next; }
377 bool has_subst() const { return _subst != NULL; }
378 Instruction* subst() { return _subst == NULL ? this : _subst->subst(); }
379 LIR_Opr operand() const { return _operand; }
381 void set_needs_null_check(bool f) { set_flag(NeedsNullCheckFlag, f); }
382 bool needs_null_check() const { return check_flag(NeedsNullCheckFlag); }
384 bool has_uses() const { return use_count() > 0; }
385 bool is_root() const { return is_pinned() || use_count() > 1; }
386 XHandlers* exception_handlers() const { return _exception_handlers; }
388 // manipulation
389 void pin(PinReason reason) { _pin_state |= reason; }
390 void pin() { _pin_state |= PinUnknown; }
391 // DANGEROUS: only used by EliminateStores
392 void unpin(PinReason reason) { assert((reason & PinUnknown) == 0, "can't unpin unknown state"); _pin_state &= ~reason; }
393 virtual void set_lock_stack(ValueStack* l) { /* do nothing*/ }
394 virtual ValueStack* lock_stack() const { return NULL; }
396 Instruction* set_next(Instruction* next, int bci) {
397 if (next != NULL) {
398 assert(as_BlockEnd() == NULL, "BlockEnd instructions must have no next");
399 assert(next->as_Phi() == NULL && next->as_Local() == NULL, "shouldn't link these instructions into list");
400 next->set_bci(bci);
401 }
402 _next = next;
403 return next;
404 }
406 void set_subst(Instruction* subst) {
407 assert(subst == NULL ||
408 type()->base() == subst->type()->base() ||
409 subst->type()->base() == illegalType, "type can't change");
410 _subst = subst;
411 }
412 void set_exception_handlers(XHandlers *xhandlers) { _exception_handlers = xhandlers; }
414 #ifdef ASSERT
415 // HiWord is used for debugging and is allocated early to avoid
416 // allocation at inconvenient points
417 HiWord* hi_word() { return _hi_word; }
418 void create_hi_word();
419 #endif
422 // machine-specifics
423 void set_operand(LIR_Opr operand) { assert(operand != LIR_OprFact::illegalOpr, "operand must exist"); _operand = operand; }
424 void clear_operand() { _operand = LIR_OprFact::illegalOpr; }
426 // generic
427 virtual Instruction* as_Instruction() { return this; } // to satisfy HASHING1 macro
428 virtual HiWord* as_HiWord() { return NULL; }
429 virtual Phi* as_Phi() { return NULL; }
430 virtual Local* as_Local() { return NULL; }
431 virtual Constant* as_Constant() { return NULL; }
432 virtual AccessField* as_AccessField() { return NULL; }
433 virtual LoadField* as_LoadField() { return NULL; }
434 virtual StoreField* as_StoreField() { return NULL; }
435 virtual AccessArray* as_AccessArray() { return NULL; }
436 virtual ArrayLength* as_ArrayLength() { return NULL; }
437 virtual AccessIndexed* as_AccessIndexed() { return NULL; }
438 virtual LoadIndexed* as_LoadIndexed() { return NULL; }
439 virtual StoreIndexed* as_StoreIndexed() { return NULL; }
440 virtual NegateOp* as_NegateOp() { return NULL; }
441 virtual Op2* as_Op2() { return NULL; }
442 virtual ArithmeticOp* as_ArithmeticOp() { return NULL; }
443 virtual ShiftOp* as_ShiftOp() { return NULL; }
444 virtual LogicOp* as_LogicOp() { return NULL; }
445 virtual CompareOp* as_CompareOp() { return NULL; }
446 virtual IfOp* as_IfOp() { return NULL; }
447 virtual Convert* as_Convert() { return NULL; }
448 virtual NullCheck* as_NullCheck() { return NULL; }
449 virtual OsrEntry* as_OsrEntry() { return NULL; }
450 virtual StateSplit* as_StateSplit() { return NULL; }
451 virtual Invoke* as_Invoke() { return NULL; }
452 virtual NewInstance* as_NewInstance() { return NULL; }
453 virtual NewArray* as_NewArray() { return NULL; }
454 virtual NewTypeArray* as_NewTypeArray() { return NULL; }
455 virtual NewObjectArray* as_NewObjectArray() { return NULL; }
456 virtual NewMultiArray* as_NewMultiArray() { return NULL; }
457 virtual TypeCheck* as_TypeCheck() { return NULL; }
458 virtual CheckCast* as_CheckCast() { return NULL; }
459 virtual InstanceOf* as_InstanceOf() { return NULL; }
460 virtual AccessMonitor* as_AccessMonitor() { return NULL; }
461 virtual MonitorEnter* as_MonitorEnter() { return NULL; }
462 virtual MonitorExit* as_MonitorExit() { return NULL; }
463 virtual Intrinsic* as_Intrinsic() { return NULL; }
464 virtual BlockBegin* as_BlockBegin() { return NULL; }
465 virtual BlockEnd* as_BlockEnd() { return NULL; }
466 virtual Goto* as_Goto() { return NULL; }
467 virtual If* as_If() { return NULL; }
468 virtual IfInstanceOf* as_IfInstanceOf() { return NULL; }
469 virtual TableSwitch* as_TableSwitch() { return NULL; }
470 virtual LookupSwitch* as_LookupSwitch() { return NULL; }
471 virtual Return* as_Return() { return NULL; }
472 virtual Throw* as_Throw() { return NULL; }
473 virtual Base* as_Base() { return NULL; }
474 virtual RoundFP* as_RoundFP() { return NULL; }
475 virtual ExceptionObject* as_ExceptionObject() { return NULL; }
476 virtual UnsafeOp* as_UnsafeOp() { return NULL; }
478 virtual void visit(InstructionVisitor* v) = 0;
480 virtual bool can_trap() const { return false; }
482 virtual void input_values_do(void f(Value*)) = 0;
483 virtual void state_values_do(void f(Value*)) { /* usually no state - override on demand */ }
484 virtual void other_values_do(void f(Value*)) { /* usually no other - override on demand */ }
485 void values_do(void f(Value*)) { input_values_do(f); state_values_do(f); other_values_do(f); }
487 virtual ciType* exact_type() const { return NULL; }
488 virtual ciType* declared_type() const { return NULL; }
490 // hashing
491 virtual const char* name() const = 0;
492 HASHING1(Instruction, false, id()) // hashing disabled by default
494 // debugging
495 void print() PRODUCT_RETURN;
496 void print_line() PRODUCT_RETURN;
497 void print(InstructionPrinter& ip) PRODUCT_RETURN;
498 };
501 // The following macros are used to define base (i.e., non-leaf)
502 // and leaf instruction classes. They define class-name related
503 // generic functionality in one place.
505 #define BASE(class_name, super_class_name) \
506 class class_name: public super_class_name { \
507 public: \
508 virtual class_name* as_##class_name() { return this; } \
511 #define LEAF(class_name, super_class_name) \
512 BASE(class_name, super_class_name) \
513 public: \
514 virtual const char* name() const { return #class_name; } \
515 virtual void visit(InstructionVisitor* v) { v->do_##class_name(this); } \
518 // Debugging support
520 #ifdef ASSERT
521 static void assert_value(Value* x) { assert((*x) != NULL, "value must exist"); }
522 #define ASSERT_VALUES values_do(assert_value);
523 #else
524 #define ASSERT_VALUES
525 #endif // ASSERT
528 // A HiWord occupies the 'high word' of a 2-word
529 // expression stack entry. Hi & lo words must be
530 // paired on the expression stack (otherwise the
531 // bytecode sequence is illegal). Note that 'hi'
532 // refers to the IR expression stack format and
533 // does *not* imply a machine word ordering. No
534 // HiWords are used in optimized mode for speed,
535 // but NULL pointers are used instead.
537 LEAF(HiWord, Instruction)
538 private:
539 Value _lo_word;
541 public:
542 // creation
543 HiWord(Value lo_word)
544 : Instruction(illegalType, false, false),
545 _lo_word(lo_word) {
546 // hi-words are also allowed for illegal lo-words
547 assert(lo_word->type()->is_double_word() || lo_word->type()->is_illegal(),
548 "HiWord must be used for 2-word values only");
549 }
551 // accessors
552 Value lo_word() const { return _lo_word->subst(); }
554 // for invalidating of HiWords
555 void make_illegal() { set_type(illegalType); }
557 // generic
558 virtual void input_values_do(void f(Value*)) { ShouldNotReachHere(); }
559 };
562 // A Phi is a phi function in the sense of SSA form. It stands for
563 // the value of a local variable at the beginning of a join block.
564 // A Phi consists of n operands, one for every incoming branch.
566 LEAF(Phi, Instruction)
567 private:
568 BlockBegin* _block; // the block to which the phi function belongs
569 int _pf_flags; // the flags of the phi function
570 int _index; // to value on operand stack (index < 0) or to local
571 public:
572 // creation
573 Phi(ValueType* type, BlockBegin* b, int index)
574 : Instruction(type->base())
575 , _pf_flags(0)
576 , _block(b)
577 , _index(index)
578 {
579 if (type->is_illegal()) {
580 make_illegal();
581 }
582 }
584 // flags
585 enum Flag {
586 no_flag = 0,
587 visited = 1 << 0,
588 cannot_simplify = 1 << 1
589 };
591 // accessors
592 bool is_local() const { return _index >= 0; }
593 bool is_on_stack() const { return !is_local(); }
594 int local_index() const { assert(is_local(), ""); return _index; }
595 int stack_index() const { assert(is_on_stack(), ""); return -(_index+1); }
597 Value operand_at(int i) const;
598 int operand_count() const;
600 BlockBegin* block() const { return _block; }
602 void set(Flag f) { _pf_flags |= f; }
603 void clear(Flag f) { _pf_flags &= ~f; }
604 bool is_set(Flag f) const { return (_pf_flags & f) != 0; }
606 // Invalidates phis corresponding to merges of locals of two different types
607 // (these should never be referenced, otherwise the bytecodes are illegal)
608 void make_illegal() {
609 set(cannot_simplify);
610 set_type(illegalType);
611 }
613 bool is_illegal() const {
614 return type()->is_illegal();
615 }
617 // generic
618 virtual void input_values_do(void f(Value*)) {
619 }
620 };
623 // A local is a placeholder for an incoming argument to a function call.
624 LEAF(Local, Instruction)
625 private:
626 int _java_index; // the local index within the method to which the local belongs
627 public:
628 // creation
629 Local(ValueType* type, int index)
630 : Instruction(type)
631 , _java_index(index)
632 {}
634 // accessors
635 int java_index() const { return _java_index; }
637 // generic
638 virtual void input_values_do(void f(Value*)) { /* no values */ }
639 };
642 LEAF(Constant, Instruction)
643 ValueStack* _state;
645 public:
646 // creation
647 Constant(ValueType* type):
648 Instruction(type, true)
649 , _state(NULL) {
650 assert(type->is_constant(), "must be a constant");
651 }
653 Constant(ValueType* type, ValueStack* state):
654 Instruction(type, true)
655 , _state(state) {
656 assert(state != NULL, "only used for constants which need patching");
657 assert(type->is_constant(), "must be a constant");
658 // since it's patching it needs to be pinned
659 pin();
660 }
662 ValueStack* state() const { return _state; }
664 // generic
665 virtual bool can_trap() const { return state() != NULL; }
666 virtual void input_values_do(void f(Value*)) { /* no values */ }
667 virtual void other_values_do(void f(Value*));
669 virtual intx hash() const;
670 virtual bool is_equal(Value v) const;
672 virtual BlockBegin* compare(Instruction::Condition condition, Value right,
673 BlockBegin* true_sux, BlockBegin* false_sux);
674 };
677 BASE(AccessField, Instruction)
678 private:
679 Value _obj;
680 int _offset;
681 ciField* _field;
682 ValueStack* _state_before; // state is set only for unloaded or uninitialized fields
683 ValueStack* _lock_stack; // contains lock and scope information
684 NullCheck* _explicit_null_check; // For explicit null check elimination
686 public:
687 // creation
688 AccessField(Value obj, int offset, ciField* field, bool is_static, ValueStack* lock_stack,
689 ValueStack* state_before, bool is_loaded, bool is_initialized)
690 : Instruction(as_ValueType(field->type()->basic_type()))
691 , _obj(obj)
692 , _offset(offset)
693 , _field(field)
694 , _lock_stack(lock_stack)
695 , _state_before(state_before)
696 , _explicit_null_check(NULL)
697 {
698 set_needs_null_check(!is_static);
699 set_flag(IsLoadedFlag, is_loaded);
700 set_flag(IsInitializedFlag, is_initialized);
701 set_flag(IsStaticFlag, is_static);
702 ASSERT_VALUES
703 if (!is_loaded || (PatchALot && !field->is_volatile())) {
704 // need to patch if the holder wasn't loaded or we're testing
705 // using PatchALot. Don't allow PatchALot for fields which are
706 // known to be volatile they aren't patchable.
707 set_flag(NeedsPatchingFlag, true);
708 }
709 // pin of all instructions with memory access
710 pin();
711 }
713 // accessors
714 Value obj() const { return _obj; }
715 int offset() const { return _offset; }
716 ciField* field() const { return _field; }
717 BasicType field_type() const { return _field->type()->basic_type(); }
718 bool is_static() const { return check_flag(IsStaticFlag); }
719 bool is_loaded() const { return check_flag(IsLoadedFlag); }
720 bool is_initialized() const { return check_flag(IsInitializedFlag); }
721 ValueStack* state_before() const { return _state_before; }
722 ValueStack* lock_stack() const { return _lock_stack; }
723 NullCheck* explicit_null_check() const { return _explicit_null_check; }
724 bool needs_patching() const { return check_flag(NeedsPatchingFlag); }
726 // manipulation
727 void set_lock_stack(ValueStack* l) { _lock_stack = l; }
728 // Under certain circumstances, if a previous NullCheck instruction
729 // proved the target object non-null, we can eliminate the explicit
730 // null check and do an implicit one, simply specifying the debug
731 // information from the NullCheck. This field should only be consulted
732 // if needs_null_check() is true.
733 void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
735 // generic
736 virtual bool can_trap() const { return needs_null_check() || needs_patching(); }
737 virtual void input_values_do(void f(Value*)) { f(&_obj); }
738 virtual void other_values_do(void f(Value*));
739 };
742 LEAF(LoadField, AccessField)
743 public:
744 // creation
745 LoadField(Value obj, int offset, ciField* field, bool is_static, ValueStack* lock_stack,
746 ValueStack* state_before, bool is_loaded, bool is_initialized)
747 : AccessField(obj, offset, field, is_static, lock_stack, state_before, is_loaded, is_initialized)
748 {}
750 ciType* declared_type() const;
751 ciType* exact_type() const;
753 // generic
754 HASHING2(LoadField, is_loaded() && !field()->is_volatile(), obj()->subst(), offset()) // cannot be eliminated if not yet loaded or if volatile
755 };
758 LEAF(StoreField, AccessField)
759 private:
760 Value _value;
762 public:
763 // creation
764 StoreField(Value obj, int offset, ciField* field, Value value, bool is_static, ValueStack* lock_stack,
765 ValueStack* state_before, bool is_loaded, bool is_initialized)
766 : AccessField(obj, offset, field, is_static, lock_stack, state_before, is_loaded, is_initialized)
767 , _value(value)
768 {
769 set_flag(NeedsWriteBarrierFlag, as_ValueType(field_type())->is_object());
770 ASSERT_VALUES
771 pin();
772 }
774 // accessors
775 Value value() const { return _value; }
776 bool needs_write_barrier() const { return check_flag(NeedsWriteBarrierFlag); }
778 // generic
779 virtual void input_values_do(void f(Value*)) { AccessField::input_values_do(f); f(&_value); }
780 };
783 BASE(AccessArray, Instruction)
784 private:
785 Value _array;
786 ValueStack* _lock_stack;
788 public:
789 // creation
790 AccessArray(ValueType* type, Value array, ValueStack* lock_stack)
791 : Instruction(type)
792 , _array(array)
793 , _lock_stack(lock_stack) {
794 set_needs_null_check(true);
795 ASSERT_VALUES
796 pin(); // instruction with side effect (null exception or range check throwing)
797 }
799 Value array() const { return _array; }
800 ValueStack* lock_stack() const { return _lock_stack; }
802 // setters
803 void set_lock_stack(ValueStack* l) { _lock_stack = l; }
805 // generic
806 virtual bool can_trap() const { return needs_null_check(); }
807 virtual void input_values_do(void f(Value*)) { f(&_array); }
808 virtual void other_values_do(void f(Value*));
809 };
812 LEAF(ArrayLength, AccessArray)
813 private:
814 NullCheck* _explicit_null_check; // For explicit null check elimination
816 public:
817 // creation
818 ArrayLength(Value array, ValueStack* lock_stack)
819 : AccessArray(intType, array, lock_stack)
820 , _explicit_null_check(NULL) {}
822 // accessors
823 NullCheck* explicit_null_check() const { return _explicit_null_check; }
825 // setters
826 // See LoadField::set_explicit_null_check for documentation
827 void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
829 // generic
830 HASHING1(ArrayLength, true, array()->subst())
831 };
834 BASE(AccessIndexed, AccessArray)
835 private:
836 Value _index;
837 Value _length;
838 BasicType _elt_type;
840 public:
841 // creation
842 AccessIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* lock_stack)
843 : AccessArray(as_ValueType(elt_type), array, lock_stack)
844 , _index(index)
845 , _length(length)
846 , _elt_type(elt_type)
847 {
848 ASSERT_VALUES
849 }
851 // accessors
852 Value index() const { return _index; }
853 Value length() const { return _length; }
854 BasicType elt_type() const { return _elt_type; }
856 // perform elimination of range checks involving constants
857 bool compute_needs_range_check();
859 // generic
860 virtual void input_values_do(void f(Value*)) { AccessArray::input_values_do(f); f(&_index); if (_length != NULL) f(&_length); }
861 };
864 LEAF(LoadIndexed, AccessIndexed)
865 private:
866 NullCheck* _explicit_null_check; // For explicit null check elimination
868 public:
869 // creation
870 LoadIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* lock_stack)
871 : AccessIndexed(array, index, length, elt_type, lock_stack)
872 , _explicit_null_check(NULL) {}
874 // accessors
875 NullCheck* explicit_null_check() const { return _explicit_null_check; }
877 // setters
878 // See LoadField::set_explicit_null_check for documentation
879 void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
881 ciType* exact_type() const;
882 ciType* declared_type() const;
884 // generic
885 HASHING2(LoadIndexed, true, array()->subst(), index()->subst())
886 };
889 LEAF(StoreIndexed, AccessIndexed)
890 private:
891 Value _value;
893 public:
894 // creation
895 StoreIndexed(Value array, Value index, Value length, BasicType elt_type, Value value, ValueStack* lock_stack)
896 : AccessIndexed(array, index, length, elt_type, lock_stack)
897 , _value(value)
898 {
899 set_flag(NeedsWriteBarrierFlag, (as_ValueType(elt_type)->is_object()));
900 set_flag(NeedsStoreCheckFlag, (as_ValueType(elt_type)->is_object()));
901 ASSERT_VALUES
902 pin();
903 }
905 // accessors
906 Value value() const { return _value; }
907 IRScope* scope() const; // the state's scope
908 bool needs_write_barrier() const { return check_flag(NeedsWriteBarrierFlag); }
909 bool needs_store_check() const { return check_flag(NeedsStoreCheckFlag); }
911 // generic
912 virtual void input_values_do(void f(Value*)) { AccessIndexed::input_values_do(f); f(&_value); }
913 };
916 LEAF(NegateOp, Instruction)
917 private:
918 Value _x;
920 public:
921 // creation
922 NegateOp(Value x) : Instruction(x->type()->base()), _x(x) {
923 ASSERT_VALUES
924 }
926 // accessors
927 Value x() const { return _x; }
929 // generic
930 virtual void input_values_do(void f(Value*)) { f(&_x); }
931 };
934 BASE(Op2, Instruction)
935 private:
936 Bytecodes::Code _op;
937 Value _x;
938 Value _y;
940 public:
941 // creation
942 Op2(ValueType* type, Bytecodes::Code op, Value x, Value y) : Instruction(type), _op(op), _x(x), _y(y) {
943 ASSERT_VALUES
944 }
946 // accessors
947 Bytecodes::Code op() const { return _op; }
948 Value x() const { return _x; }
949 Value y() const { return _y; }
951 // manipulators
952 void swap_operands() {
953 assert(is_commutative(), "operation must be commutative");
954 Value t = _x; _x = _y; _y = t;
955 }
957 // generic
958 virtual bool is_commutative() const { return false; }
959 virtual void input_values_do(void f(Value*)) { f(&_x); f(&_y); }
960 };
963 LEAF(ArithmeticOp, Op2)
964 private:
965 ValueStack* _lock_stack; // used only for division operations
966 public:
967 // creation
968 ArithmeticOp(Bytecodes::Code op, Value x, Value y, bool is_strictfp, ValueStack* lock_stack)
969 : Op2(x->type()->meet(y->type()), op, x, y)
970 , _lock_stack(lock_stack) {
971 set_flag(IsStrictfpFlag, is_strictfp);
972 if (can_trap()) pin();
973 }
975 // accessors
976 ValueStack* lock_stack() const { return _lock_stack; }
977 bool is_strictfp() const { return check_flag(IsStrictfpFlag); }
979 // setters
980 void set_lock_stack(ValueStack* l) { _lock_stack = l; }
982 // generic
983 virtual bool is_commutative() const;
984 virtual bool can_trap() const;
985 virtual void other_values_do(void f(Value*));
986 HASHING3(Op2, true, op(), x()->subst(), y()->subst())
987 };
990 LEAF(ShiftOp, Op2)
991 public:
992 // creation
993 ShiftOp(Bytecodes::Code op, Value x, Value s) : Op2(x->type()->base(), op, x, s) {}
995 // generic
996 HASHING3(Op2, true, op(), x()->subst(), y()->subst())
997 };
1000 LEAF(LogicOp, Op2)
1001 public:
1002 // creation
1003 LogicOp(Bytecodes::Code op, Value x, Value y) : Op2(x->type()->meet(y->type()), op, x, y) {}
1005 // generic
1006 virtual bool is_commutative() const;
1007 HASHING3(Op2, true, op(), x()->subst(), y()->subst())
1008 };
1011 LEAF(CompareOp, Op2)
1012 private:
1013 ValueStack* _state_before; // for deoptimization, when canonicalizing
1014 public:
1015 // creation
1016 CompareOp(Bytecodes::Code op, Value x, Value y, ValueStack* state_before)
1017 : Op2(intType, op, x, y)
1018 , _state_before(state_before)
1019 {}
1021 // accessors
1022 ValueStack* state_before() const { return _state_before; }
1024 // generic
1025 HASHING3(Op2, true, op(), x()->subst(), y()->subst())
1026 virtual void other_values_do(void f(Value*));
1027 };
1030 LEAF(IfOp, Op2)
1031 private:
1032 Value _tval;
1033 Value _fval;
1035 public:
1036 // creation
1037 IfOp(Value x, Condition cond, Value y, Value tval, Value fval)
1038 : Op2(tval->type()->meet(fval->type()), (Bytecodes::Code)cond, x, y)
1039 , _tval(tval)
1040 , _fval(fval)
1041 {
1042 ASSERT_VALUES
1043 assert(tval->type()->tag() == fval->type()->tag(), "types must match");
1044 }
1046 // accessors
1047 virtual bool is_commutative() const;
1048 Bytecodes::Code op() const { ShouldNotCallThis(); return Bytecodes::_illegal; }
1049 Condition cond() const { return (Condition)Op2::op(); }
1050 Value tval() const { return _tval; }
1051 Value fval() const { return _fval; }
1053 // generic
1054 virtual void input_values_do(void f(Value*)) { Op2::input_values_do(f); f(&_tval); f(&_fval); }
1055 };
1058 LEAF(Convert, Instruction)
1059 private:
1060 Bytecodes::Code _op;
1061 Value _value;
1063 public:
1064 // creation
1065 Convert(Bytecodes::Code op, Value value, ValueType* to_type) : Instruction(to_type), _op(op), _value(value) {
1066 ASSERT_VALUES
1067 }
1069 // accessors
1070 Bytecodes::Code op() const { return _op; }
1071 Value value() const { return _value; }
1073 // generic
1074 virtual void input_values_do(void f(Value*)) { f(&_value); }
1075 HASHING2(Convert, true, op(), value()->subst())
1076 };
1079 LEAF(NullCheck, Instruction)
1080 private:
1081 Value _obj;
1082 ValueStack* _lock_stack;
1084 public:
1085 // creation
1086 NullCheck(Value obj, ValueStack* lock_stack) : Instruction(obj->type()->base()), _obj(obj), _lock_stack(lock_stack) {
1087 ASSERT_VALUES
1088 set_can_trap(true);
1089 assert(_obj->type()->is_object(), "null check must be applied to objects only");
1090 pin(Instruction::PinExplicitNullCheck);
1091 }
1093 // accessors
1094 Value obj() const { return _obj; }
1095 ValueStack* lock_stack() const { return _lock_stack; }
1097 // setters
1098 void set_lock_stack(ValueStack* l) { _lock_stack = l; }
1099 void set_can_trap(bool can_trap) { set_flag(CanTrapFlag, can_trap); }
1101 // generic
1102 virtual bool can_trap() const { return check_flag(CanTrapFlag); /* null-check elimination sets to false */ }
1103 virtual void input_values_do(void f(Value*)) { f(&_obj); }
1104 virtual void other_values_do(void f(Value*));
1105 HASHING1(NullCheck, true, obj()->subst())
1106 };
1109 BASE(StateSplit, Instruction)
1110 private:
1111 ValueStack* _state;
1113 protected:
1114 static void substitute(BlockList& list, BlockBegin* old_block, BlockBegin* new_block);
1116 public:
1117 // creation
1118 StateSplit(ValueType* type) : Instruction(type), _state(NULL) {
1119 pin(PinStateSplitConstructor);
1120 }
1122 // accessors
1123 ValueStack* state() const { return _state; }
1124 IRScope* scope() const; // the state's scope
1126 // manipulation
1127 void set_state(ValueStack* state) { _state = state; }
1129 // generic
1130 virtual void input_values_do(void f(Value*)) { /* no values */ }
1131 virtual void state_values_do(void f(Value*));
1132 };
1135 LEAF(Invoke, StateSplit)
1136 private:
1137 Bytecodes::Code _code;
1138 Value _recv;
1139 Values* _args;
1140 BasicTypeList* _signature;
1141 int _vtable_index;
1142 ciMethod* _target;
1144 public:
1145 // creation
1146 Invoke(Bytecodes::Code code, ValueType* result_type, Value recv, Values* args,
1147 int vtable_index, ciMethod* target);
1149 // accessors
1150 Bytecodes::Code code() const { return _code; }
1151 Value receiver() const { return _recv; }
1152 bool has_receiver() const { return receiver() != NULL; }
1153 int number_of_arguments() const { return _args->length(); }
1154 Value argument_at(int i) const { return _args->at(i); }
1155 int vtable_index() const { return _vtable_index; }
1156 BasicTypeList* signature() const { return _signature; }
1157 ciMethod* target() const { return _target; }
1159 // Returns false if target is not loaded
1160 bool target_is_final() const { return check_flag(TargetIsFinalFlag); }
1161 bool target_is_loaded() const { return check_flag(TargetIsLoadedFlag); }
1162 // Returns false if target is not loaded
1163 bool target_is_strictfp() const { return check_flag(TargetIsStrictfpFlag); }
1165 // generic
1166 virtual bool can_trap() const { return true; }
1167 virtual void input_values_do(void f(Value*)) {
1168 StateSplit::input_values_do(f);
1169 if (has_receiver()) f(&_recv);
1170 for (int i = 0; i < _args->length(); i++) f(_args->adr_at(i));
1171 }
1172 };
1175 LEAF(NewInstance, StateSplit)
1176 private:
1177 ciInstanceKlass* _klass;
1179 public:
1180 // creation
1181 NewInstance(ciInstanceKlass* klass) : StateSplit(instanceType), _klass(klass) {}
1183 // accessors
1184 ciInstanceKlass* klass() const { return _klass; }
1186 // generic
1187 virtual bool can_trap() const { return true; }
1188 ciType* exact_type() const;
1189 };
1192 BASE(NewArray, StateSplit)
1193 private:
1194 Value _length;
1195 ValueStack* _state_before;
1197 public:
1198 // creation
1199 NewArray(Value length, ValueStack* state_before) : StateSplit(objectType), _length(length), _state_before(state_before) {
1200 // Do not ASSERT_VALUES since length is NULL for NewMultiArray
1201 }
1203 // accessors
1204 ValueStack* state_before() const { return _state_before; }
1205 Value length() const { return _length; }
1207 // generic
1208 virtual bool can_trap() const { return true; }
1209 virtual void input_values_do(void f(Value*)) { StateSplit::input_values_do(f); f(&_length); }
1210 virtual void other_values_do(void f(Value*));
1211 };
1214 LEAF(NewTypeArray, NewArray)
1215 private:
1216 BasicType _elt_type;
1218 public:
1219 // creation
1220 NewTypeArray(Value length, BasicType elt_type) : NewArray(length, NULL), _elt_type(elt_type) {}
1222 // accessors
1223 BasicType elt_type() const { return _elt_type; }
1224 ciType* exact_type() const;
1225 };
1228 LEAF(NewObjectArray, NewArray)
1229 private:
1230 ciKlass* _klass;
1232 public:
1233 // creation
1234 NewObjectArray(ciKlass* klass, Value length, ValueStack* state_before) : NewArray(length, state_before), _klass(klass) {}
1236 // accessors
1237 ciKlass* klass() const { return _klass; }
1238 ciType* exact_type() const;
1239 };
1242 LEAF(NewMultiArray, NewArray)
1243 private:
1244 ciKlass* _klass;
1245 Values* _dims;
1247 public:
1248 // creation
1249 NewMultiArray(ciKlass* klass, Values* dims, ValueStack* state_before) : NewArray(NULL, state_before), _klass(klass), _dims(dims) {
1250 ASSERT_VALUES
1251 }
1253 // accessors
1254 ciKlass* klass() const { return _klass; }
1255 Values* dims() const { return _dims; }
1256 int rank() const { return dims()->length(); }
1258 // generic
1259 virtual void input_values_do(void f(Value*)) {
1260 // NOTE: we do not call NewArray::input_values_do since "length"
1261 // is meaningless for a multi-dimensional array; passing the
1262 // zeroth element down to NewArray as its length is a bad idea
1263 // since there will be a copy in the "dims" array which doesn't
1264 // get updated, and the value must not be traversed twice. Was bug
1265 // - kbr 4/10/2001
1266 StateSplit::input_values_do(f);
1267 for (int i = 0; i < _dims->length(); i++) f(_dims->adr_at(i));
1268 }
1269 };
1272 BASE(TypeCheck, StateSplit)
1273 private:
1274 ciKlass* _klass;
1275 Value _obj;
1276 ValueStack* _state_before;
1278 public:
1279 // creation
1280 TypeCheck(ciKlass* klass, Value obj, ValueType* type, ValueStack* state_before) : StateSplit(type), _klass(klass), _obj(obj), _state_before(state_before) {
1281 ASSERT_VALUES
1282 set_direct_compare(false);
1283 }
1285 // accessors
1286 ValueStack* state_before() const { return _state_before; }
1287 ciKlass* klass() const { return _klass; }
1288 Value obj() const { return _obj; }
1289 bool is_loaded() const { return klass() != NULL; }
1290 bool direct_compare() const { return check_flag(DirectCompareFlag); }
1292 // manipulation
1293 void set_direct_compare(bool flag) { set_flag(DirectCompareFlag, flag); }
1295 // generic
1296 virtual bool can_trap() const { return true; }
1297 virtual void input_values_do(void f(Value*)) { StateSplit::input_values_do(f); f(&_obj); }
1298 virtual void other_values_do(void f(Value*));
1299 };
1302 LEAF(CheckCast, TypeCheck)
1303 private:
1304 ciMethod* _profiled_method;
1305 int _profiled_bci;
1307 public:
1308 // creation
1309 CheckCast(ciKlass* klass, Value obj, ValueStack* state_before)
1310 : TypeCheck(klass, obj, objectType, state_before)
1311 , _profiled_method(NULL)
1312 , _profiled_bci(0) {}
1314 void set_incompatible_class_change_check() {
1315 set_flag(ThrowIncompatibleClassChangeErrorFlag, true);
1316 }
1317 bool is_incompatible_class_change_check() const {
1318 return check_flag(ThrowIncompatibleClassChangeErrorFlag);
1319 }
1321 // Helpers for methodDataOop profiling
1322 void set_should_profile(bool value) { set_flag(ProfileMDOFlag, value); }
1323 void set_profiled_method(ciMethod* method) { _profiled_method = method; }
1324 void set_profiled_bci(int bci) { _profiled_bci = bci; }
1325 bool should_profile() const { return check_flag(ProfileMDOFlag); }
1326 ciMethod* profiled_method() const { return _profiled_method; }
1327 int profiled_bci() const { return _profiled_bci; }
1329 ciType* declared_type() const;
1330 ciType* exact_type() const;
1332 };
1335 LEAF(InstanceOf, TypeCheck)
1336 public:
1337 // creation
1338 InstanceOf(ciKlass* klass, Value obj, ValueStack* state_before) : TypeCheck(klass, obj, intType, state_before) {}
1339 };
1342 BASE(AccessMonitor, StateSplit)
1343 private:
1344 Value _obj;
1345 int _monitor_no;
1347 public:
1348 // creation
1349 AccessMonitor(Value obj, int monitor_no)
1350 : StateSplit(illegalType)
1351 , _obj(obj)
1352 , _monitor_no(monitor_no)
1353 {
1354 set_needs_null_check(true);
1355 ASSERT_VALUES
1356 }
1358 // accessors
1359 Value obj() const { return _obj; }
1360 int monitor_no() const { return _monitor_no; }
1362 // generic
1363 virtual void input_values_do(void f(Value*)) { StateSplit::input_values_do(f); f(&_obj); }
1364 };
1367 LEAF(MonitorEnter, AccessMonitor)
1368 private:
1369 ValueStack* _lock_stack_before;
1371 public:
1372 // creation
1373 MonitorEnter(Value obj, int monitor_no, ValueStack* lock_stack_before)
1374 : AccessMonitor(obj, monitor_no)
1375 , _lock_stack_before(lock_stack_before)
1376 {
1377 ASSERT_VALUES
1378 }
1380 // accessors
1381 ValueStack* lock_stack_before() const { return _lock_stack_before; }
1382 virtual void state_values_do(void f(Value*));
1384 // generic
1385 virtual bool can_trap() const { return true; }
1386 };
1389 LEAF(MonitorExit, AccessMonitor)
1390 public:
1391 // creation
1392 MonitorExit(Value obj, int monitor_no) : AccessMonitor(obj, monitor_no) {}
1393 };
1396 LEAF(Intrinsic, StateSplit)
1397 private:
1398 vmIntrinsics::ID _id;
1399 Values* _args;
1400 ValueStack* _lock_stack;
1401 Value _recv;
1403 public:
1404 // preserves_state can be set to true for Intrinsics
1405 // which are guaranteed to preserve register state across any slow
1406 // cases; setting it to true does not mean that the Intrinsic can
1407 // not trap, only that if we continue execution in the same basic
1408 // block after the Intrinsic, all of the registers are intact. This
1409 // allows load elimination and common expression elimination to be
1410 // performed across the Intrinsic. The default value is false.
1411 Intrinsic(ValueType* type,
1412 vmIntrinsics::ID id,
1413 Values* args,
1414 bool has_receiver,
1415 ValueStack* lock_stack,
1416 bool preserves_state,
1417 bool cantrap = true)
1418 : StateSplit(type)
1419 , _id(id)
1420 , _args(args)
1421 , _lock_stack(lock_stack)
1422 , _recv(NULL)
1423 {
1424 assert(args != NULL, "args must exist");
1425 ASSERT_VALUES
1426 set_flag(PreservesStateFlag, preserves_state);
1427 set_flag(CanTrapFlag, cantrap);
1428 if (has_receiver) {
1429 _recv = argument_at(0);
1430 }
1431 set_needs_null_check(has_receiver);
1433 // some intrinsics can't trap, so don't force them to be pinned
1434 if (!can_trap()) {
1435 unpin(PinStateSplitConstructor);
1436 }
1437 }
1439 // accessors
1440 vmIntrinsics::ID id() const { return _id; }
1441 int number_of_arguments() const { return _args->length(); }
1442 Value argument_at(int i) const { return _args->at(i); }
1443 ValueStack* lock_stack() const { return _lock_stack; }
1445 bool has_receiver() const { return (_recv != NULL); }
1446 Value receiver() const { assert(has_receiver(), "must have receiver"); return _recv; }
1447 bool preserves_state() const { return check_flag(PreservesStateFlag); }
1449 // generic
1450 virtual bool can_trap() const { return check_flag(CanTrapFlag); }
1451 virtual void input_values_do(void f(Value*)) {
1452 StateSplit::input_values_do(f);
1453 for (int i = 0; i < _args->length(); i++) f(_args->adr_at(i));
1454 }
1455 virtual void state_values_do(void f(Value*));
1457 };
1460 class LIR_List;
1462 LEAF(BlockBegin, StateSplit)
1463 private:
1464 static int _next_block_id; // the block counter
1466 int _block_id; // the unique block id
1467 int _depth_first_number; // number of this block in a depth-first ordering
1468 int _linear_scan_number; // number of this block in linear-scan ordering
1469 int _loop_depth; // the loop nesting level of this block
1470 int _loop_index; // number of the innermost loop of this block
1471 int _flags; // the flags associated with this block
1473 // fields used by BlockListBuilder
1474 int _total_preds; // number of predecessors found by BlockListBuilder
1475 BitMap _stores_to_locals; // bit is set when a local variable is stored in the block
1477 // SSA specific fields: (factor out later)
1478 BlockList _successors; // the successors of this block
1479 BlockList _predecessors; // the predecessors of this block
1480 BlockBegin* _dominator; // the dominator of this block
1481 // SSA specific ends
1482 BlockEnd* _end; // the last instruction of this block
1483 BlockList _exception_handlers; // the exception handlers potentially invoked by this block
1484 ValueStackStack* _exception_states; // only for xhandler entries: states of all instructions that have an edge to this xhandler
1485 int _exception_handler_pco; // if this block is the start of an exception handler,
1486 // this records the PC offset in the assembly code of the
1487 // first instruction in this block
1488 Label _label; // the label associated with this block
1489 LIR_List* _lir; // the low level intermediate representation for this block
1491 BitMap _live_in; // set of live LIR_Opr registers at entry to this block
1492 BitMap _live_out; // set of live LIR_Opr registers at exit from this block
1493 BitMap _live_gen; // set of registers used before any redefinition in this block
1494 BitMap _live_kill; // set of registers defined in this block
1496 BitMap _fpu_register_usage;
1497 intArray* _fpu_stack_state; // For x86 FPU code generation with UseLinearScan
1498 int _first_lir_instruction_id; // ID of first LIR instruction in this block
1499 int _last_lir_instruction_id; // ID of last LIR instruction in this block
1501 void iterate_preorder (boolArray& mark, BlockClosure* closure);
1502 void iterate_postorder(boolArray& mark, BlockClosure* closure);
1504 friend class SuxAndWeightAdjuster;
1506 public:
1507 // initialization/counting
1508 static void initialize() { _next_block_id = 0; }
1509 static int number_of_blocks() { return _next_block_id; }
1511 // creation
1512 BlockBegin(int bci)
1513 : StateSplit(illegalType)
1514 , _block_id(_next_block_id++)
1515 , _depth_first_number(-1)
1516 , _linear_scan_number(-1)
1517 , _loop_depth(0)
1518 , _flags(0)
1519 , _dominator(NULL)
1520 , _end(NULL)
1521 , _predecessors(2)
1522 , _successors(2)
1523 , _exception_handlers(1)
1524 , _exception_states(NULL)
1525 , _exception_handler_pco(-1)
1526 , _lir(NULL)
1527 , _loop_index(-1)
1528 , _live_in()
1529 , _live_out()
1530 , _live_gen()
1531 , _live_kill()
1532 , _fpu_register_usage()
1533 , _fpu_stack_state(NULL)
1534 , _first_lir_instruction_id(-1)
1535 , _last_lir_instruction_id(-1)
1536 , _total_preds(0)
1537 , _stores_to_locals()
1538 {
1539 set_bci(bci);
1540 }
1542 // accessors
1543 int block_id() const { return _block_id; }
1544 BlockList* successors() { return &_successors; }
1545 BlockBegin* dominator() const { return _dominator; }
1546 int loop_depth() const { return _loop_depth; }
1547 int depth_first_number() const { return _depth_first_number; }
1548 int linear_scan_number() const { return _linear_scan_number; }
1549 BlockEnd* end() const { return _end; }
1550 Label* label() { return &_label; }
1551 LIR_List* lir() const { return _lir; }
1552 int exception_handler_pco() const { return _exception_handler_pco; }
1553 BitMap& live_in() { return _live_in; }
1554 BitMap& live_out() { return _live_out; }
1555 BitMap& live_gen() { return _live_gen; }
1556 BitMap& live_kill() { return _live_kill; }
1557 BitMap& fpu_register_usage() { return _fpu_register_usage; }
1558 intArray* fpu_stack_state() const { return _fpu_stack_state; }
1559 int first_lir_instruction_id() const { return _first_lir_instruction_id; }
1560 int last_lir_instruction_id() const { return _last_lir_instruction_id; }
1561 int total_preds() const { return _total_preds; }
1562 BitMap& stores_to_locals() { return _stores_to_locals; }
1564 // manipulation
1565 void set_bci(int bci) { Instruction::set_bci(bci); }
1566 void set_dominator(BlockBegin* dom) { _dominator = dom; }
1567 void set_loop_depth(int d) { _loop_depth = d; }
1568 void set_depth_first_number(int dfn) { _depth_first_number = dfn; }
1569 void set_linear_scan_number(int lsn) { _linear_scan_number = lsn; }
1570 void set_end(BlockEnd* end);
1571 void disconnect_from_graph();
1572 static void disconnect_edge(BlockBegin* from, BlockBegin* to);
1573 BlockBegin* insert_block_between(BlockBegin* sux);
1574 void substitute_sux(BlockBegin* old_sux, BlockBegin* new_sux);
1575 void set_lir(LIR_List* lir) { _lir = lir; }
1576 void set_exception_handler_pco(int pco) { _exception_handler_pco = pco; }
1577 void set_live_in (BitMap map) { _live_in = map; }
1578 void set_live_out (BitMap map) { _live_out = map; }
1579 void set_live_gen (BitMap map) { _live_gen = map; }
1580 void set_live_kill (BitMap map) { _live_kill = map; }
1581 void set_fpu_register_usage(BitMap map) { _fpu_register_usage = map; }
1582 void set_fpu_stack_state(intArray* state) { _fpu_stack_state = state; }
1583 void set_first_lir_instruction_id(int id) { _first_lir_instruction_id = id; }
1584 void set_last_lir_instruction_id(int id) { _last_lir_instruction_id = id; }
1585 void increment_total_preds(int n = 1) { _total_preds += n; }
1586 void init_stores_to_locals(int locals_count) { _stores_to_locals = BitMap(locals_count); _stores_to_locals.clear(); }
1588 // generic
1589 virtual void state_values_do(void f(Value*));
1591 // successors and predecessors
1592 int number_of_sux() const;
1593 BlockBegin* sux_at(int i) const;
1594 void add_successor(BlockBegin* sux);
1595 void remove_successor(BlockBegin* pred);
1596 bool is_successor(BlockBegin* sux) const { return _successors.contains(sux); }
1598 void add_predecessor(BlockBegin* pred);
1599 void remove_predecessor(BlockBegin* pred);
1600 bool is_predecessor(BlockBegin* pred) const { return _predecessors.contains(pred); }
1601 int number_of_preds() const { return _predecessors.length(); }
1602 BlockBegin* pred_at(int i) const { return _predecessors[i]; }
1604 // exception handlers potentially invoked by this block
1605 void add_exception_handler(BlockBegin* b);
1606 bool is_exception_handler(BlockBegin* b) const { return _exception_handlers.contains(b); }
1607 int number_of_exception_handlers() const { return _exception_handlers.length(); }
1608 BlockBegin* exception_handler_at(int i) const { return _exception_handlers.at(i); }
1610 // states of the instructions that have an edge to this exception handler
1611 int number_of_exception_states() { assert(is_set(exception_entry_flag), "only for xhandlers"); return _exception_states == NULL ? 0 : _exception_states->length(); }
1612 ValueStack* exception_state_at(int idx) const { assert(is_set(exception_entry_flag), "only for xhandlers"); return _exception_states->at(idx); }
1613 int add_exception_state(ValueStack* state);
1615 // flags
1616 enum Flag {
1617 no_flag = 0,
1618 std_entry_flag = 1 << 0,
1619 osr_entry_flag = 1 << 1,
1620 exception_entry_flag = 1 << 2,
1621 subroutine_entry_flag = 1 << 3,
1622 backward_branch_target_flag = 1 << 4,
1623 is_on_work_list_flag = 1 << 5,
1624 was_visited_flag = 1 << 6,
1625 default_exception_handler_flag = 1 << 8, // identify block which represents the default exception handler
1626 parser_loop_header_flag = 1 << 9, // set by parser to identify blocks where phi functions can not be created on demand
1627 critical_edge_split_flag = 1 << 10, // set for all blocks that are introduced when critical edges are split
1628 linear_scan_loop_header_flag = 1 << 11, // set during loop-detection for LinearScan
1629 linear_scan_loop_end_flag = 1 << 12 // set during loop-detection for LinearScan
1630 };
1632 void set(Flag f) { _flags |= f; }
1633 void clear(Flag f) { _flags &= ~f; }
1634 bool is_set(Flag f) const { return (_flags & f) != 0; }
1635 bool is_entry_block() const {
1636 const int entry_mask = std_entry_flag | osr_entry_flag | exception_entry_flag;
1637 return (_flags & entry_mask) != 0;
1638 }
1640 // iteration
1641 void iterate_preorder (BlockClosure* closure);
1642 void iterate_postorder (BlockClosure* closure);
1644 void block_values_do(void f(Value*));
1646 // loops
1647 void set_loop_index(int ix) { _loop_index = ix; }
1648 int loop_index() const { return _loop_index; }
1650 // merging
1651 bool try_merge(ValueStack* state); // try to merge states at block begin
1652 void merge(ValueStack* state) { bool b = try_merge(state); assert(b, "merge failed"); }
1654 // debugging
1655 void print_block() PRODUCT_RETURN;
1656 void print_block(InstructionPrinter& ip, bool live_only = false) PRODUCT_RETURN;
1657 };
1660 BASE(BlockEnd, StateSplit)
1661 private:
1662 BlockBegin* _begin;
1663 BlockList* _sux;
1664 ValueStack* _state_before;
1666 protected:
1667 BlockList* sux() const { return _sux; }
1669 void set_sux(BlockList* sux) {
1670 #ifdef ASSERT
1671 assert(sux != NULL, "sux must exist");
1672 for (int i = sux->length() - 1; i >= 0; i--) assert(sux->at(i) != NULL, "sux must exist");
1673 #endif
1674 _sux = sux;
1675 }
1677 public:
1678 // creation
1679 BlockEnd(ValueType* type, ValueStack* state_before, bool is_safepoint)
1680 : StateSplit(type)
1681 , _begin(NULL)
1682 , _sux(NULL)
1683 , _state_before(state_before) {
1684 set_flag(IsSafepointFlag, is_safepoint);
1685 }
1687 // accessors
1688 ValueStack* state_before() const { return _state_before; }
1689 bool is_safepoint() const { return check_flag(IsSafepointFlag); }
1690 BlockBegin* begin() const { return _begin; }
1692 // manipulation
1693 void set_begin(BlockBegin* begin);
1695 // generic
1696 virtual void other_values_do(void f(Value*));
1698 // successors
1699 int number_of_sux() const { return _sux != NULL ? _sux->length() : 0; }
1700 BlockBegin* sux_at(int i) const { return _sux->at(i); }
1701 BlockBegin* default_sux() const { return sux_at(number_of_sux() - 1); }
1702 BlockBegin** addr_sux_at(int i) const { return _sux->adr_at(i); }
1703 int sux_index(BlockBegin* sux) const { return _sux->find(sux); }
1704 void substitute_sux(BlockBegin* old_sux, BlockBegin* new_sux);
1705 };
1708 LEAF(Goto, BlockEnd)
1709 public:
1710 // creation
1711 Goto(BlockBegin* sux, ValueStack* state_before, bool is_safepoint = false) : BlockEnd(illegalType, state_before, is_safepoint) {
1712 BlockList* s = new BlockList(1);
1713 s->append(sux);
1714 set_sux(s);
1715 }
1717 Goto(BlockBegin* sux, bool is_safepoint) : BlockEnd(illegalType, NULL, is_safepoint) {
1718 BlockList* s = new BlockList(1);
1719 s->append(sux);
1720 set_sux(s);
1721 }
1723 };
1726 LEAF(If, BlockEnd)
1727 private:
1728 Value _x;
1729 Condition _cond;
1730 Value _y;
1731 ciMethod* _profiled_method;
1732 int _profiled_bci; // Canonicalizer may alter bci of If node
1733 public:
1734 // creation
1735 // unordered_is_true is valid for float/double compares only
1736 If(Value x, Condition cond, bool unordered_is_true, Value y, BlockBegin* tsux, BlockBegin* fsux, ValueStack* state_before, bool is_safepoint)
1737 : BlockEnd(illegalType, state_before, is_safepoint)
1738 , _x(x)
1739 , _cond(cond)
1740 , _y(y)
1741 , _profiled_method(NULL)
1742 , _profiled_bci(0)
1743 {
1744 ASSERT_VALUES
1745 set_flag(UnorderedIsTrueFlag, unordered_is_true);
1746 assert(x->type()->tag() == y->type()->tag(), "types must match");
1747 BlockList* s = new BlockList(2);
1748 s->append(tsux);
1749 s->append(fsux);
1750 set_sux(s);
1751 }
1753 // accessors
1754 Value x() const { return _x; }
1755 Condition cond() const { return _cond; }
1756 bool unordered_is_true() const { return check_flag(UnorderedIsTrueFlag); }
1757 Value y() const { return _y; }
1758 BlockBegin* sux_for(bool is_true) const { return sux_at(is_true ? 0 : 1); }
1759 BlockBegin* tsux() const { return sux_for(true); }
1760 BlockBegin* fsux() const { return sux_for(false); }
1761 BlockBegin* usux() const { return sux_for(unordered_is_true()); }
1762 bool should_profile() const { return check_flag(ProfileMDOFlag); }
1763 ciMethod* profiled_method() const { return _profiled_method; } // set only for profiled branches
1764 int profiled_bci() const { return _profiled_bci; } // set only for profiled branches
1766 // manipulation
1767 void swap_operands() {
1768 Value t = _x; _x = _y; _y = t;
1769 _cond = mirror(_cond);
1770 }
1772 void swap_sux() {
1773 assert(number_of_sux() == 2, "wrong number of successors");
1774 BlockList* s = sux();
1775 BlockBegin* t = s->at(0); s->at_put(0, s->at(1)); s->at_put(1, t);
1776 _cond = negate(_cond);
1777 set_flag(UnorderedIsTrueFlag, !check_flag(UnorderedIsTrueFlag));
1778 }
1780 void set_should_profile(bool value) { set_flag(ProfileMDOFlag, value); }
1781 void set_profiled_method(ciMethod* method) { _profiled_method = method; }
1782 void set_profiled_bci(int bci) { _profiled_bci = bci; }
1784 // generic
1785 virtual void input_values_do(void f(Value*)) { BlockEnd::input_values_do(f); f(&_x); f(&_y); }
1786 };
1789 LEAF(IfInstanceOf, BlockEnd)
1790 private:
1791 ciKlass* _klass;
1792 Value _obj;
1793 bool _test_is_instance; // jump if instance
1794 int _instanceof_bci;
1796 public:
1797 IfInstanceOf(ciKlass* klass, Value obj, bool test_is_instance, int instanceof_bci, BlockBegin* tsux, BlockBegin* fsux)
1798 : BlockEnd(illegalType, NULL, false) // temporary set to false
1799 , _klass(klass)
1800 , _obj(obj)
1801 , _test_is_instance(test_is_instance)
1802 , _instanceof_bci(instanceof_bci)
1803 {
1804 ASSERT_VALUES
1805 assert(instanceof_bci >= 0, "illegal bci");
1806 BlockList* s = new BlockList(2);
1807 s->append(tsux);
1808 s->append(fsux);
1809 set_sux(s);
1810 }
1812 // accessors
1813 //
1814 // Note 1: If test_is_instance() is true, IfInstanceOf tests if obj *is* an
1815 // instance of klass; otherwise it tests if it is *not* and instance
1816 // of klass.
1817 //
1818 // Note 2: IfInstanceOf instructions are created by combining an InstanceOf
1819 // and an If instruction. The IfInstanceOf bci() corresponds to the
1820 // bci that the If would have had; the (this->) instanceof_bci() is
1821 // the bci of the original InstanceOf instruction.
1822 ciKlass* klass() const { return _klass; }
1823 Value obj() const { return _obj; }
1824 int instanceof_bci() const { return _instanceof_bci; }
1825 bool test_is_instance() const { return _test_is_instance; }
1826 BlockBegin* sux_for(bool is_true) const { return sux_at(is_true ? 0 : 1); }
1827 BlockBegin* tsux() const { return sux_for(true); }
1828 BlockBegin* fsux() const { return sux_for(false); }
1830 // manipulation
1831 void swap_sux() {
1832 assert(number_of_sux() == 2, "wrong number of successors");
1833 BlockList* s = sux();
1834 BlockBegin* t = s->at(0); s->at_put(0, s->at(1)); s->at_put(1, t);
1835 _test_is_instance = !_test_is_instance;
1836 }
1838 // generic
1839 virtual void input_values_do(void f(Value*)) { BlockEnd::input_values_do(f); f(&_obj); }
1840 };
1843 BASE(Switch, BlockEnd)
1844 private:
1845 Value _tag;
1847 public:
1848 // creation
1849 Switch(Value tag, BlockList* sux, ValueStack* state_before, bool is_safepoint)
1850 : BlockEnd(illegalType, state_before, is_safepoint)
1851 , _tag(tag) {
1852 ASSERT_VALUES
1853 set_sux(sux);
1854 }
1856 // accessors
1857 Value tag() const { return _tag; }
1858 int length() const { return number_of_sux() - 1; }
1860 // generic
1861 virtual void input_values_do(void f(Value*)) { BlockEnd::input_values_do(f); f(&_tag); }
1862 };
1865 LEAF(TableSwitch, Switch)
1866 private:
1867 int _lo_key;
1869 public:
1870 // creation
1871 TableSwitch(Value tag, BlockList* sux, int lo_key, ValueStack* state_before, bool is_safepoint)
1872 : Switch(tag, sux, state_before, is_safepoint)
1873 , _lo_key(lo_key) {}
1875 // accessors
1876 int lo_key() const { return _lo_key; }
1877 int hi_key() const { return _lo_key + length() - 1; }
1878 };
1881 LEAF(LookupSwitch, Switch)
1882 private:
1883 intArray* _keys;
1885 public:
1886 // creation
1887 LookupSwitch(Value tag, BlockList* sux, intArray* keys, ValueStack* state_before, bool is_safepoint)
1888 : Switch(tag, sux, state_before, is_safepoint)
1889 , _keys(keys) {
1890 assert(keys != NULL, "keys must exist");
1891 assert(keys->length() == length(), "sux & keys have incompatible lengths");
1892 }
1894 // accessors
1895 int key_at(int i) const { return _keys->at(i); }
1896 };
1899 LEAF(Return, BlockEnd)
1900 private:
1901 Value _result;
1903 public:
1904 // creation
1905 Return(Value result) :
1906 BlockEnd(result == NULL ? voidType : result->type()->base(), NULL, true),
1907 _result(result) {}
1909 // accessors
1910 Value result() const { return _result; }
1911 bool has_result() const { return result() != NULL; }
1913 // generic
1914 virtual void input_values_do(void f(Value*)) {
1915 BlockEnd::input_values_do(f);
1916 if (has_result()) f(&_result);
1917 }
1918 };
1921 LEAF(Throw, BlockEnd)
1922 private:
1923 Value _exception;
1925 public:
1926 // creation
1927 Throw(Value exception, ValueStack* state_before) : BlockEnd(illegalType, state_before, true), _exception(exception) {
1928 ASSERT_VALUES
1929 }
1931 // accessors
1932 Value exception() const { return _exception; }
1934 // generic
1935 virtual bool can_trap() const { return true; }
1936 virtual void input_values_do(void f(Value*)) { BlockEnd::input_values_do(f); f(&_exception); }
1937 virtual void state_values_do(void f(Value*));
1938 };
1941 LEAF(Base, BlockEnd)
1942 public:
1943 // creation
1944 Base(BlockBegin* std_entry, BlockBegin* osr_entry) : BlockEnd(illegalType, NULL, false) {
1945 assert(std_entry->is_set(BlockBegin::std_entry_flag), "std entry must be flagged");
1946 assert(osr_entry == NULL || osr_entry->is_set(BlockBegin::osr_entry_flag), "osr entry must be flagged");
1947 BlockList* s = new BlockList(2);
1948 if (osr_entry != NULL) s->append(osr_entry);
1949 s->append(std_entry); // must be default sux!
1950 set_sux(s);
1951 }
1953 // accessors
1954 BlockBegin* std_entry() const { return default_sux(); }
1955 BlockBegin* osr_entry() const { return number_of_sux() < 2 ? NULL : sux_at(0); }
1956 };
1959 LEAF(OsrEntry, Instruction)
1960 public:
1961 // creation
1962 #ifdef _LP64
1963 OsrEntry() : Instruction(longType, false) { pin(); }
1964 #else
1965 OsrEntry() : Instruction(intType, false) { pin(); }
1966 #endif
1968 // generic
1969 virtual void input_values_do(void f(Value*)) { }
1970 };
1973 // Models the incoming exception at a catch site
1974 LEAF(ExceptionObject, Instruction)
1975 public:
1976 // creation
1977 ExceptionObject() : Instruction(objectType, false) {
1978 pin();
1979 }
1981 // generic
1982 virtual void input_values_do(void f(Value*)) { }
1983 };
1986 // Models needed rounding for floating-point values on Intel.
1987 // Currently only used to represent rounding of double-precision
1988 // values stored into local variables, but could be used to model
1989 // intermediate rounding of single-precision values as well.
1990 LEAF(RoundFP, Instruction)
1991 private:
1992 Value _input; // floating-point value to be rounded
1994 public:
1995 RoundFP(Value input)
1996 : Instruction(input->type()) // Note: should not be used for constants
1997 , _input(input)
1998 {
1999 ASSERT_VALUES
2000 }
2002 // accessors
2003 Value input() const { return _input; }
2005 // generic
2006 virtual void input_values_do(void f(Value*)) { f(&_input); }
2007 };
2010 BASE(UnsafeOp, Instruction)
2011 private:
2012 BasicType _basic_type; // ValueType can not express byte-sized integers
2014 protected:
2015 // creation
2016 UnsafeOp(BasicType basic_type, bool is_put)
2017 : Instruction(is_put ? voidType : as_ValueType(basic_type))
2018 , _basic_type(basic_type)
2019 {
2020 //Note: Unsafe ops are not not guaranteed to throw NPE.
2021 // Convservatively, Unsafe operations must be pinned though we could be
2022 // looser about this if we wanted to..
2023 pin();
2024 }
2026 public:
2027 // accessors
2028 BasicType basic_type() { return _basic_type; }
2030 // generic
2031 virtual void input_values_do(void f(Value*)) { }
2032 virtual void other_values_do(void f(Value*)) { }
2033 };
2036 BASE(UnsafeRawOp, UnsafeOp)
2037 private:
2038 Value _base; // Base address (a Java long)
2039 Value _index; // Index if computed by optimizer; initialized to NULL
2040 int _log2_scale; // Scale factor: 0, 1, 2, or 3.
2041 // Indicates log2 of number of bytes (1, 2, 4, or 8)
2042 // to scale index by.
2044 protected:
2045 UnsafeRawOp(BasicType basic_type, Value addr, bool is_put)
2046 : UnsafeOp(basic_type, is_put)
2047 , _base(addr)
2048 , _index(NULL)
2049 , _log2_scale(0)
2050 {
2051 // Can not use ASSERT_VALUES because index may be NULL
2052 assert(addr != NULL && addr->type()->is_long(), "just checking");
2053 }
2055 UnsafeRawOp(BasicType basic_type, Value base, Value index, int log2_scale, bool is_put)
2056 : UnsafeOp(basic_type, is_put)
2057 , _base(base)
2058 , _index(index)
2059 , _log2_scale(log2_scale)
2060 {
2061 }
2063 public:
2064 // accessors
2065 Value base() { return _base; }
2066 Value index() { return _index; }
2067 bool has_index() { return (_index != NULL); }
2068 int log2_scale() { return _log2_scale; }
2070 // setters
2071 void set_base (Value base) { _base = base; }
2072 void set_index(Value index) { _index = index; }
2073 void set_log2_scale(int log2_scale) { _log2_scale = log2_scale; }
2075 // generic
2076 virtual void input_values_do(void f(Value*)) { UnsafeOp::input_values_do(f);
2077 f(&_base);
2078 if (has_index()) f(&_index); }
2079 };
2082 LEAF(UnsafeGetRaw, UnsafeRawOp)
2083 private:
2084 bool _may_be_unaligned; // For OSREntry
2086 public:
2087 UnsafeGetRaw(BasicType basic_type, Value addr, bool may_be_unaligned)
2088 : UnsafeRawOp(basic_type, addr, false) {
2089 _may_be_unaligned = may_be_unaligned;
2090 }
2092 UnsafeGetRaw(BasicType basic_type, Value base, Value index, int log2_scale, bool may_be_unaligned)
2093 : UnsafeRawOp(basic_type, base, index, log2_scale, false) {
2094 _may_be_unaligned = may_be_unaligned;
2095 }
2097 bool may_be_unaligned() { return _may_be_unaligned; }
2098 };
2101 LEAF(UnsafePutRaw, UnsafeRawOp)
2102 private:
2103 Value _value; // Value to be stored
2105 public:
2106 UnsafePutRaw(BasicType basic_type, Value addr, Value value)
2107 : UnsafeRawOp(basic_type, addr, true)
2108 , _value(value)
2109 {
2110 assert(value != NULL, "just checking");
2111 ASSERT_VALUES
2112 }
2114 UnsafePutRaw(BasicType basic_type, Value base, Value index, int log2_scale, Value value)
2115 : UnsafeRawOp(basic_type, base, index, log2_scale, true)
2116 , _value(value)
2117 {
2118 assert(value != NULL, "just checking");
2119 ASSERT_VALUES
2120 }
2122 // accessors
2123 Value value() { return _value; }
2125 // generic
2126 virtual void input_values_do(void f(Value*)) { UnsafeRawOp::input_values_do(f);
2127 f(&_value); }
2128 };
2131 BASE(UnsafeObjectOp, UnsafeOp)
2132 private:
2133 Value _object; // Object to be fetched from or mutated
2134 Value _offset; // Offset within object
2135 bool _is_volatile; // true if volatile - dl/JSR166
2136 public:
2137 UnsafeObjectOp(BasicType basic_type, Value object, Value offset, bool is_put, bool is_volatile)
2138 : UnsafeOp(basic_type, is_put), _object(object), _offset(offset), _is_volatile(is_volatile)
2139 {
2140 }
2142 // accessors
2143 Value object() { return _object; }
2144 Value offset() { return _offset; }
2145 bool is_volatile() { return _is_volatile; }
2146 // generic
2147 virtual void input_values_do(void f(Value*)) { UnsafeOp::input_values_do(f);
2148 f(&_object);
2149 f(&_offset); }
2150 };
2153 LEAF(UnsafeGetObject, UnsafeObjectOp)
2154 public:
2155 UnsafeGetObject(BasicType basic_type, Value object, Value offset, bool is_volatile)
2156 : UnsafeObjectOp(basic_type, object, offset, false, is_volatile)
2157 {
2158 ASSERT_VALUES
2159 }
2160 };
2163 LEAF(UnsafePutObject, UnsafeObjectOp)
2164 private:
2165 Value _value; // Value to be stored
2166 public:
2167 UnsafePutObject(BasicType basic_type, Value object, Value offset, Value value, bool is_volatile)
2168 : UnsafeObjectOp(basic_type, object, offset, true, is_volatile)
2169 , _value(value)
2170 {
2171 ASSERT_VALUES
2172 }
2174 // accessors
2175 Value value() { return _value; }
2177 // generic
2178 virtual void input_values_do(void f(Value*)) { UnsafeObjectOp::input_values_do(f);
2179 f(&_value); }
2180 };
2183 BASE(UnsafePrefetch, UnsafeObjectOp)
2184 public:
2185 UnsafePrefetch(Value object, Value offset)
2186 : UnsafeObjectOp(T_VOID, object, offset, false, false)
2187 {
2188 }
2189 };
2192 LEAF(UnsafePrefetchRead, UnsafePrefetch)
2193 public:
2194 UnsafePrefetchRead(Value object, Value offset)
2195 : UnsafePrefetch(object, offset)
2196 {
2197 ASSERT_VALUES
2198 }
2199 };
2202 LEAF(UnsafePrefetchWrite, UnsafePrefetch)
2203 public:
2204 UnsafePrefetchWrite(Value object, Value offset)
2205 : UnsafePrefetch(object, offset)
2206 {
2207 ASSERT_VALUES
2208 }
2209 };
2212 LEAF(ProfileCall, Instruction)
2213 private:
2214 ciMethod* _method;
2215 int _bci_of_invoke;
2216 Value _recv;
2217 ciKlass* _known_holder;
2219 public:
2220 ProfileCall(ciMethod* method, int bci, Value recv, ciKlass* known_holder)
2221 : Instruction(voidType)
2222 , _method(method)
2223 , _bci_of_invoke(bci)
2224 , _recv(recv)
2225 , _known_holder(known_holder)
2226 {
2227 // The ProfileCall has side-effects and must occur precisely where located
2228 pin();
2229 }
2231 ciMethod* method() { return _method; }
2232 int bci_of_invoke() { return _bci_of_invoke; }
2233 Value recv() { return _recv; }
2234 ciKlass* known_holder() { return _known_holder; }
2236 virtual void input_values_do(void f(Value*)) { if (_recv != NULL) f(&_recv); }
2237 };
2240 //
2241 // Simple node representing a counter update generally used for updating MDOs
2242 //
2243 LEAF(ProfileCounter, Instruction)
2244 private:
2245 Value _mdo;
2246 int _offset;
2247 int _increment;
2249 public:
2250 ProfileCounter(Value mdo, int offset, int increment = 1)
2251 : Instruction(voidType)
2252 , _mdo(mdo)
2253 , _offset(offset)
2254 , _increment(increment)
2255 {
2256 // The ProfileCounter has side-effects and must occur precisely where located
2257 pin();
2258 }
2260 Value mdo() { return _mdo; }
2261 int offset() { return _offset; }
2262 int increment() { return _increment; }
2264 virtual void input_values_do(void f(Value*)) { f(&_mdo); }
2265 };
2268 class BlockPair: public CompilationResourceObj {
2269 private:
2270 BlockBegin* _from;
2271 BlockBegin* _to;
2272 public:
2273 BlockPair(BlockBegin* from, BlockBegin* to): _from(from), _to(to) {}
2274 BlockBegin* from() const { return _from; }
2275 BlockBegin* to() const { return _to; }
2276 bool is_same(BlockBegin* from, BlockBegin* to) const { return _from == from && _to == to; }
2277 bool is_same(BlockPair* p) const { return _from == p->from() && _to == p->to(); }
2278 void set_to(BlockBegin* b) { _to = b; }
2279 void set_from(BlockBegin* b) { _from = b; }
2280 };
2283 define_array(BlockPairArray, BlockPair*)
2284 define_stack(BlockPairList, BlockPairArray)
2287 inline int BlockBegin::number_of_sux() const { assert(_end == NULL || _end->number_of_sux() == _successors.length(), "mismatch"); return _successors.length(); }
2288 inline BlockBegin* BlockBegin::sux_at(int i) const { assert(_end == NULL || _end->sux_at(i) == _successors.at(i), "mismatch"); return _successors.at(i); }
2289 inline void BlockBegin::add_successor(BlockBegin* sux) { assert(_end == NULL, "Would create mismatch with successors of BlockEnd"); _successors.append(sux); }
2291 #undef ASSERT_VALUES