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