< prev index next >

src/hotspot/share/c1/c1_Instruction.hpp

Print this page

  53 class   AccessArray;
  54 class     ArrayLength;
  55 class     AccessIndexed;
  56 class       LoadIndexed;
  57 class       StoreIndexed;
  58 class   NegateOp;
  59 class   Op2;
  60 class     ArithmeticOp;
  61 class     ShiftOp;
  62 class     LogicOp;
  63 class     CompareOp;
  64 class     IfOp;
  65 class   Convert;
  66 class   NullCheck;
  67 class   TypeCast;
  68 class   OsrEntry;
  69 class   ExceptionObject;
  70 class   StateSplit;
  71 class     Invoke;
  72 class     NewInstance;

  73 class     NewArray;
  74 class       NewTypeArray;
  75 class       NewObjectArray;
  76 class       NewMultiArray;

  77 class     TypeCheck;
  78 class       CheckCast;
  79 class       InstanceOf;
  80 class     AccessMonitor;
  81 class       MonitorEnter;
  82 class       MonitorExit;
  83 class     Intrinsic;
  84 class     BlockBegin;
  85 class     BlockEnd;
  86 class       Goto;
  87 class       If;
  88 class       Switch;
  89 class         TableSwitch;
  90 class         LookupSwitch;
  91 class       Return;
  92 class       Throw;
  93 class       Base;
  94 class   RoundFP;
  95 class   UnsafeOp;
  96 class     UnsafeGet;
  97 class     UnsafePut;
  98 class     UnsafeGetAndSet;
  99 class   ProfileCall;
 100 class   ProfileReturnType;

 101 class   ProfileInvoke;
 102 class   RuntimeCall;
 103 class   MemBar;
 104 class   RangeCheckPredicate;
 105 #ifdef ASSERT
 106 class   Assert;
 107 #endif
 108 
 109 // A Value is a reference to the instruction creating the value
 110 typedef Instruction* Value;
 111 typedef GrowableArray<Value> Values;
 112 typedef GrowableArray<ValueStack*> ValueStackStack;
 113 
 114 // BlockClosure is the base class for block traversal/iteration.
 115 
 116 class BlockClosure: public CompilationResourceObj {
 117  public:
 118   virtual void block_do(BlockBegin* block)       = 0;
 119 };
 120 

 152  public:
 153   virtual void do_Phi            (Phi*             x) = 0;
 154   virtual void do_Local          (Local*           x) = 0;
 155   virtual void do_Constant       (Constant*        x) = 0;
 156   virtual void do_LoadField      (LoadField*       x) = 0;
 157   virtual void do_StoreField     (StoreField*      x) = 0;
 158   virtual void do_ArrayLength    (ArrayLength*     x) = 0;
 159   virtual void do_LoadIndexed    (LoadIndexed*     x) = 0;
 160   virtual void do_StoreIndexed   (StoreIndexed*    x) = 0;
 161   virtual void do_NegateOp       (NegateOp*        x) = 0;
 162   virtual void do_ArithmeticOp   (ArithmeticOp*    x) = 0;
 163   virtual void do_ShiftOp        (ShiftOp*         x) = 0;
 164   virtual void do_LogicOp        (LogicOp*         x) = 0;
 165   virtual void do_CompareOp      (CompareOp*       x) = 0;
 166   virtual void do_IfOp           (IfOp*            x) = 0;
 167   virtual void do_Convert        (Convert*         x) = 0;
 168   virtual void do_NullCheck      (NullCheck*       x) = 0;
 169   virtual void do_TypeCast       (TypeCast*        x) = 0;
 170   virtual void do_Invoke         (Invoke*          x) = 0;
 171   virtual void do_NewInstance    (NewInstance*     x) = 0;

 172   virtual void do_NewTypeArray   (NewTypeArray*    x) = 0;
 173   virtual void do_NewObjectArray (NewObjectArray*  x) = 0;
 174   virtual void do_NewMultiArray  (NewMultiArray*   x) = 0;

 175   virtual void do_CheckCast      (CheckCast*       x) = 0;
 176   virtual void do_InstanceOf     (InstanceOf*      x) = 0;
 177   virtual void do_MonitorEnter   (MonitorEnter*    x) = 0;
 178   virtual void do_MonitorExit    (MonitorExit*     x) = 0;
 179   virtual void do_Intrinsic      (Intrinsic*       x) = 0;
 180   virtual void do_BlockBegin     (BlockBegin*      x) = 0;
 181   virtual void do_Goto           (Goto*            x) = 0;
 182   virtual void do_If             (If*              x) = 0;
 183   virtual void do_TableSwitch    (TableSwitch*     x) = 0;
 184   virtual void do_LookupSwitch   (LookupSwitch*    x) = 0;
 185   virtual void do_Return         (Return*          x) = 0;
 186   virtual void do_Throw          (Throw*           x) = 0;
 187   virtual void do_Base           (Base*            x) = 0;
 188   virtual void do_OsrEntry       (OsrEntry*        x) = 0;
 189   virtual void do_ExceptionObject(ExceptionObject* x) = 0;
 190   virtual void do_RoundFP        (RoundFP*         x) = 0;
 191   virtual void do_UnsafeGet      (UnsafeGet*       x) = 0;
 192   virtual void do_UnsafePut      (UnsafePut*       x) = 0;
 193   virtual void do_UnsafeGetAndSet(UnsafeGetAndSet* x) = 0;
 194   virtual void do_ProfileCall    (ProfileCall*     x) = 0;
 195   virtual void do_ProfileReturnType (ProfileReturnType*  x) = 0;

 196   virtual void do_ProfileInvoke  (ProfileInvoke*   x) = 0;
 197   virtual void do_RuntimeCall    (RuntimeCall*     x) = 0;
 198   virtual void do_MemBar         (MemBar*          x) = 0;
 199   virtual void do_RangeCheckPredicate(RangeCheckPredicate* x) = 0;
 200 #ifdef ASSERT
 201   virtual void do_Assert         (Assert*          x) = 0;
 202 #endif
 203 };
 204 
 205 
 206 // Hashing support
 207 //
 208 // Note: This hash functions affect the performance
 209 //       of ValueMap - make changes carefully!
 210 
 211 #define HASH1(x1            )                    ((intx)(x1))
 212 #define HASH2(x1, x2        )                    ((HASH1(x1        ) << 7) ^ HASH1(x2))
 213 #define HASH3(x1, x2, x3    )                    ((HASH2(x1, x2    ) << 7) ^ HASH1(x3))
 214 #define HASH4(x1, x2, x3, x4)                    ((HASH3(x1, x2, x3) << 7) ^ HASH1(x4))

 215 
 216 
 217 // The following macros are used to implement instruction-specific hashing.
 218 // By default, each instruction implements hash() and is_equal(Value), used
 219 // for value numbering/common subexpression elimination. The default imple-
 220 // mentation disables value numbering. Each instruction which can be value-
 221 // numbered, should define corresponding hash() and is_equal(Value) functions
 222 // via the macros below. The f arguments specify all the values/op codes, etc.
 223 // that need to be identical for two instructions to be identical.
 224 //
 225 // Note: The default implementation of hash() returns 0 in order to indicate
 226 //       that the instruction should not be considered for value numbering.
 227 //       The currently used hash functions do not guarantee that never a 0
 228 //       is produced. While this is still correct, it may be a performance
 229 //       bug (no value numbering for that node). However, this situation is
 230 //       so unlikely, that we are not going to handle it specially.
 231 
 232 #define HASHING1(class_name, enabled, f1)             \
 233   virtual intx hash() const {                         \
 234     return (enabled) ? HASH2(name(), f1) : 0;         \

 253     if (f1 != _v->f1) return false;                   \
 254     if (f2 != _v->f2) return false;                   \
 255     return true;                                      \
 256   }                                                   \
 257 
 258 
 259 #define HASHING3(class_name, enabled, f1, f2, f3)     \
 260   virtual intx hash() const {                         \
 261     return (enabled) ? HASH4(name(), f1, f2, f3) : 0; \
 262   }                                                   \
 263   virtual bool is_equal(Value v) const {              \
 264     if (!(enabled)  ) return false;                   \
 265     class_name* _v = v->as_##class_name();            \
 266     if (_v == NULL  ) return false;                   \
 267     if (f1 != _v->f1) return false;                   \
 268     if (f2 != _v->f2) return false;                   \
 269     if (f3 != _v->f3) return false;                   \
 270     return true;                                      \
 271   }                                                   \
 272 















 273 
 274 // The mother of all instructions...
 275 
 276 class Instruction: public CompilationResourceObj {
 277  private:
 278   int          _id;                              // the unique instruction id
 279 #ifndef PRODUCT
 280   int          _printable_bci;                   // the bci of the instruction for printing
 281 #endif
 282   int          _use_count;                       // the number of instructions referring to this value (w/o prev/next); only roots can have use count = 0 or > 1
 283   int          _pin_state;                       // set of PinReason describing the reason for pinning
 284   ValueType*   _type;                            // the instruction value type
 285   Instruction* _next;                            // the next instruction if any (NULL for BlockEnd instructions)
 286   Instruction* _subst;                           // the substitution instruction if any
 287   LIR_Opr      _operand;                         // LIR specific information
 288   unsigned int _flags;                           // Flag bits
 289 
 290   ValueStack*  _state_before;                    // Copy of state with input operands still on stack (or NULL)
 291   ValueStack*  _exception_state;                 // Copy of state for exception handling
 292   XHandlers*   _exception_handlers;              // Flat list of exception handlers covering this instruction
 293 
 294   friend class UseCountComputer;

 295 
 296   void update_exception_state(ValueStack* state);
 297 
 298  protected:
 299   BlockBegin*  _block;                           // Block that contains this instruction
 300 
 301   void set_type(ValueType* type) {
 302     assert(type != NULL, "type must exist");
 303     _type = type;
 304   }
 305 
 306   // Helper class to keep track of which arguments need a null check
 307   class ArgsNonNullState {
 308   private:
 309     int _nonnull_state; // mask identifying which args are nonnull
 310   public:
 311     ArgsNonNullState()
 312       : _nonnull_state(AllBits) {}
 313 
 314     // Does argument number i needs a null check?

 327         if (check) {
 328           _nonnull_state |= nth_bit(i);
 329         } else {
 330           _nonnull_state &= ~(nth_bit(i));
 331         }
 332       }
 333     }
 334   };
 335 
 336  public:
 337   void* operator new(size_t size) throw() {
 338     Compilation* c = Compilation::current();
 339     void* res = c->arena()->Amalloc(size);
 340     return res;
 341   }
 342 
 343   static const int no_bci = -99;
 344 
 345   enum InstructionFlag {
 346     NeedsNullCheckFlag = 0,

 347     CanTrapFlag,
 348     DirectCompareFlag,
 349     IsEliminatedFlag,
 350     IsSafepointFlag,
 351     IsStaticFlag,
 352     NeedsStoreCheckFlag,
 353     NeedsWriteBarrierFlag,
 354     PreservesStateFlag,
 355     TargetIsFinalFlag,
 356     TargetIsLoadedFlag,
 357     UnorderedIsTrueFlag,
 358     NeedsPatchingFlag,
 359     ThrowIncompatibleClassChangeErrorFlag,
 360     InvokeSpecialReceiverCheckFlag,
 361     ProfileMDOFlag,
 362     IsLinkedInBlockFlag,
 363     NeedsRangeCheckFlag,
 364     InWorkListFlag,
 365     DeoptimizeOnException,
 366     KillsMemoryFlag,

 420   int id() const                                 { return _id; }
 421 #ifndef PRODUCT
 422   bool has_printable_bci() const                 { return _printable_bci != -99; }
 423   int printable_bci() const                      { assert(has_printable_bci(), "_printable_bci should have been set"); return _printable_bci; }
 424   void set_printable_bci(int bci)                { _printable_bci = bci; }
 425 #endif
 426   int dominator_depth();
 427   int use_count() const                          { return _use_count; }
 428   int pin_state() const                          { return _pin_state; }
 429   bool is_pinned() const                         { return _pin_state != 0 || PinAllInstructions; }
 430   ValueType* type() const                        { return _type; }
 431   BlockBegin *block() const                      { return _block; }
 432   Instruction* prev();                           // use carefully, expensive operation
 433   Instruction* next() const                      { return _next; }
 434   bool has_subst() const                         { return _subst != NULL; }
 435   Instruction* subst()                           { return _subst == NULL ? this : _subst->subst(); }
 436   LIR_Opr operand() const                        { return _operand; }
 437 
 438   void set_needs_null_check(bool f)              { set_flag(NeedsNullCheckFlag, f); }
 439   bool needs_null_check() const                  { return check_flag(NeedsNullCheckFlag); }


 440   bool is_linked() const                         { return check_flag(IsLinkedInBlockFlag); }
 441   bool can_be_linked()                           { return as_Local() == NULL && as_Phi() == NULL; }
 442 
 443   bool is_null_obj()                             { return as_Constant() != NULL && type()->as_ObjectType()->constant_value()->is_null_object(); }
 444 
 445   bool has_uses() const                          { return use_count() > 0; }
 446   ValueStack* state_before() const               { return _state_before; }
 447   ValueStack* exception_state() const            { return _exception_state; }
 448   virtual bool needs_exception_state() const     { return true; }
 449   XHandlers* exception_handlers() const          { return _exception_handlers; }

 450 
 451   // manipulation
 452   void pin(PinReason reason)                     { _pin_state |= reason; }
 453   void pin()                                     { _pin_state |= PinUnknown; }
 454   // DANGEROUS: only used by EliminateStores
 455   void unpin(PinReason reason)                   { assert((reason & PinUnknown) == 0, "can't unpin unknown state"); _pin_state &= ~reason; }
 456 
 457   Instruction* set_next(Instruction* next) {
 458     assert(next->has_printable_bci(), "_printable_bci should have been set");
 459     assert(next != NULL, "must not be NULL");
 460     assert(as_BlockEnd() == NULL, "BlockEnd instructions must have no next");
 461     assert(next->can_be_linked(), "shouldn't link these instructions into list");
 462 
 463     BlockBegin *block = this->block();
 464     next->_block = block;
 465 
 466     next->set_flag(Instruction::IsLinkedInBlockFlag, true);
 467     _next = next;
 468     return next;
 469   }

 474 #endif
 475     return set_next(next);
 476   }
 477 
 478   // when blocks are merged
 479   void fixup_block_pointers() {
 480     Instruction *cur = next()->next(); // next()'s block is set in set_next
 481     while (cur && cur->_block != block()) {
 482       cur->_block = block();
 483       cur = cur->next();
 484     }
 485   }
 486 
 487   Instruction *insert_after(Instruction *i) {
 488     Instruction* n = _next;
 489     set_next(i);
 490     i->set_next(n);
 491     return _next;
 492   }
 493 




 494   Instruction *insert_after_same_bci(Instruction *i) {
 495 #ifndef PRODUCT
 496     i->set_printable_bci(printable_bci());
 497 #endif
 498     return insert_after(i);
 499   }
 500 
 501   void set_subst(Instruction* subst)             {
 502     assert(subst == NULL ||
 503            type()->base() == subst->type()->base() ||
 504            subst->type()->base() == illegalType, "type can't change");
 505     _subst = subst;
 506   }
 507   void set_exception_handlers(XHandlers *xhandlers) { _exception_handlers = xhandlers; }
 508   void set_exception_state(ValueStack* s)        { check_state(s); _exception_state = s; }
 509   void set_state_before(ValueStack* s)           { check_state(s); _state_before = s; }
 510 
 511   // machine-specifics
 512   void set_operand(LIR_Opr operand)              { assert(operand != LIR_OprFact::illegalOpr, "operand must exist"); _operand = operand; }
 513   void clear_operand()                           { _operand = LIR_OprFact::illegalOpr; }

 521   virtual LoadField*        as_LoadField()       { return NULL; }
 522   virtual StoreField*       as_StoreField()      { return NULL; }
 523   virtual AccessArray*      as_AccessArray()     { return NULL; }
 524   virtual ArrayLength*      as_ArrayLength()     { return NULL; }
 525   virtual AccessIndexed*    as_AccessIndexed()   { return NULL; }
 526   virtual LoadIndexed*      as_LoadIndexed()     { return NULL; }
 527   virtual StoreIndexed*     as_StoreIndexed()    { return NULL; }
 528   virtual NegateOp*         as_NegateOp()        { return NULL; }
 529   virtual Op2*              as_Op2()             { return NULL; }
 530   virtual ArithmeticOp*     as_ArithmeticOp()    { return NULL; }
 531   virtual ShiftOp*          as_ShiftOp()         { return NULL; }
 532   virtual LogicOp*          as_LogicOp()         { return NULL; }
 533   virtual CompareOp*        as_CompareOp()       { return NULL; }
 534   virtual IfOp*             as_IfOp()            { return NULL; }
 535   virtual Convert*          as_Convert()         { return NULL; }
 536   virtual NullCheck*        as_NullCheck()       { return NULL; }
 537   virtual OsrEntry*         as_OsrEntry()        { return NULL; }
 538   virtual StateSplit*       as_StateSplit()      { return NULL; }
 539   virtual Invoke*           as_Invoke()          { return NULL; }
 540   virtual NewInstance*      as_NewInstance()     { return NULL; }

 541   virtual NewArray*         as_NewArray()        { return NULL; }
 542   virtual NewTypeArray*     as_NewTypeArray()    { return NULL; }
 543   virtual NewObjectArray*   as_NewObjectArray()  { return NULL; }
 544   virtual NewMultiArray*    as_NewMultiArray()   { return NULL; }

 545   virtual TypeCheck*        as_TypeCheck()       { return NULL; }
 546   virtual CheckCast*        as_CheckCast()       { return NULL; }
 547   virtual InstanceOf*       as_InstanceOf()      { return NULL; }
 548   virtual TypeCast*         as_TypeCast()        { return NULL; }
 549   virtual AccessMonitor*    as_AccessMonitor()   { return NULL; }
 550   virtual MonitorEnter*     as_MonitorEnter()    { return NULL; }
 551   virtual MonitorExit*      as_MonitorExit()     { return NULL; }
 552   virtual Intrinsic*        as_Intrinsic()       { return NULL; }
 553   virtual BlockBegin*       as_BlockBegin()      { return NULL; }
 554   virtual BlockEnd*         as_BlockEnd()        { return NULL; }
 555   virtual Goto*             as_Goto()            { return NULL; }
 556   virtual If*               as_If()              { return NULL; }
 557   virtual TableSwitch*      as_TableSwitch()     { return NULL; }
 558   virtual LookupSwitch*     as_LookupSwitch()    { return NULL; }
 559   virtual Return*           as_Return()          { return NULL; }
 560   virtual Throw*            as_Throw()           { return NULL; }
 561   virtual Base*             as_Base()            { return NULL; }
 562   virtual RoundFP*          as_RoundFP()         { return NULL; }
 563   virtual ExceptionObject*  as_ExceptionObject() { return NULL; }
 564   virtual UnsafeOp*         as_UnsafeOp()        { return NULL; }

 673   }
 674 
 675   bool is_illegal() const {
 676     return type()->is_illegal();
 677   }
 678 
 679   // generic
 680   virtual void input_values_do(ValueVisitor* f) {
 681   }
 682 };
 683 
 684 
 685 // A local is a placeholder for an incoming argument to a function call.
 686 LEAF(Local, Instruction)
 687  private:
 688   int      _java_index;                          // the local index within the method to which the local belongs
 689   bool     _is_receiver;                         // if local variable holds the receiver: "this" for non-static methods
 690   ciType*  _declared_type;
 691  public:
 692   // creation
 693   Local(ciType* declared, ValueType* type, int index, bool receiver)
 694     : Instruction(type)
 695     , _java_index(index)
 696     , _is_receiver(receiver)
 697     , _declared_type(declared)
 698   {

 699     NOT_PRODUCT(set_printable_bci(-1));
 700   }
 701 
 702   // accessors
 703   int java_index() const                         { return _java_index; }
 704   bool is_receiver() const                       { return _is_receiver; }
 705 
 706   virtual ciType* declared_type() const          { return _declared_type; }
 707 
 708   // generic
 709   virtual void input_values_do(ValueVisitor* f)   { /* no values */ }
 710 };
 711 
 712 
 713 LEAF(Constant, Instruction)
 714  public:
 715   // creation
 716   Constant(ValueType* type):
 717       Instruction(type, NULL, /*type_is_constant*/ true)
 718   {

 800 
 801   // manipulation
 802 
 803   // Under certain circumstances, if a previous NullCheck instruction
 804   // proved the target object non-null, we can eliminate the explicit
 805   // null check and do an implicit one, simply specifying the debug
 806   // information from the NullCheck. This field should only be consulted
 807   // if needs_null_check() is true.
 808   void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
 809 
 810   // generic
 811   virtual bool can_trap() const                  { return needs_null_check() || needs_patching(); }
 812   virtual void input_values_do(ValueVisitor* f)   { f->visit(&_obj); }
 813 };
 814 
 815 
 816 LEAF(LoadField, AccessField)
 817  public:
 818   // creation
 819   LoadField(Value obj, int offset, ciField* field, bool is_static,
 820             ValueStack* state_before, bool needs_patching)

 821   : AccessField(obj, offset, field, is_static, state_before, needs_patching)
 822   {}


 823 
 824   ciType* declared_type() const;
 825 
 826   // generic; cannot be eliminated if needs patching or if volatile.
 827   HASHING3(LoadField, !needs_patching() && !field()->is_volatile(), obj()->subst(), offset(), declared_type())
 828 };
 829 
 830 
 831 LEAF(StoreField, AccessField)
 832  private:
 833   Value _value;

 834 
 835  public:
 836   // creation
 837   StoreField(Value obj, int offset, ciField* field, Value value, bool is_static,
 838              ValueStack* state_before, bool needs_patching)
 839   : AccessField(obj, offset, field, is_static, state_before, needs_patching)
 840   , _value(value)
 841   {
 842     set_flag(NeedsWriteBarrierFlag, as_ValueType(field_type())->is_object());
 843     ASSERT_VALUES
 844     pin();
 845   }
 846 
 847   // accessors
 848   Value value() const                            { return _value; }
 849   bool needs_write_barrier() const               { return check_flag(NeedsWriteBarrierFlag); }


 850 
 851   // generic
 852   virtual void input_values_do(ValueVisitor* f)   { AccessField::input_values_do(f); f->visit(&_value); }
 853 };
 854 
 855 
 856 BASE(AccessArray, Instruction)
 857  private:
 858   Value       _array;
 859 
 860  public:
 861   // creation
 862   AccessArray(ValueType* type, Value array, ValueStack* state_before)
 863   : Instruction(type, state_before)
 864   , _array(array)
 865   {
 866     set_needs_null_check(true);
 867     ASSERT_VALUES
 868     pin(); // instruction with side effect (null exception or range check throwing)
 869   }

 887   , _explicit_null_check(NULL) {}
 888 
 889   // accessors
 890   NullCheck* explicit_null_check() const         { return _explicit_null_check; }
 891 
 892   // setters
 893   // See LoadField::set_explicit_null_check for documentation
 894   void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
 895 
 896   // generic
 897   HASHING1(ArrayLength, true, array()->subst())
 898 };
 899 
 900 
 901 BASE(AccessIndexed, AccessArray)
 902  private:
 903   Value     _index;
 904   Value     _length;
 905   BasicType _elt_type;
 906   bool      _mismatched;


 907 
 908  public:
 909   // creation
 910   AccessIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* state_before, bool mismatched)
 911   : AccessArray(as_ValueType(elt_type), array, state_before)
 912   , _index(index)
 913   , _length(length)
 914   , _elt_type(elt_type)
 915   , _mismatched(mismatched)

 916   {
 917     set_flag(Instruction::NeedsRangeCheckFlag, true);
 918     ASSERT_VALUES
 919   }
 920 
 921   // accessors
 922   Value index() const                            { return _index; }
 923   Value length() const                           { return _length; }
 924   BasicType elt_type() const                     { return _elt_type; }
 925   bool mismatched() const                        { return _mismatched; }
 926 
 927   void clear_length()                            { _length = NULL; }
 928   // perform elimination of range checks involving constants
 929   bool compute_needs_range_check();
 930 
 931   // generic









 932   virtual void input_values_do(ValueVisitor* f)   { AccessArray::input_values_do(f); f->visit(&_index); if (_length != NULL) f->visit(&_length); }
 933 };
 934 

 935 
 936 LEAF(LoadIndexed, AccessIndexed)
 937  private:
 938   NullCheck*  _explicit_null_check;              // For explicit null check elimination


 939 
 940  public:
 941   // creation
 942   LoadIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* state_before, bool mismatched = false)
 943   : AccessIndexed(array, index, length, elt_type, state_before, mismatched)
 944   , _explicit_null_check(NULL) {}
 945 
 946   // accessors
 947   NullCheck* explicit_null_check() const         { return _explicit_null_check; }
 948 
 949   // setters
 950   // See LoadField::set_explicit_null_check for documentation
 951   void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
 952 
 953   ciType* exact_type() const;
 954   ciType* declared_type() const;
 955 
 956   // generic;
 957   HASHING3(LoadIndexed, true, type()->tag(), array()->subst(), index()->subst())






 958 };
 959 























 960 
 961 LEAF(StoreIndexed, AccessIndexed)
 962  private:
 963   Value       _value;
 964 
 965   ciMethod* _profiled_method;
 966   int       _profiled_bci;
 967   bool      _check_boolean;
 968 
 969  public:
 970   // creation
 971   StoreIndexed(Value array, Value index, Value length, BasicType elt_type, Value value, ValueStack* state_before,
 972                bool check_boolean, bool mismatched = false)
 973   : AccessIndexed(array, index, length, elt_type, state_before, mismatched)
 974   , _value(value), _profiled_method(NULL), _profiled_bci(0), _check_boolean(check_boolean)
 975   {
 976     set_flag(NeedsWriteBarrierFlag, (as_ValueType(elt_type)->is_object()));
 977     set_flag(NeedsStoreCheckFlag, (as_ValueType(elt_type)->is_object()));
 978     ASSERT_VALUES
 979     pin();
 980   }
 981 
 982   // accessors
 983   Value value() const                            { return _value; }
 984   bool needs_write_barrier() const               { return check_flag(NeedsWriteBarrierFlag); }
 985   bool needs_store_check() const                 { return check_flag(NeedsStoreCheckFlag); }
 986   bool check_boolean() const                     { return _check_boolean; }
 987   // Helpers for MethodData* profiling
 988   void set_should_profile(bool value)                { set_flag(ProfileMDOFlag, value); }
 989   void set_profiled_method(ciMethod* method)         { _profiled_method = method;   }
 990   void set_profiled_bci(int bci)                     { _profiled_bci = bci;         }
 991   bool      should_profile() const                   { return check_flag(ProfileMDOFlag); }
 992   ciMethod* profiled_method() const                  { return _profiled_method;     }
 993   int       profiled_bci() const                     { return _profiled_bci;        }
 994   // generic
 995   virtual void input_values_do(ValueVisitor* f)   { AccessIndexed::input_values_do(f); f->visit(&_value); }
 996 };
 997 
 998 
 999 LEAF(NegateOp, Instruction)
1000  private:
1001   Value _x;
1002 
1003  public:
1004   // creation
1005   NegateOp(Value x) : Instruction(x->type()->base()), _x(x) {
1006     ASSERT_VALUES
1007   }
1008 
1009   // accessors
1010   Value x() const                                { return _x; }
1011 
1012   // generic
1013   virtual void input_values_do(ValueVisitor* f)   { f->visit(&_x); }

1084   HASHING3(Op2, true, op(), x()->subst(), y()->subst())
1085 };
1086 
1087 
1088 LEAF(CompareOp, Op2)
1089  public:
1090   // creation
1091   CompareOp(Bytecodes::Code op, Value x, Value y, ValueStack* state_before)
1092   : Op2(intType, op, x, y, state_before)
1093   {}
1094 
1095   // generic
1096   HASHING3(Op2, true, op(), x()->subst(), y()->subst())
1097 };
1098 
1099 
1100 LEAF(IfOp, Op2)
1101  private:
1102   Value _tval;
1103   Value _fval;

1104 
1105  public:
1106   // creation
1107   IfOp(Value x, Condition cond, Value y, Value tval, Value fval)
1108   : Op2(tval->type()->meet(fval->type()), (Bytecodes::Code)cond, x, y)
1109   , _tval(tval)
1110   , _fval(fval)

1111   {
1112     ASSERT_VALUES
1113     assert(tval->type()->tag() == fval->type()->tag(), "types must match");

1114   }
1115 
1116   // accessors
1117   virtual bool is_commutative() const;
1118   Bytecodes::Code op() const                     { ShouldNotCallThis(); return Bytecodes::_illegal; }
1119   Condition cond() const                         { return (Condition)Op2::op(); }
1120   Value tval() const                             { return _tval; }
1121   Value fval() const                             { return _fval; }
1122 
1123   // generic
1124   virtual void input_values_do(ValueVisitor* f)   { Op2::input_values_do(f); f->visit(&_tval); f->visit(&_fval); }
1125 };
1126 
1127 
1128 LEAF(Convert, Instruction)
1129  private:
1130   Bytecodes::Code _op;
1131   Value           _value;
1132 
1133  public:
1134   // creation
1135   Convert(Bytecodes::Code op, Value value, ValueType* to_type) : Instruction(to_type), _op(op), _value(value) {
1136     ASSERT_VALUES
1137   }
1138 
1139   // accessors
1140   Bytecodes::Code op() const                     { return _op; }
1141   Value value() const                            { return _value; }
1142 

1221   // manipulation
1222   void set_state(ValueStack* state)              { assert(_state == NULL, "overwriting existing state"); check_state(state); _state = state; }
1223 
1224   // generic
1225   virtual void input_values_do(ValueVisitor* f)   { /* no values */ }
1226   virtual void state_values_do(ValueVisitor* f);
1227 };
1228 
1229 
1230 LEAF(Invoke, StateSplit)
1231  private:
1232   Bytecodes::Code _code;
1233   Value           _recv;
1234   Values*         _args;
1235   BasicTypeList*  _signature;
1236   ciMethod*       _target;
1237 
1238  public:
1239   // creation
1240   Invoke(Bytecodes::Code code, ValueType* result_type, Value recv, Values* args,
1241          ciMethod* target, ValueStack* state_before);
1242 
1243   // accessors
1244   Bytecodes::Code code() const                   { return _code; }
1245   Value receiver() const                         { return _recv; }
1246   bool has_receiver() const                      { return receiver() != NULL; }
1247   int number_of_arguments() const                { return _args->length(); }
1248   Value argument_at(int i) const                 { return _args->at(i); }
1249   BasicTypeList* signature() const               { return _signature; }
1250   ciMethod* target() const                       { return _target; }
1251 
1252   ciType* declared_type() const;
1253 
1254   // Returns false if target is not loaded
1255   bool target_is_final() const                   { return check_flag(TargetIsFinalFlag); }
1256   bool target_is_loaded() const                  { return check_flag(TargetIsLoadedFlag); }
1257 
1258   // JSR 292 support
1259   bool is_invokedynamic() const                  { return code() == Bytecodes::_invokedynamic; }
1260   bool is_method_handle_intrinsic() const        { return target()->is_method_handle_intrinsic(); }
1261 

1279 
1280  public:
1281   // creation
1282   NewInstance(ciInstanceKlass* klass, ValueStack* state_before, bool is_unresolved)
1283   : StateSplit(instanceType, state_before)
1284   , _klass(klass), _is_unresolved(is_unresolved)
1285   {}
1286 
1287   // accessors
1288   ciInstanceKlass* klass() const                 { return _klass; }
1289   bool is_unresolved() const                     { return _is_unresolved; }
1290 
1291   virtual bool needs_exception_state() const     { return false; }
1292 
1293   // generic
1294   virtual bool can_trap() const                  { return true; }
1295   ciType* exact_type() const;
1296   ciType* declared_type() const;
1297 };
1298 
















































1299 
1300 BASE(NewArray, StateSplit)
1301  private:
1302   Value       _length;
1303 
1304  public:
1305   // creation
1306   NewArray(Value length, ValueStack* state_before)
1307   : StateSplit(objectType, state_before)
1308   , _length(length)
1309   {
1310     // Do not ASSERT_VALUES since length is NULL for NewMultiArray
1311   }
1312 
1313   // accessors
1314   Value length() const                           { return _length; }
1315 
1316   virtual bool needs_exception_state() const     { return false; }
1317 
1318   ciType* exact_type() const                     { return NULL; }

1330 
1331  public:
1332   // creation
1333   NewTypeArray(Value length, BasicType elt_type, ValueStack* state_before)
1334   : NewArray(length, state_before)
1335   , _elt_type(elt_type)
1336   {}
1337 
1338   // accessors
1339   BasicType elt_type() const                     { return _elt_type; }
1340   ciType* exact_type() const;
1341 };
1342 
1343 
1344 LEAF(NewObjectArray, NewArray)
1345  private:
1346   ciKlass* _klass;
1347 
1348  public:
1349   // creation
1350   NewObjectArray(ciKlass* klass, Value length, ValueStack* state_before) : NewArray(length, state_before), _klass(klass) {}



1351 
1352   // accessors
1353   ciKlass* klass() const                         { return _klass; }
1354   ciType* exact_type() const;
1355 };
1356 
1357 
1358 LEAF(NewMultiArray, NewArray)
1359  private:
1360   ciKlass* _klass;
1361   Values*  _dims;
1362 
1363  public:
1364   // creation
1365   NewMultiArray(ciKlass* klass, Values* dims, ValueStack* state_before) : NewArray(NULL, state_before), _klass(klass), _dims(dims) {
1366     ASSERT_VALUES
1367   }
1368 
1369   // accessors
1370   ciKlass* klass() const                         { return _klass; }
1371   Values* dims() const                           { return _dims; }
1372   int rank() const                               { return dims()->length(); }
1373 
1374   // generic
1375   virtual void input_values_do(ValueVisitor* f) {
1376     // NOTE: we do not call NewArray::input_values_do since "length"
1377     // is meaningless for a multi-dimensional array; passing the
1378     // zeroth element down to NewArray as its length is a bad idea
1379     // since there will be a copy in the "dims" array which doesn't
1380     // get updated, and the value must not be traversed twice. Was bug
1381     // - kbr 4/10/2001
1382     StateSplit::input_values_do(f);
1383     for (int i = 0; i < _dims->length(); i++) f->visit(_dims->adr_at(i));
1384   }


1385 };
1386 











1387 
1388 BASE(TypeCheck, StateSplit)
1389  private:
1390   ciKlass*    _klass;
1391   Value       _obj;
1392 
1393   ciMethod* _profiled_method;
1394   int       _profiled_bci;
1395 
1396  public:
1397   // creation
1398   TypeCheck(ciKlass* klass, Value obj, ValueType* type, ValueStack* state_before)
1399   : StateSplit(type, state_before), _klass(klass), _obj(obj),
1400     _profiled_method(NULL), _profiled_bci(0) {
1401     ASSERT_VALUES
1402     set_direct_compare(false);
1403   }
1404 
1405   // accessors
1406   ciKlass* klass() const                         { return _klass; }

1411   // manipulation
1412   void set_direct_compare(bool flag)             { set_flag(DirectCompareFlag, flag); }
1413 
1414   // generic
1415   virtual bool can_trap() const                  { return true; }
1416   virtual void input_values_do(ValueVisitor* f)   { StateSplit::input_values_do(f); f->visit(&_obj); }
1417 
1418   // Helpers for MethodData* profiling
1419   void set_should_profile(bool value)                { set_flag(ProfileMDOFlag, value); }
1420   void set_profiled_method(ciMethod* method)         { _profiled_method = method;   }
1421   void set_profiled_bci(int bci)                     { _profiled_bci = bci;         }
1422   bool      should_profile() const                   { return check_flag(ProfileMDOFlag); }
1423   ciMethod* profiled_method() const                  { return _profiled_method;     }
1424   int       profiled_bci() const                     { return _profiled_bci;        }
1425 };
1426 
1427 
1428 LEAF(CheckCast, TypeCheck)
1429  public:
1430   // creation
1431   CheckCast(ciKlass* klass, Value obj, ValueStack* state_before)
1432   : TypeCheck(klass, obj, objectType, state_before) {}


1433 
1434   void set_incompatible_class_change_check() {
1435     set_flag(ThrowIncompatibleClassChangeErrorFlag, true);
1436   }
1437   bool is_incompatible_class_change_check() const {
1438     return check_flag(ThrowIncompatibleClassChangeErrorFlag);
1439   }
1440   void set_invokespecial_receiver_check() {
1441     set_flag(InvokeSpecialReceiverCheckFlag, true);
1442   }
1443   bool is_invokespecial_receiver_check() const {
1444     return check_flag(InvokeSpecialReceiverCheckFlag);
1445   }
1446 
1447   virtual bool needs_exception_state() const {
1448     return !is_invokespecial_receiver_check();
1449   }
1450 
1451   ciType* declared_type() const;
1452 };

1470   // creation
1471   AccessMonitor(Value obj, int monitor_no, ValueStack* state_before = NULL)
1472   : StateSplit(illegalType, state_before)
1473   , _obj(obj)
1474   , _monitor_no(monitor_no)
1475   {
1476     set_needs_null_check(true);
1477     ASSERT_VALUES
1478   }
1479 
1480   // accessors
1481   Value obj() const                              { return _obj; }
1482   int monitor_no() const                         { return _monitor_no; }
1483 
1484   // generic
1485   virtual void input_values_do(ValueVisitor* f)   { StateSplit::input_values_do(f); f->visit(&_obj); }
1486 };
1487 
1488 
1489 LEAF(MonitorEnter, AccessMonitor)

1490  public:
1491   // creation
1492   MonitorEnter(Value obj, int monitor_no, ValueStack* state_before)
1493   : AccessMonitor(obj, monitor_no, state_before)

1494   {
1495     ASSERT_VALUES
1496   }
1497 



1498   // generic
1499   virtual bool can_trap() const                  { return true; }
1500 };
1501 
1502 
1503 LEAF(MonitorExit, AccessMonitor)
1504  public:
1505   // creation
1506   MonitorExit(Value obj, int monitor_no)
1507   : AccessMonitor(obj, monitor_no, NULL)
1508   {
1509     ASSERT_VALUES
1510   }
1511 };
1512 
1513 
1514 LEAF(Intrinsic, StateSplit)
1515  private:
1516   vmIntrinsics::ID _id;
1517   Values*          _args;

1937   Condition cond() const                         { return _cond; }
1938   bool unordered_is_true() const                 { return check_flag(UnorderedIsTrueFlag); }
1939   Value y() const                                { return _y; }
1940 
1941   void always_fail()                             { _x = _y = NULL; }
1942 
1943   // generic
1944   virtual void input_values_do(ValueVisitor* f)  { StateSplit::input_values_do(f); f->visit(&_x); f->visit(&_y); }
1945   HASHING3(RangeCheckPredicate, true, x()->subst(), y()->subst(), cond())
1946 };
1947 
1948 LEAF(If, BlockEnd)
1949  private:
1950   Value       _x;
1951   Condition   _cond;
1952   Value       _y;
1953   ciMethod*   _profiled_method;
1954   int         _profiled_bci; // Canonicalizer may alter bci of If node
1955   bool        _swapped;      // Is the order reversed with respect to the original If in the
1956                              // bytecode stream?

1957  public:
1958   // creation
1959   // unordered_is_true is valid for float/double compares only
1960   If(Value x, Condition cond, bool unordered_is_true, Value y, BlockBegin* tsux, BlockBegin* fsux, ValueStack* state_before, bool is_safepoint)
1961     : BlockEnd(illegalType, state_before, is_safepoint)
1962   , _x(x)
1963   , _cond(cond)
1964   , _y(y)
1965   , _profiled_method(NULL)
1966   , _profiled_bci(0)
1967   , _swapped(false)

1968   {
1969     ASSERT_VALUES
1970     set_flag(UnorderedIsTrueFlag, unordered_is_true);
1971     assert(x->type()->tag() == y->type()->tag(), "types must match");
1972     BlockList* s = new BlockList(2);
1973     s->append(tsux);
1974     s->append(fsux);
1975     set_sux(s);




1976   }
1977 
1978   // accessors
1979   Value x() const                                { return _x; }
1980   Condition cond() const                         { return _cond; }
1981   bool unordered_is_true() const                 { return check_flag(UnorderedIsTrueFlag); }
1982   Value y() const                                { return _y; }
1983   BlockBegin* sux_for(bool is_true) const        { return sux_at(is_true ? 0 : 1); }
1984   BlockBegin* tsux() const                       { return sux_for(true); }
1985   BlockBegin* fsux() const                       { return sux_for(false); }
1986   BlockBegin* usux() const                       { return sux_for(unordered_is_true()); }
1987   bool should_profile() const                    { return check_flag(ProfileMDOFlag); }
1988   ciMethod* profiled_method() const              { return _profiled_method; } // set only for profiled branches
1989   int profiled_bci() const                       { return _profiled_bci; }    // set for profiled branches and tiered
1990   bool is_swapped() const                        { return _swapped; }
1991 
1992   // manipulation
1993   void swap_operands() {
1994     Value t = _x; _x = _y; _y = t;
1995     _cond = mirror(_cond);
1996   }
1997 
1998   void set_should_profile(bool value)             { set_flag(ProfileMDOFlag, value); }
1999   void set_profiled_method(ciMethod* method)      { _profiled_method = method; }
2000   void set_profiled_bci(int bci)                  { _profiled_bci = bci;       }
2001   void set_swapped(bool value)                    { _swapped = value;         }

2002   // generic
2003   virtual void input_values_do(ValueVisitor* f)   { BlockEnd::input_values_do(f); f->visit(&_x); f->visit(&_y); }
2004 };
2005 
2006 
2007 BASE(Switch, BlockEnd)
2008  private:
2009   Value       _tag;
2010 
2011  public:
2012   // creation
2013   Switch(Value tag, BlockList* sux, ValueStack* state_before, bool is_safepoint)
2014   : BlockEnd(illegalType, state_before, is_safepoint)
2015   , _tag(tag) {
2016     ASSERT_VALUES
2017     set_sux(sux);
2018   }
2019 
2020   // accessors
2021   Value tag() const                              { return _tag; }

2316     }
2317   }
2318 };
2319 
2320 LEAF(ProfileReturnType, Instruction)
2321  private:
2322   ciMethod*        _method;
2323   ciMethod*        _callee;
2324   int              _bci_of_invoke;
2325   Value            _ret;
2326 
2327  public:
2328   ProfileReturnType(ciMethod* method, int bci, ciMethod* callee, Value ret)
2329     : Instruction(voidType)
2330     , _method(method)
2331     , _callee(callee)
2332     , _bci_of_invoke(bci)
2333     , _ret(ret)
2334   {
2335     set_needs_null_check(true);
2336     // The ProfileType has side-effects and must occur precisely where located
2337     pin();
2338   }
2339 
2340   ciMethod* method()             const { return _method; }
2341   ciMethod* callee()             const { return _callee; }
2342   int bci_of_invoke()            const { return _bci_of_invoke; }
2343   Value ret()                    const { return _ret; }
2344 
2345   virtual void input_values_do(ValueVisitor* f)   {
2346     if (_ret != NULL) {
2347       f->visit(&_ret);
2348     }
2349   }
2350 };
2351 










































2352 // Call some C runtime function that doesn't safepoint,
2353 // optionally passing the current thread as the first argument.
2354 LEAF(RuntimeCall, Instruction)
2355  private:
2356   const char* _entry_name;
2357   address     _entry;
2358   Values*     _args;
2359   bool        _pass_thread;  // Pass the JavaThread* as an implicit first argument
2360 
2361  public:
2362   RuntimeCall(ValueType* type, const char* entry_name, address entry, Values* args, bool pass_thread = true)
2363     : Instruction(type)
2364     , _entry_name(entry_name)
2365     , _entry(entry)
2366     , _args(args)
2367     , _pass_thread(pass_thread) {
2368     ASSERT_VALUES
2369     pin();
2370   }
2371 

  53 class   AccessArray;
  54 class     ArrayLength;
  55 class     AccessIndexed;
  56 class       LoadIndexed;
  57 class       StoreIndexed;
  58 class   NegateOp;
  59 class   Op2;
  60 class     ArithmeticOp;
  61 class     ShiftOp;
  62 class     LogicOp;
  63 class     CompareOp;
  64 class     IfOp;
  65 class   Convert;
  66 class   NullCheck;
  67 class   TypeCast;
  68 class   OsrEntry;
  69 class   ExceptionObject;
  70 class   StateSplit;
  71 class     Invoke;
  72 class     NewInstance;
  73 class     NewInlineTypeInstance;
  74 class     NewArray;
  75 class       NewTypeArray;
  76 class       NewObjectArray;
  77 class       NewMultiArray;
  78 class     Deoptimize;
  79 class     TypeCheck;
  80 class       CheckCast;
  81 class       InstanceOf;
  82 class     AccessMonitor;
  83 class       MonitorEnter;
  84 class       MonitorExit;
  85 class     Intrinsic;
  86 class     BlockBegin;
  87 class     BlockEnd;
  88 class       Goto;
  89 class       If;
  90 class       Switch;
  91 class         TableSwitch;
  92 class         LookupSwitch;
  93 class       Return;
  94 class       Throw;
  95 class       Base;
  96 class   RoundFP;
  97 class   UnsafeOp;
  98 class     UnsafeGet;
  99 class     UnsafePut;
 100 class     UnsafeGetAndSet;
 101 class   ProfileCall;
 102 class   ProfileReturnType;
 103 class   ProfileACmpTypes;
 104 class   ProfileInvoke;
 105 class   RuntimeCall;
 106 class   MemBar;
 107 class   RangeCheckPredicate;
 108 #ifdef ASSERT
 109 class   Assert;
 110 #endif
 111 
 112 // A Value is a reference to the instruction creating the value
 113 typedef Instruction* Value;
 114 typedef GrowableArray<Value> Values;
 115 typedef GrowableArray<ValueStack*> ValueStackStack;
 116 
 117 // BlockClosure is the base class for block traversal/iteration.
 118 
 119 class BlockClosure: public CompilationResourceObj {
 120  public:
 121   virtual void block_do(BlockBegin* block)       = 0;
 122 };
 123 

 155  public:
 156   virtual void do_Phi            (Phi*             x) = 0;
 157   virtual void do_Local          (Local*           x) = 0;
 158   virtual void do_Constant       (Constant*        x) = 0;
 159   virtual void do_LoadField      (LoadField*       x) = 0;
 160   virtual void do_StoreField     (StoreField*      x) = 0;
 161   virtual void do_ArrayLength    (ArrayLength*     x) = 0;
 162   virtual void do_LoadIndexed    (LoadIndexed*     x) = 0;
 163   virtual void do_StoreIndexed   (StoreIndexed*    x) = 0;
 164   virtual void do_NegateOp       (NegateOp*        x) = 0;
 165   virtual void do_ArithmeticOp   (ArithmeticOp*    x) = 0;
 166   virtual void do_ShiftOp        (ShiftOp*         x) = 0;
 167   virtual void do_LogicOp        (LogicOp*         x) = 0;
 168   virtual void do_CompareOp      (CompareOp*       x) = 0;
 169   virtual void do_IfOp           (IfOp*            x) = 0;
 170   virtual void do_Convert        (Convert*         x) = 0;
 171   virtual void do_NullCheck      (NullCheck*       x) = 0;
 172   virtual void do_TypeCast       (TypeCast*        x) = 0;
 173   virtual void do_Invoke         (Invoke*          x) = 0;
 174   virtual void do_NewInstance    (NewInstance*     x) = 0;
 175   virtual void do_NewInlineTypeInstance(NewInlineTypeInstance* x) = 0;
 176   virtual void do_NewTypeArray   (NewTypeArray*    x) = 0;
 177   virtual void do_NewObjectArray (NewObjectArray*  x) = 0;
 178   virtual void do_NewMultiArray  (NewMultiArray*   x) = 0;
 179   virtual void do_Deoptimize     (Deoptimize*      x) = 0;
 180   virtual void do_CheckCast      (CheckCast*       x) = 0;
 181   virtual void do_InstanceOf     (InstanceOf*      x) = 0;
 182   virtual void do_MonitorEnter   (MonitorEnter*    x) = 0;
 183   virtual void do_MonitorExit    (MonitorExit*     x) = 0;
 184   virtual void do_Intrinsic      (Intrinsic*       x) = 0;
 185   virtual void do_BlockBegin     (BlockBegin*      x) = 0;
 186   virtual void do_Goto           (Goto*            x) = 0;
 187   virtual void do_If             (If*              x) = 0;
 188   virtual void do_TableSwitch    (TableSwitch*     x) = 0;
 189   virtual void do_LookupSwitch   (LookupSwitch*    x) = 0;
 190   virtual void do_Return         (Return*          x) = 0;
 191   virtual void do_Throw          (Throw*           x) = 0;
 192   virtual void do_Base           (Base*            x) = 0;
 193   virtual void do_OsrEntry       (OsrEntry*        x) = 0;
 194   virtual void do_ExceptionObject(ExceptionObject* x) = 0;
 195   virtual void do_RoundFP        (RoundFP*         x) = 0;
 196   virtual void do_UnsafeGet      (UnsafeGet*       x) = 0;
 197   virtual void do_UnsafePut      (UnsafePut*       x) = 0;
 198   virtual void do_UnsafeGetAndSet(UnsafeGetAndSet* x) = 0;
 199   virtual void do_ProfileCall    (ProfileCall*     x) = 0;
 200   virtual void do_ProfileReturnType (ProfileReturnType*  x) = 0;
 201   virtual void do_ProfileACmpTypes(ProfileACmpTypes*  x) = 0;
 202   virtual void do_ProfileInvoke  (ProfileInvoke*   x) = 0;
 203   virtual void do_RuntimeCall    (RuntimeCall*     x) = 0;
 204   virtual void do_MemBar         (MemBar*          x) = 0;
 205   virtual void do_RangeCheckPredicate(RangeCheckPredicate* x) = 0;
 206 #ifdef ASSERT
 207   virtual void do_Assert         (Assert*          x) = 0;
 208 #endif
 209 };
 210 
 211 
 212 // Hashing support
 213 //
 214 // Note: This hash functions affect the performance
 215 //       of ValueMap - make changes carefully!
 216 
 217 #define HASH1(x1            )                    ((intx)(x1))
 218 #define HASH2(x1, x2        )                    ((HASH1(x1            ) << 7) ^ HASH1(x2))
 219 #define HASH3(x1, x2, x3    )                    ((HASH2(x1, x2        ) << 7) ^ HASH1(x3))
 220 #define HASH4(x1, x2, x3, x4)                    ((HASH3(x1, x2, x3    ) << 7) ^ HASH1(x4))
 221 #define HASH5(x1, x2, x3, x4, x5)                ((HASH4(x1, x2, x3, x4) << 7) ^ HASH1(x5))
 222 
 223 
 224 // The following macros are used to implement instruction-specific hashing.
 225 // By default, each instruction implements hash() and is_equal(Value), used
 226 // for value numbering/common subexpression elimination. The default imple-
 227 // mentation disables value numbering. Each instruction which can be value-
 228 // numbered, should define corresponding hash() and is_equal(Value) functions
 229 // via the macros below. The f arguments specify all the values/op codes, etc.
 230 // that need to be identical for two instructions to be identical.
 231 //
 232 // Note: The default implementation of hash() returns 0 in order to indicate
 233 //       that the instruction should not be considered for value numbering.
 234 //       The currently used hash functions do not guarantee that never a 0
 235 //       is produced. While this is still correct, it may be a performance
 236 //       bug (no value numbering for that node). However, this situation is
 237 //       so unlikely, that we are not going to handle it specially.
 238 
 239 #define HASHING1(class_name, enabled, f1)             \
 240   virtual intx hash() const {                         \
 241     return (enabled) ? HASH2(name(), f1) : 0;         \

 260     if (f1 != _v->f1) return false;                   \
 261     if (f2 != _v->f2) return false;                   \
 262     return true;                                      \
 263   }                                                   \
 264 
 265 
 266 #define HASHING3(class_name, enabled, f1, f2, f3)     \
 267   virtual intx hash() const {                         \
 268     return (enabled) ? HASH4(name(), f1, f2, f3) : 0; \
 269   }                                                   \
 270   virtual bool is_equal(Value v) const {              \
 271     if (!(enabled)  ) return false;                   \
 272     class_name* _v = v->as_##class_name();            \
 273     if (_v == NULL  ) return false;                   \
 274     if (f1 != _v->f1) return false;                   \
 275     if (f2 != _v->f2) return false;                   \
 276     if (f3 != _v->f3) return false;                   \
 277     return true;                                      \
 278   }                                                   \
 279 
 280 #define HASHING4(class_name, enabled, f1, f2, f3, f4) \
 281   virtual intx hash() const {                         \
 282     return (enabled) ? HASH5(name(), f1, f2, f3, f4) : 0; \
 283   }                                                   \
 284   virtual bool is_equal(Value v) const {              \
 285     if (!(enabled)  ) return false;                   \
 286     class_name* _v = v->as_##class_name();            \
 287     if (_v == NULL  ) return false;                   \
 288     if (f1 != _v->f1) return false;                   \
 289     if (f2 != _v->f2) return false;                   \
 290     if (f3 != _v->f3) return false;                   \
 291     if (f4 != _v->f4) return false;                   \
 292     return true;                                      \
 293   }                                                   \
 294 
 295 
 296 // The mother of all instructions...
 297 
 298 class Instruction: public CompilationResourceObj {
 299  private:
 300   int          _id;                              // the unique instruction id
 301 #ifndef PRODUCT
 302   int          _printable_bci;                   // the bci of the instruction for printing
 303 #endif
 304   int          _use_count;                       // the number of instructions referring to this value (w/o prev/next); only roots can have use count = 0 or > 1
 305   int          _pin_state;                       // set of PinReason describing the reason for pinning
 306   ValueType*   _type;                            // the instruction value type
 307   Instruction* _next;                            // the next instruction if any (NULL for BlockEnd instructions)
 308   Instruction* _subst;                           // the substitution instruction if any
 309   LIR_Opr      _operand;                         // LIR specific information
 310   unsigned int _flags;                           // Flag bits
 311 
 312   ValueStack*  _state_before;                    // Copy of state with input operands still on stack (or NULL)
 313   ValueStack*  _exception_state;                 // Copy of state for exception handling
 314   XHandlers*   _exception_handlers;              // Flat list of exception handlers covering this instruction
 315 
 316   friend class UseCountComputer;
 317   friend class GraphBuilder;
 318 
 319   void update_exception_state(ValueStack* state);
 320 
 321  protected:
 322   BlockBegin*  _block;                           // Block that contains this instruction
 323 
 324   void set_type(ValueType* type) {
 325     assert(type != NULL, "type must exist");
 326     _type = type;
 327   }
 328 
 329   // Helper class to keep track of which arguments need a null check
 330   class ArgsNonNullState {
 331   private:
 332     int _nonnull_state; // mask identifying which args are nonnull
 333   public:
 334     ArgsNonNullState()
 335       : _nonnull_state(AllBits) {}
 336 
 337     // Does argument number i needs a null check?

 350         if (check) {
 351           _nonnull_state |= nth_bit(i);
 352         } else {
 353           _nonnull_state &= ~(nth_bit(i));
 354         }
 355       }
 356     }
 357   };
 358 
 359  public:
 360   void* operator new(size_t size) throw() {
 361     Compilation* c = Compilation::current();
 362     void* res = c->arena()->Amalloc(size);
 363     return res;
 364   }
 365 
 366   static const int no_bci = -99;
 367 
 368   enum InstructionFlag {
 369     NeedsNullCheckFlag = 0,
 370     NeverNullFlag,          // For "Q" signatures
 371     CanTrapFlag,
 372     DirectCompareFlag,
 373     IsEliminatedFlag,
 374     IsSafepointFlag,
 375     IsStaticFlag,
 376     NeedsStoreCheckFlag,
 377     NeedsWriteBarrierFlag,
 378     PreservesStateFlag,
 379     TargetIsFinalFlag,
 380     TargetIsLoadedFlag,
 381     UnorderedIsTrueFlag,
 382     NeedsPatchingFlag,
 383     ThrowIncompatibleClassChangeErrorFlag,
 384     InvokeSpecialReceiverCheckFlag,
 385     ProfileMDOFlag,
 386     IsLinkedInBlockFlag,
 387     NeedsRangeCheckFlag,
 388     InWorkListFlag,
 389     DeoptimizeOnException,
 390     KillsMemoryFlag,

 444   int id() const                                 { return _id; }
 445 #ifndef PRODUCT
 446   bool has_printable_bci() const                 { return _printable_bci != -99; }
 447   int printable_bci() const                      { assert(has_printable_bci(), "_printable_bci should have been set"); return _printable_bci; }
 448   void set_printable_bci(int bci)                { _printable_bci = bci; }
 449 #endif
 450   int dominator_depth();
 451   int use_count() const                          { return _use_count; }
 452   int pin_state() const                          { return _pin_state; }
 453   bool is_pinned() const                         { return _pin_state != 0 || PinAllInstructions; }
 454   ValueType* type() const                        { return _type; }
 455   BlockBegin *block() const                      { return _block; }
 456   Instruction* prev();                           // use carefully, expensive operation
 457   Instruction* next() const                      { return _next; }
 458   bool has_subst() const                         { return _subst != NULL; }
 459   Instruction* subst()                           { return _subst == NULL ? this : _subst->subst(); }
 460   LIR_Opr operand() const                        { return _operand; }
 461 
 462   void set_needs_null_check(bool f)              { set_flag(NeedsNullCheckFlag, f); }
 463   bool needs_null_check() const                  { return check_flag(NeedsNullCheckFlag); }
 464   void set_null_free(bool f)                     { set_flag(NeverNullFlag, f); }
 465   bool is_null_free() const                      { return check_flag(NeverNullFlag); }
 466   bool is_linked() const                         { return check_flag(IsLinkedInBlockFlag); }
 467   bool can_be_linked()                           { return as_Local() == NULL && as_Phi() == NULL; }
 468 
 469   bool is_null_obj()                             { return as_Constant() != NULL && type()->as_ObjectType()->constant_value()->is_null_object(); }
 470 
 471   bool has_uses() const                          { return use_count() > 0; }
 472   ValueStack* state_before() const               { return _state_before; }
 473   ValueStack* exception_state() const            { return _exception_state; }
 474   virtual bool needs_exception_state() const     { return true; }
 475   XHandlers* exception_handlers() const          { return _exception_handlers; }
 476   ciKlass* as_loaded_klass_or_null() const;
 477 
 478   // manipulation
 479   void pin(PinReason reason)                     { _pin_state |= reason; }
 480   void pin()                                     { _pin_state |= PinUnknown; }
 481   // DANGEROUS: only used by EliminateStores
 482   void unpin(PinReason reason)                   { assert((reason & PinUnknown) == 0, "can't unpin unknown state"); _pin_state &= ~reason; }
 483 
 484   Instruction* set_next(Instruction* next) {
 485     assert(next->has_printable_bci(), "_printable_bci should have been set");
 486     assert(next != NULL, "must not be NULL");
 487     assert(as_BlockEnd() == NULL, "BlockEnd instructions must have no next");
 488     assert(next->can_be_linked(), "shouldn't link these instructions into list");
 489 
 490     BlockBegin *block = this->block();
 491     next->_block = block;
 492 
 493     next->set_flag(Instruction::IsLinkedInBlockFlag, true);
 494     _next = next;
 495     return next;
 496   }

 501 #endif
 502     return set_next(next);
 503   }
 504 
 505   // when blocks are merged
 506   void fixup_block_pointers() {
 507     Instruction *cur = next()->next(); // next()'s block is set in set_next
 508     while (cur && cur->_block != block()) {
 509       cur->_block = block();
 510       cur = cur->next();
 511     }
 512   }
 513 
 514   Instruction *insert_after(Instruction *i) {
 515     Instruction* n = _next;
 516     set_next(i);
 517     i->set_next(n);
 518     return _next;
 519   }
 520 
 521   bool is_loaded_flattened_array() const;
 522   bool maybe_flattened_array();
 523   bool maybe_null_free_array();
 524 
 525   Instruction *insert_after_same_bci(Instruction *i) {
 526 #ifndef PRODUCT
 527     i->set_printable_bci(printable_bci());
 528 #endif
 529     return insert_after(i);
 530   }
 531 
 532   void set_subst(Instruction* subst)             {
 533     assert(subst == NULL ||
 534            type()->base() == subst->type()->base() ||
 535            subst->type()->base() == illegalType, "type can't change");
 536     _subst = subst;
 537   }
 538   void set_exception_handlers(XHandlers *xhandlers) { _exception_handlers = xhandlers; }
 539   void set_exception_state(ValueStack* s)        { check_state(s); _exception_state = s; }
 540   void set_state_before(ValueStack* s)           { check_state(s); _state_before = s; }
 541 
 542   // machine-specifics
 543   void set_operand(LIR_Opr operand)              { assert(operand != LIR_OprFact::illegalOpr, "operand must exist"); _operand = operand; }
 544   void clear_operand()                           { _operand = LIR_OprFact::illegalOpr; }

 552   virtual LoadField*        as_LoadField()       { return NULL; }
 553   virtual StoreField*       as_StoreField()      { return NULL; }
 554   virtual AccessArray*      as_AccessArray()     { return NULL; }
 555   virtual ArrayLength*      as_ArrayLength()     { return NULL; }
 556   virtual AccessIndexed*    as_AccessIndexed()   { return NULL; }
 557   virtual LoadIndexed*      as_LoadIndexed()     { return NULL; }
 558   virtual StoreIndexed*     as_StoreIndexed()    { return NULL; }
 559   virtual NegateOp*         as_NegateOp()        { return NULL; }
 560   virtual Op2*              as_Op2()             { return NULL; }
 561   virtual ArithmeticOp*     as_ArithmeticOp()    { return NULL; }
 562   virtual ShiftOp*          as_ShiftOp()         { return NULL; }
 563   virtual LogicOp*          as_LogicOp()         { return NULL; }
 564   virtual CompareOp*        as_CompareOp()       { return NULL; }
 565   virtual IfOp*             as_IfOp()            { return NULL; }
 566   virtual Convert*          as_Convert()         { return NULL; }
 567   virtual NullCheck*        as_NullCheck()       { return NULL; }
 568   virtual OsrEntry*         as_OsrEntry()        { return NULL; }
 569   virtual StateSplit*       as_StateSplit()      { return NULL; }
 570   virtual Invoke*           as_Invoke()          { return NULL; }
 571   virtual NewInstance*      as_NewInstance()     { return NULL; }
 572   virtual NewInlineTypeInstance* as_NewInlineTypeInstance() { return NULL; }
 573   virtual NewArray*         as_NewArray()        { return NULL; }
 574   virtual NewTypeArray*     as_NewTypeArray()    { return NULL; }
 575   virtual NewObjectArray*   as_NewObjectArray()  { return NULL; }
 576   virtual NewMultiArray*    as_NewMultiArray()   { return NULL; }
 577   virtual Deoptimize*       as_Deoptimize()      { return NULL; }
 578   virtual TypeCheck*        as_TypeCheck()       { return NULL; }
 579   virtual CheckCast*        as_CheckCast()       { return NULL; }
 580   virtual InstanceOf*       as_InstanceOf()      { return NULL; }
 581   virtual TypeCast*         as_TypeCast()        { return NULL; }
 582   virtual AccessMonitor*    as_AccessMonitor()   { return NULL; }
 583   virtual MonitorEnter*     as_MonitorEnter()    { return NULL; }
 584   virtual MonitorExit*      as_MonitorExit()     { return NULL; }
 585   virtual Intrinsic*        as_Intrinsic()       { return NULL; }
 586   virtual BlockBegin*       as_BlockBegin()      { return NULL; }
 587   virtual BlockEnd*         as_BlockEnd()        { return NULL; }
 588   virtual Goto*             as_Goto()            { return NULL; }
 589   virtual If*               as_If()              { return NULL; }
 590   virtual TableSwitch*      as_TableSwitch()     { return NULL; }
 591   virtual LookupSwitch*     as_LookupSwitch()    { return NULL; }
 592   virtual Return*           as_Return()          { return NULL; }
 593   virtual Throw*            as_Throw()           { return NULL; }
 594   virtual Base*             as_Base()            { return NULL; }
 595   virtual RoundFP*          as_RoundFP()         { return NULL; }
 596   virtual ExceptionObject*  as_ExceptionObject() { return NULL; }
 597   virtual UnsafeOp*         as_UnsafeOp()        { return NULL; }

 706   }
 707 
 708   bool is_illegal() const {
 709     return type()->is_illegal();
 710   }
 711 
 712   // generic
 713   virtual void input_values_do(ValueVisitor* f) {
 714   }
 715 };
 716 
 717 
 718 // A local is a placeholder for an incoming argument to a function call.
 719 LEAF(Local, Instruction)
 720  private:
 721   int      _java_index;                          // the local index within the method to which the local belongs
 722   bool     _is_receiver;                         // if local variable holds the receiver: "this" for non-static methods
 723   ciType*  _declared_type;
 724  public:
 725   // creation
 726   Local(ciType* declared, ValueType* type, int index, bool receiver, bool null_free)
 727     : Instruction(type)
 728     , _java_index(index)
 729     , _is_receiver(receiver)
 730     , _declared_type(declared)
 731   {
 732     set_null_free(null_free);
 733     NOT_PRODUCT(set_printable_bci(-1));
 734   }
 735 
 736   // accessors
 737   int java_index() const                         { return _java_index; }
 738   bool is_receiver() const                       { return _is_receiver; }
 739 
 740   virtual ciType* declared_type() const          { return _declared_type; }
 741 
 742   // generic
 743   virtual void input_values_do(ValueVisitor* f)   { /* no values */ }
 744 };
 745 
 746 
 747 LEAF(Constant, Instruction)
 748  public:
 749   // creation
 750   Constant(ValueType* type):
 751       Instruction(type, NULL, /*type_is_constant*/ true)
 752   {

 834 
 835   // manipulation
 836 
 837   // Under certain circumstances, if a previous NullCheck instruction
 838   // proved the target object non-null, we can eliminate the explicit
 839   // null check and do an implicit one, simply specifying the debug
 840   // information from the NullCheck. This field should only be consulted
 841   // if needs_null_check() is true.
 842   void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
 843 
 844   // generic
 845   virtual bool can_trap() const                  { return needs_null_check() || needs_patching(); }
 846   virtual void input_values_do(ValueVisitor* f)   { f->visit(&_obj); }
 847 };
 848 
 849 
 850 LEAF(LoadField, AccessField)
 851  public:
 852   // creation
 853   LoadField(Value obj, int offset, ciField* field, bool is_static,
 854             ValueStack* state_before, bool needs_patching,
 855             ciInlineKlass* inline_klass = NULL, Value default_value = NULL )
 856   : AccessField(obj, offset, field, is_static, state_before, needs_patching)
 857   {
 858     set_null_free(field->is_null_free());
 859   }
 860 
 861   ciType* declared_type() const;
 862 
 863   // generic; cannot be eliminated if needs patching or if volatile.
 864   HASHING3(LoadField, !needs_patching() && !field()->is_volatile(), obj()->subst(), offset(), declared_type())
 865 };
 866 
 867 
 868 LEAF(StoreField, AccessField)
 869  private:
 870   Value _value;
 871   ciField* _enclosing_field;   // enclosing field (the flattened one) for nested fields
 872 
 873  public:
 874   // creation
 875   StoreField(Value obj, int offset, ciField* field, Value value, bool is_static,
 876              ValueStack* state_before, bool needs_patching);







 877 
 878   // accessors
 879   Value value() const                            { return _value; }
 880   bool needs_write_barrier() const               { return check_flag(NeedsWriteBarrierFlag); }
 881   ciField* enclosing_field() const               { return _enclosing_field; }
 882   void set_enclosing_field(ciField* field)       { _enclosing_field = field; }
 883 
 884   // generic
 885   virtual void input_values_do(ValueVisitor* f)   { AccessField::input_values_do(f); f->visit(&_value); }
 886 };
 887 
 888 
 889 BASE(AccessArray, Instruction)
 890  private:
 891   Value       _array;
 892 
 893  public:
 894   // creation
 895   AccessArray(ValueType* type, Value array, ValueStack* state_before)
 896   : Instruction(type, state_before)
 897   , _array(array)
 898   {
 899     set_needs_null_check(true);
 900     ASSERT_VALUES
 901     pin(); // instruction with side effect (null exception or range check throwing)
 902   }

 920   , _explicit_null_check(NULL) {}
 921 
 922   // accessors
 923   NullCheck* explicit_null_check() const         { return _explicit_null_check; }
 924 
 925   // setters
 926   // See LoadField::set_explicit_null_check for documentation
 927   void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
 928 
 929   // generic
 930   HASHING1(ArrayLength, true, array()->subst())
 931 };
 932 
 933 
 934 BASE(AccessIndexed, AccessArray)
 935  private:
 936   Value     _index;
 937   Value     _length;
 938   BasicType _elt_type;
 939   bool      _mismatched;
 940   ciMethod* _profiled_method;
 941   int       _profiled_bci;
 942 
 943  public:
 944   // creation
 945   AccessIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* state_before, bool mismatched)
 946   : AccessArray(as_ValueType(elt_type), array, state_before)
 947   , _index(index)
 948   , _length(length)
 949   , _elt_type(elt_type)
 950   , _mismatched(mismatched)
 951   , _profiled_method(NULL), _profiled_bci(0)
 952   {
 953     set_flag(Instruction::NeedsRangeCheckFlag, true);
 954     ASSERT_VALUES
 955   }
 956 
 957   // accessors
 958   Value index() const                            { return _index; }
 959   Value length() const                           { return _length; }
 960   BasicType elt_type() const                     { return _elt_type; }
 961   bool mismatched() const                        { return _mismatched; }
 962 
 963   void clear_length()                            { _length = NULL; }
 964   // perform elimination of range checks involving constants
 965   bool compute_needs_range_check();
 966 
 967   // Helpers for MethodData* profiling
 968   void set_should_profile(bool value)                { set_flag(ProfileMDOFlag, value); }
 969   void set_profiled_method(ciMethod* method)         { _profiled_method = method;   }
 970   void set_profiled_bci(int bci)                     { _profiled_bci = bci;         }
 971   bool      should_profile() const                   { return check_flag(ProfileMDOFlag); }
 972   ciMethod* profiled_method() const                  { return _profiled_method;     }
 973   int       profiled_bci() const                     { return _profiled_bci;        }
 974 
 975 
 976 // generic
 977   virtual void input_values_do(ValueVisitor* f)   { AccessArray::input_values_do(f); f->visit(&_index); if (_length != NULL) f->visit(&_length); }
 978 };
 979 
 980 class DelayedLoadIndexed;
 981 
 982 LEAF(LoadIndexed, AccessIndexed)
 983  private:
 984   NullCheck*  _explicit_null_check;              // For explicit null check elimination
 985   NewInlineTypeInstance* _vt;
 986   DelayedLoadIndexed* _delayed;
 987 
 988  public:
 989   // creation
 990   LoadIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* state_before, bool mismatched = false)
 991   : AccessIndexed(array, index, length, elt_type, state_before, mismatched)
 992   , _explicit_null_check(NULL), _vt(NULL), _delayed(NULL) {}
 993 
 994   // accessors
 995   NullCheck* explicit_null_check() const         { return _explicit_null_check; }
 996 
 997   // setters
 998   // See LoadField::set_explicit_null_check for documentation
 999   void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
1000 
1001   ciType* exact_type() const;
1002   ciType* declared_type() const;
1003 
1004   NewInlineTypeInstance* vt() const { return _vt; }
1005   void set_vt(NewInlineTypeInstance* vt) { _vt = vt; }
1006 
1007   DelayedLoadIndexed* delayed() const { return _delayed; }
1008   void set_delayed(DelayedLoadIndexed* delayed) { _delayed = delayed; }
1009 
1010   // generic
1011   HASHING4(LoadIndexed, delayed() == NULL && !should_profile(), type()->tag(), array()->subst(), index()->subst(), vt())
1012 };
1013 
1014 class DelayedLoadIndexed : public CompilationResourceObj {
1015 private:
1016   LoadIndexed* _load_instr;
1017   ValueStack* _state_before;
1018   ciField* _field;
1019   int _offset;
1020  public:
1021   DelayedLoadIndexed(LoadIndexed* load, ValueStack* state_before)
1022   : _load_instr(load)
1023   , _state_before(state_before)
1024   , _field(NULL)
1025   , _offset(0) { }
1026 
1027   void update(ciField* field, int offset) {
1028     _field = field;
1029     _offset += offset;
1030   }
1031 
1032   LoadIndexed* load_instr() const { return _load_instr; }
1033   ValueStack* state_before() const { return _state_before; }
1034   ciField* field() const { return _field; }
1035   int offset() const { return _offset; }
1036 };
1037 
1038 LEAF(StoreIndexed, AccessIndexed)
1039  private:
1040   Value       _value;
1041 


1042   bool      _check_boolean;
1043 
1044  public:
1045   // creation
1046   StoreIndexed(Value array, Value index, Value length, BasicType elt_type, Value value, ValueStack* state_before,
1047                bool check_boolean, bool mismatched = false);








1048 
1049   // accessors
1050   Value value() const                            { return _value; }
1051   bool needs_write_barrier() const               { return check_flag(NeedsWriteBarrierFlag); }
1052   bool needs_store_check() const                 { return check_flag(NeedsStoreCheckFlag); }
1053   bool check_boolean() const                     { return _check_boolean; }
1054 
1055   // Flattened array support
1056   bool is_exact_flattened_array_store() const;




1057   // generic
1058   virtual void input_values_do(ValueVisitor* f)   { AccessIndexed::input_values_do(f); f->visit(&_value); }
1059 };
1060 
1061 
1062 LEAF(NegateOp, Instruction)
1063  private:
1064   Value _x;
1065 
1066  public:
1067   // creation
1068   NegateOp(Value x) : Instruction(x->type()->base()), _x(x) {
1069     ASSERT_VALUES
1070   }
1071 
1072   // accessors
1073   Value x() const                                { return _x; }
1074 
1075   // generic
1076   virtual void input_values_do(ValueVisitor* f)   { f->visit(&_x); }

1147   HASHING3(Op2, true, op(), x()->subst(), y()->subst())
1148 };
1149 
1150 
1151 LEAF(CompareOp, Op2)
1152  public:
1153   // creation
1154   CompareOp(Bytecodes::Code op, Value x, Value y, ValueStack* state_before)
1155   : Op2(intType, op, x, y, state_before)
1156   {}
1157 
1158   // generic
1159   HASHING3(Op2, true, op(), x()->subst(), y()->subst())
1160 };
1161 
1162 
1163 LEAF(IfOp, Op2)
1164  private:
1165   Value _tval;
1166   Value _fval;
1167   bool _substitutability_check;
1168 
1169  public:
1170   // creation
1171   IfOp(Value x, Condition cond, Value y, Value tval, Value fval, ValueStack* state_before, bool substitutability_check)
1172   : Op2(tval->type()->meet(fval->type()), (Bytecodes::Code)cond, x, y)
1173   , _tval(tval)
1174   , _fval(fval)
1175   , _substitutability_check(substitutability_check)
1176   {
1177     ASSERT_VALUES
1178     assert(tval->type()->tag() == fval->type()->tag(), "types must match");
1179     set_state_before(state_before);
1180   }
1181 
1182   // accessors
1183   virtual bool is_commutative() const;
1184   Bytecodes::Code op() const                     { ShouldNotCallThis(); return Bytecodes::_illegal; }
1185   Condition cond() const                         { return (Condition)Op2::op(); }
1186   Value tval() const                             { return _tval; }
1187   Value fval() const                             { return _fval; }
1188   bool substitutability_check() const             { return _substitutability_check; }
1189   // generic
1190   virtual void input_values_do(ValueVisitor* f)   { Op2::input_values_do(f); f->visit(&_tval); f->visit(&_fval); }
1191 };
1192 
1193 
1194 LEAF(Convert, Instruction)
1195  private:
1196   Bytecodes::Code _op;
1197   Value           _value;
1198 
1199  public:
1200   // creation
1201   Convert(Bytecodes::Code op, Value value, ValueType* to_type) : Instruction(to_type), _op(op), _value(value) {
1202     ASSERT_VALUES
1203   }
1204 
1205   // accessors
1206   Bytecodes::Code op() const                     { return _op; }
1207   Value value() const                            { return _value; }
1208 

1287   // manipulation
1288   void set_state(ValueStack* state)              { assert(_state == NULL, "overwriting existing state"); check_state(state); _state = state; }
1289 
1290   // generic
1291   virtual void input_values_do(ValueVisitor* f)   { /* no values */ }
1292   virtual void state_values_do(ValueVisitor* f);
1293 };
1294 
1295 
1296 LEAF(Invoke, StateSplit)
1297  private:
1298   Bytecodes::Code _code;
1299   Value           _recv;
1300   Values*         _args;
1301   BasicTypeList*  _signature;
1302   ciMethod*       _target;
1303 
1304  public:
1305   // creation
1306   Invoke(Bytecodes::Code code, ValueType* result_type, Value recv, Values* args,
1307          ciMethod* target, ValueStack* state_before, bool null_free);
1308 
1309   // accessors
1310   Bytecodes::Code code() const                   { return _code; }
1311   Value receiver() const                         { return _recv; }
1312   bool has_receiver() const                      { return receiver() != NULL; }
1313   int number_of_arguments() const                { return _args->length(); }
1314   Value argument_at(int i) const                 { return _args->at(i); }
1315   BasicTypeList* signature() const               { return _signature; }
1316   ciMethod* target() const                       { return _target; }
1317 
1318   ciType* declared_type() const;
1319 
1320   // Returns false if target is not loaded
1321   bool target_is_final() const                   { return check_flag(TargetIsFinalFlag); }
1322   bool target_is_loaded() const                  { return check_flag(TargetIsLoadedFlag); }
1323 
1324   // JSR 292 support
1325   bool is_invokedynamic() const                  { return code() == Bytecodes::_invokedynamic; }
1326   bool is_method_handle_intrinsic() const        { return target()->is_method_handle_intrinsic(); }
1327 

1345 
1346  public:
1347   // creation
1348   NewInstance(ciInstanceKlass* klass, ValueStack* state_before, bool is_unresolved)
1349   : StateSplit(instanceType, state_before)
1350   , _klass(klass), _is_unresolved(is_unresolved)
1351   {}
1352 
1353   // accessors
1354   ciInstanceKlass* klass() const                 { return _klass; }
1355   bool is_unresolved() const                     { return _is_unresolved; }
1356 
1357   virtual bool needs_exception_state() const     { return false; }
1358 
1359   // generic
1360   virtual bool can_trap() const                  { return true; }
1361   ciType* exact_type() const;
1362   ciType* declared_type() const;
1363 };
1364 
1365 LEAF(NewInlineTypeInstance, StateSplit)
1366   ciInlineKlass* _klass;
1367   bool _in_larval_state;
1368   int _first_local_index;
1369   int _on_stack_count;
1370 public:
1371 
1372   // Default creation, always allocated for now
1373   NewInlineTypeInstance(ciInlineKlass* klass, ValueStack* state_before)
1374   : StateSplit(instanceType, state_before)
1375    , _klass(klass)
1376    , _in_larval_state(true)
1377    , _first_local_index(-1)
1378    , _on_stack_count(1)
1379   {
1380     set_null_free(true);
1381   }
1382 
1383   // accessors
1384   ciInlineKlass* klass() const { return _klass; }
1385   virtual bool needs_exception_state() const     { return false; }
1386 
1387   // generic
1388   virtual bool can_trap() const                  { return true; }
1389   ciType* exact_type() const;
1390   ciType* declared_type() const;
1391 
1392   // Only done in LIR Generator -> map everything to object
1393   void set_to_object_type() { set_type(instanceType); }
1394 
1395   void set_local_index(int index) {
1396     decrement_on_stack_count();
1397     if (_first_local_index != index) {
1398       if (_first_local_index == -1) {
1399         _first_local_index = index;
1400       } else {
1401         set_not_larva_anymore();
1402       }
1403     }
1404   }
1405 
1406   bool in_larval_state() const { return _in_larval_state; }
1407   void set_not_larva_anymore() { _in_larval_state = false; }
1408 
1409   int on_stack_count() const { return _on_stack_count; }
1410   void increment_on_stack_count() { _on_stack_count++; }
1411   void decrement_on_stack_count() { _on_stack_count--; }
1412 };
1413 
1414 BASE(NewArray, StateSplit)
1415  private:
1416   Value       _length;
1417 
1418  public:
1419   // creation
1420   NewArray(Value length, ValueStack* state_before)
1421   : StateSplit(objectType, state_before)
1422   , _length(length)
1423   {
1424     // Do not ASSERT_VALUES since length is NULL for NewMultiArray
1425   }
1426 
1427   // accessors
1428   Value length() const                           { return _length; }
1429 
1430   virtual bool needs_exception_state() const     { return false; }
1431 
1432   ciType* exact_type() const                     { return NULL; }

1444 
1445  public:
1446   // creation
1447   NewTypeArray(Value length, BasicType elt_type, ValueStack* state_before)
1448   : NewArray(length, state_before)
1449   , _elt_type(elt_type)
1450   {}
1451 
1452   // accessors
1453   BasicType elt_type() const                     { return _elt_type; }
1454   ciType* exact_type() const;
1455 };
1456 
1457 
1458 LEAF(NewObjectArray, NewArray)
1459  private:
1460   ciKlass* _klass;
1461 
1462  public:
1463   // creation
1464   NewObjectArray(ciKlass* klass, Value length, ValueStack* state_before, bool null_free)
1465   : NewArray(length, state_before), _klass(klass) {
1466     set_null_free(null_free);
1467   }
1468 
1469   // accessors
1470   ciKlass* klass() const                         { return _klass; }
1471   ciType* exact_type() const;
1472 };
1473 
1474 
1475 LEAF(NewMultiArray, NewArray)
1476  private:
1477   ciKlass* _klass;
1478   Values*  _dims;
1479 
1480  public:
1481   // creation
1482   NewMultiArray(ciKlass* klass, Values* dims, ValueStack* state_before) : NewArray(NULL, state_before), _klass(klass), _dims(dims) {
1483     ASSERT_VALUES
1484   }
1485 
1486   // accessors
1487   ciKlass* klass() const                         { return _klass; }
1488   Values* dims() const                           { return _dims; }
1489   int rank() const                               { return dims()->length(); }
1490 
1491   // generic
1492   virtual void input_values_do(ValueVisitor* f) {
1493     // NOTE: we do not call NewArray::input_values_do since "length"
1494     // is meaningless for a multi-dimensional array; passing the
1495     // zeroth element down to NewArray as its length is a bad idea
1496     // since there will be a copy in the "dims" array which doesn't
1497     // get updated, and the value must not be traversed twice. Was bug
1498     // - kbr 4/10/2001
1499     StateSplit::input_values_do(f);
1500     for (int i = 0; i < _dims->length(); i++) f->visit(_dims->adr_at(i));
1501   }
1502 
1503   ciType* exact_type() const;
1504 };
1505 
1506 LEAF(Deoptimize, StateSplit)
1507 private:
1508   ciKlass*    _klass;
1509 
1510  public:
1511   Deoptimize(ciKlass* klass, ValueStack* state_before)
1512   : StateSplit(objectType, state_before), _klass(klass) {}
1513 
1514   // accessors
1515   ciKlass* klass() const                         { return _klass; }
1516 };
1517 
1518 BASE(TypeCheck, StateSplit)
1519  private:
1520   ciKlass*    _klass;
1521   Value       _obj;
1522 
1523   ciMethod* _profiled_method;
1524   int       _profiled_bci;
1525 
1526  public:
1527   // creation
1528   TypeCheck(ciKlass* klass, Value obj, ValueType* type, ValueStack* state_before)
1529   : StateSplit(type, state_before), _klass(klass), _obj(obj),
1530     _profiled_method(NULL), _profiled_bci(0) {
1531     ASSERT_VALUES
1532     set_direct_compare(false);
1533   }
1534 
1535   // accessors
1536   ciKlass* klass() const                         { return _klass; }

1541   // manipulation
1542   void set_direct_compare(bool flag)             { set_flag(DirectCompareFlag, flag); }
1543 
1544   // generic
1545   virtual bool can_trap() const                  { return true; }
1546   virtual void input_values_do(ValueVisitor* f)   { StateSplit::input_values_do(f); f->visit(&_obj); }
1547 
1548   // Helpers for MethodData* profiling
1549   void set_should_profile(bool value)                { set_flag(ProfileMDOFlag, value); }
1550   void set_profiled_method(ciMethod* method)         { _profiled_method = method;   }
1551   void set_profiled_bci(int bci)                     { _profiled_bci = bci;         }
1552   bool      should_profile() const                   { return check_flag(ProfileMDOFlag); }
1553   ciMethod* profiled_method() const                  { return _profiled_method;     }
1554   int       profiled_bci() const                     { return _profiled_bci;        }
1555 };
1556 
1557 
1558 LEAF(CheckCast, TypeCheck)
1559  public:
1560   // creation
1561   CheckCast(ciKlass* klass, Value obj, ValueStack* state_before, bool null_free = false)
1562   : TypeCheck(klass, obj, objectType, state_before) {
1563     set_null_free(null_free);
1564   }
1565 
1566   void set_incompatible_class_change_check() {
1567     set_flag(ThrowIncompatibleClassChangeErrorFlag, true);
1568   }
1569   bool is_incompatible_class_change_check() const {
1570     return check_flag(ThrowIncompatibleClassChangeErrorFlag);
1571   }
1572   void set_invokespecial_receiver_check() {
1573     set_flag(InvokeSpecialReceiverCheckFlag, true);
1574   }
1575   bool is_invokespecial_receiver_check() const {
1576     return check_flag(InvokeSpecialReceiverCheckFlag);
1577   }
1578 
1579   virtual bool needs_exception_state() const {
1580     return !is_invokespecial_receiver_check();
1581   }
1582 
1583   ciType* declared_type() const;
1584 };

1602   // creation
1603   AccessMonitor(Value obj, int monitor_no, ValueStack* state_before = NULL)
1604   : StateSplit(illegalType, state_before)
1605   , _obj(obj)
1606   , _monitor_no(monitor_no)
1607   {
1608     set_needs_null_check(true);
1609     ASSERT_VALUES
1610   }
1611 
1612   // accessors
1613   Value obj() const                              { return _obj; }
1614   int monitor_no() const                         { return _monitor_no; }
1615 
1616   // generic
1617   virtual void input_values_do(ValueVisitor* f)   { StateSplit::input_values_do(f); f->visit(&_obj); }
1618 };
1619 
1620 
1621 LEAF(MonitorEnter, AccessMonitor)
1622   bool _maybe_inlinetype;
1623  public:
1624   // creation
1625   MonitorEnter(Value obj, int monitor_no, ValueStack* state_before, bool maybe_inlinetype)
1626   : AccessMonitor(obj, monitor_no, state_before)
1627   , _maybe_inlinetype(maybe_inlinetype)
1628   {
1629     ASSERT_VALUES
1630   }
1631 
1632   // accessors
1633   bool maybe_inlinetype() const                   { return _maybe_inlinetype; }
1634 
1635   // generic
1636   virtual bool can_trap() const                  { return true; }
1637 };
1638 
1639 
1640 LEAF(MonitorExit, AccessMonitor)
1641  public:
1642   // creation
1643   MonitorExit(Value obj, int monitor_no)
1644   : AccessMonitor(obj, monitor_no, NULL)
1645   {
1646     ASSERT_VALUES
1647   }
1648 };
1649 
1650 
1651 LEAF(Intrinsic, StateSplit)
1652  private:
1653   vmIntrinsics::ID _id;
1654   Values*          _args;

2074   Condition cond() const                         { return _cond; }
2075   bool unordered_is_true() const                 { return check_flag(UnorderedIsTrueFlag); }
2076   Value y() const                                { return _y; }
2077 
2078   void always_fail()                             { _x = _y = NULL; }
2079 
2080   // generic
2081   virtual void input_values_do(ValueVisitor* f)  { StateSplit::input_values_do(f); f->visit(&_x); f->visit(&_y); }
2082   HASHING3(RangeCheckPredicate, true, x()->subst(), y()->subst(), cond())
2083 };
2084 
2085 LEAF(If, BlockEnd)
2086  private:
2087   Value       _x;
2088   Condition   _cond;
2089   Value       _y;
2090   ciMethod*   _profiled_method;
2091   int         _profiled_bci; // Canonicalizer may alter bci of If node
2092   bool        _swapped;      // Is the order reversed with respect to the original If in the
2093                              // bytecode stream?
2094   bool        _substitutability_check;
2095  public:
2096   // creation
2097   // unordered_is_true is valid for float/double compares only
2098   If(Value x, Condition cond, bool unordered_is_true, Value y, BlockBegin* tsux, BlockBegin* fsux, ValueStack* state_before, bool is_safepoint, bool substitutability_check=false)
2099     : BlockEnd(illegalType, state_before, is_safepoint)
2100   , _x(x)
2101   , _cond(cond)
2102   , _y(y)
2103   , _profiled_method(NULL)
2104   , _profiled_bci(0)
2105   , _swapped(false)
2106   , _substitutability_check(substitutability_check)
2107   {
2108     ASSERT_VALUES
2109     set_flag(UnorderedIsTrueFlag, unordered_is_true);
2110     assert(x->type()->tag() == y->type()->tag(), "types must match");
2111     BlockList* s = new BlockList(2);
2112     s->append(tsux);
2113     s->append(fsux);
2114     set_sux(s);
2115     if (!_substitutability_check) {
2116       assert(x->as_NewInlineTypeInstance() == NULL || y->type() == objectNull, "Sanity check");
2117       assert(y->as_NewInlineTypeInstance() == NULL || x->type() == objectNull, "Sanity check");
2118     }
2119   }
2120 
2121   // accessors
2122   Value x() const                                { return _x; }
2123   Condition cond() const                         { return _cond; }
2124   bool unordered_is_true() const                 { return check_flag(UnorderedIsTrueFlag); }
2125   Value y() const                                { return _y; }
2126   BlockBegin* sux_for(bool is_true) const        { return sux_at(is_true ? 0 : 1); }
2127   BlockBegin* tsux() const                       { return sux_for(true); }
2128   BlockBegin* fsux() const                       { return sux_for(false); }
2129   BlockBegin* usux() const                       { return sux_for(unordered_is_true()); }
2130   bool should_profile() const                    { return check_flag(ProfileMDOFlag); }
2131   ciMethod* profiled_method() const              { return _profiled_method; } // set only for profiled branches
2132   int profiled_bci() const                       { return _profiled_bci; }    // set for profiled branches and tiered
2133   bool is_swapped() const                        { return _swapped; }
2134 
2135   // manipulation
2136   void swap_operands() {
2137     Value t = _x; _x = _y; _y = t;
2138     _cond = mirror(_cond);
2139   }
2140 
2141   void set_should_profile(bool value)             { set_flag(ProfileMDOFlag, value); }
2142   void set_profiled_method(ciMethod* method)      { _profiled_method = method; }
2143   void set_profiled_bci(int bci)                  { _profiled_bci = bci;       }
2144   void set_swapped(bool value)                    { _swapped = value;         }
2145   bool substitutability_check() const              { return _substitutability_check; }
2146   // generic
2147   virtual void input_values_do(ValueVisitor* f)   { BlockEnd::input_values_do(f); f->visit(&_x); f->visit(&_y); }
2148 };
2149 
2150 
2151 BASE(Switch, BlockEnd)
2152  private:
2153   Value       _tag;
2154 
2155  public:
2156   // creation
2157   Switch(Value tag, BlockList* sux, ValueStack* state_before, bool is_safepoint)
2158   : BlockEnd(illegalType, state_before, is_safepoint)
2159   , _tag(tag) {
2160     ASSERT_VALUES
2161     set_sux(sux);
2162   }
2163 
2164   // accessors
2165   Value tag() const                              { return _tag; }

2460     }
2461   }
2462 };
2463 
2464 LEAF(ProfileReturnType, Instruction)
2465  private:
2466   ciMethod*        _method;
2467   ciMethod*        _callee;
2468   int              _bci_of_invoke;
2469   Value            _ret;
2470 
2471  public:
2472   ProfileReturnType(ciMethod* method, int bci, ciMethod* callee, Value ret)
2473     : Instruction(voidType)
2474     , _method(method)
2475     , _callee(callee)
2476     , _bci_of_invoke(bci)
2477     , _ret(ret)
2478   {
2479     set_needs_null_check(true);
2480     // The ProfileReturnType has side-effects and must occur precisely where located
2481     pin();
2482   }
2483 
2484   ciMethod* method()             const { return _method; }
2485   ciMethod* callee()             const { return _callee; }
2486   int bci_of_invoke()            const { return _bci_of_invoke; }
2487   Value ret()                    const { return _ret; }
2488 
2489   virtual void input_values_do(ValueVisitor* f)   {
2490     if (_ret != NULL) {
2491       f->visit(&_ret);
2492     }
2493   }
2494 };
2495 
2496 LEAF(ProfileACmpTypes, Instruction)
2497  private:
2498   ciMethod*        _method;
2499   int              _bci;
2500   Value            _left;
2501   Value            _right;
2502   bool             _left_maybe_null;
2503   bool             _right_maybe_null;
2504 
2505  public:
2506   ProfileACmpTypes(ciMethod* method, int bci, Value left, Value right)
2507     : Instruction(voidType)
2508     , _method(method)
2509     , _bci(bci)
2510     , _left(left)
2511     , _right(right)
2512   {
2513     // The ProfileACmp has side-effects and must occur precisely where located
2514     pin();
2515     _left_maybe_null = true;
2516     _right_maybe_null = true;
2517   }
2518 
2519   ciMethod* method()             const { return _method; }
2520   int bci()                      const { return _bci; }
2521   Value left()                   const { return _left; }
2522   Value right()                  const { return _right; }
2523   bool left_maybe_null()         const { return _left_maybe_null; }
2524   bool right_maybe_null()        const { return _right_maybe_null; }
2525   void set_left_maybe_null(bool v)     { _left_maybe_null = v; }
2526   void set_right_maybe_null(bool v)    { _right_maybe_null = v; }
2527 
2528   virtual void input_values_do(ValueVisitor* f)   {
2529     if (_left != NULL) {
2530       f->visit(&_left);
2531     }
2532     if (_right != NULL) {
2533       f->visit(&_right);
2534     }
2535   }
2536 };
2537 
2538 // Call some C runtime function that doesn't safepoint,
2539 // optionally passing the current thread as the first argument.
2540 LEAF(RuntimeCall, Instruction)
2541  private:
2542   const char* _entry_name;
2543   address     _entry;
2544   Values*     _args;
2545   bool        _pass_thread;  // Pass the JavaThread* as an implicit first argument
2546 
2547  public:
2548   RuntimeCall(ValueType* type, const char* entry_name, address entry, Values* args, bool pass_thread = true)
2549     : Instruction(type)
2550     , _entry_name(entry_name)
2551     , _entry(entry)
2552     , _args(args)
2553     , _pass_thread(pass_thread) {
2554     ASSERT_VALUES
2555     pin();
2556   }
2557 
< prev index next >