1 /*
   2  * Copyright (c) 1999, 2022, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_C1_C1_INSTRUCTION_HPP
  26 #define SHARE_C1_C1_INSTRUCTION_HPP
  27 
  28 #include "c1/c1_Compilation.hpp"
  29 #include "c1/c1_LIR.hpp"
  30 #include "c1/c1_ValueType.hpp"
  31 #include "ci/ciField.hpp"
  32 
  33 // Predefined classes
  34 class ciField;
  35 class ValueStack;
  36 class InstructionPrinter;
  37 class IRScope;
  38 
  39 
  40 // Instruction class hierarchy
  41 //
  42 // All leaf classes in the class hierarchy are concrete classes
  43 // (i.e., are instantiated). All other classes are abstract and
  44 // serve factoring.
  45 
  46 class Instruction;
  47 class   Phi;
  48 class   Local;
  49 class   Constant;
  50 class   AccessField;
  51 class     LoadField;
  52 class     StoreField;
  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 
 121 
 122 // A simple closure class for visiting the values of an Instruction
 123 class ValueVisitor: public StackObj {
 124  public:
 125   virtual void visit(Value* v) = 0;
 126 };
 127 
 128 
 129 // Some array and list classes
 130 typedef GrowableArray<BlockBegin*> BlockBeginArray;
 131 
 132 class BlockList: public GrowableArray<BlockBegin*> {
 133  public:
 134   BlockList(): GrowableArray<BlockBegin*>() {}
 135   BlockList(const int size): GrowableArray<BlockBegin*>(size) {}
 136   BlockList(const int size, BlockBegin* init): GrowableArray<BlockBegin*>(size, size, init) {}
 137 
 138   void iterate_forward(BlockClosure* closure);
 139   void iterate_backward(BlockClosure* closure);
 140   void values_do(ValueVisitor* f);
 141   void print(bool cfg_only = false, bool live_only = false) PRODUCT_RETURN;
 142 };
 143 
 144 
 145 // InstructionVisitors provide type-based dispatch for instructions.
 146 // For each concrete Instruction class X, a virtual function do_X is
 147 // provided. Functionality that needs to be implemented for all classes
 148 // (e.g., printing, code generation) is factored out into a specialised
 149 // visitor instead of added to the Instruction classes itself.
 150 
 151 class InstructionVisitor: public StackObj {
 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;         \
 235   }                                                   \
 236   virtual bool is_equal(Value v) const {              \
 237     if (!(enabled)  ) return false;                   \
 238     class_name* _v = v->as_##class_name();            \
 239     if (_v == NULL  ) return false;                   \
 240     if (f1 != _v->f1) return false;                   \
 241     return true;                                      \
 242   }                                                   \
 243 
 244 
 245 #define HASHING2(class_name, enabled, f1, f2)         \
 246   virtual intx hash() const {                         \
 247     return (enabled) ? HASH3(name(), f1, f2) : 0;     \
 248   }                                                   \
 249   virtual bool is_equal(Value v) const {              \
 250     if (!(enabled)  ) return false;                   \
 251     class_name* _v = v->as_##class_name();            \
 252     if (_v == NULL  ) return false;                   \
 253     if (f1 != _v->f1) return false;                   \
 254     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 refering 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?
 315     bool arg_needs_null_check(int i) const {
 316       // No data is kept for arguments starting at position 33 so
 317       // conservatively assume that they need a null check.
 318       if (i >= 0 && i < (int)sizeof(_nonnull_state) * BitsPerByte) {
 319         return is_set_nth_bit(_nonnull_state, i);
 320       }
 321       return true;
 322     }
 323 
 324     // Set whether argument number i needs a null check or not
 325     void set_arg_needs_null_check(int i, bool check) {
 326       if (i >= 0 && i < (int)sizeof(_nonnull_state) * BitsPerByte) {
 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,
 367     InstructionLastFlag
 368   };
 369 
 370  public:
 371   bool check_flag(InstructionFlag id) const      { return (_flags & (1 << id)) != 0;    }
 372   void set_flag(InstructionFlag id, bool f)      { _flags = f ? (_flags | (1 << id)) : (_flags & ~(1 << id)); };
 373 
 374   // 'globally' used condition values
 375   enum Condition {
 376     eql, neq, lss, leq, gtr, geq, aeq, beq
 377   };
 378 
 379   // Instructions may be pinned for many reasons and under certain conditions
 380   // with enough knowledge it's possible to safely unpin them.
 381   enum PinReason {
 382       PinUnknown           = 1 << 0
 383     , PinExplicitNullCheck = 1 << 3
 384     , PinStackForStateSplit= 1 << 12
 385     , PinStateSplitConstructor= 1 << 13
 386     , PinGlobalValueNumbering= 1 << 14
 387   };
 388 
 389   static Condition mirror(Condition cond);
 390   static Condition negate(Condition cond);
 391 
 392   // initialization
 393   static int number_of_instructions() {
 394     return Compilation::current()->number_of_instructions();
 395   }
 396 
 397   // creation
 398   Instruction(ValueType* type, ValueStack* state_before = NULL, bool type_is_constant = false)
 399   : _id(Compilation::current()->get_next_id()),
 400 #ifndef PRODUCT
 401   _printable_bci(-99),
 402 #endif
 403     _use_count(0)
 404   , _pin_state(0)
 405   , _type(type)
 406   , _next(NULL)
 407   , _subst(NULL)
 408   , _operand(LIR_OprFact::illegalOpr)
 409   , _flags(0)
 410   , _state_before(state_before)
 411   , _exception_handlers(NULL)
 412   , _block(NULL)
 413   {
 414     check_state(state_before);
 415     assert(type != NULL && (!type->is_constant() || type_is_constant), "type must exist");
 416     update_exception_state(_state_before);
 417   }
 418 
 419   // accessors
 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   }
 470 
 471   Instruction* set_next(Instruction* next, int bci) {
 472 #ifndef PRODUCT
 473     next->set_printable_bci(bci);
 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; }
 514 
 515   // generic
 516   virtual Instruction*      as_Instruction()     { return this; } // to satisfy HASHING1 macro
 517   virtual Phi*              as_Phi()             { return NULL; }
 518   virtual Local*            as_Local()           { return NULL; }
 519   virtual Constant*         as_Constant()        { return NULL; }
 520   virtual AccessField*      as_AccessField()     { return NULL; }
 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; }
 565   virtual ProfileInvoke*    as_ProfileInvoke()   { return NULL; }
 566   virtual RangeCheckPredicate* as_RangeCheckPredicate() { return NULL; }
 567 
 568 #ifdef ASSERT
 569   virtual Assert*           as_Assert()          { return NULL; }
 570 #endif
 571 
 572   virtual void visit(InstructionVisitor* v)      = 0;
 573 
 574   virtual bool can_trap() const                  { return false; }
 575 
 576   virtual void input_values_do(ValueVisitor* f)   = 0;
 577   virtual void state_values_do(ValueVisitor* f);
 578   virtual void other_values_do(ValueVisitor* f)   { /* usually no other - override on demand */ }
 579           void       values_do(ValueVisitor* f)   { input_values_do(f); state_values_do(f); other_values_do(f); }
 580 
 581   virtual ciType* exact_type() const;
 582   virtual ciType* declared_type() const          { return NULL; }
 583 
 584   // hashing
 585   virtual const char* name() const               = 0;
 586   HASHING1(Instruction, false, id())             // hashing disabled by default
 587 
 588   // debugging
 589   static void check_state(ValueStack* state)     PRODUCT_RETURN;
 590   void print()                                   PRODUCT_RETURN;
 591   void print_line()                              PRODUCT_RETURN;
 592   void print(InstructionPrinter& ip)             PRODUCT_RETURN;
 593 };
 594 
 595 
 596 // The following macros are used to define base (i.e., non-leaf)
 597 // and leaf instruction classes. They define class-name related
 598 // generic functionality in one place.
 599 
 600 #define BASE(class_name, super_class_name)       \
 601   class class_name: public super_class_name {    \
 602    public:                                       \
 603     virtual class_name* as_##class_name()        { return this; }              \
 604 
 605 
 606 #define LEAF(class_name, super_class_name)       \
 607   BASE(class_name, super_class_name)             \
 608    public:                                       \
 609     virtual const char* name() const             { return #class_name; }       \
 610     virtual void visit(InstructionVisitor* v)    { v->do_##class_name(this); } \
 611 
 612 
 613 // Debugging support
 614 
 615 
 616 #ifdef ASSERT
 617 class AssertValues: public ValueVisitor {
 618   void visit(Value* x)             { assert((*x) != NULL, "value must exist"); }
 619 };
 620   #define ASSERT_VALUES                          { AssertValues assert_value; values_do(&assert_value); }
 621 #else
 622   #define ASSERT_VALUES
 623 #endif // ASSERT
 624 
 625 
 626 // A Phi is a phi function in the sense of SSA form. It stands for
 627 // the value of a local variable at the beginning of a join block.
 628 // A Phi consists of n operands, one for every incoming branch.
 629 
 630 LEAF(Phi, Instruction)
 631  private:
 632   int         _pf_flags; // the flags of the phi function
 633   int         _index;    // to value on operand stack (index < 0) or to local
 634  public:
 635   // creation
 636   Phi(ValueType* type, BlockBegin* b, int index)
 637   : Instruction(type->base())
 638   , _pf_flags(0)
 639   , _index(index)
 640   {
 641     _block = b;
 642     NOT_PRODUCT(set_printable_bci(Value(b)->printable_bci()));
 643     if (type->is_illegal()) {
 644       make_illegal();
 645     }
 646   }
 647 
 648   // flags
 649   enum Flag {
 650     no_flag         = 0,
 651     visited         = 1 << 0,
 652     cannot_simplify = 1 << 1
 653   };
 654 
 655   // accessors
 656   bool  is_local() const          { return _index >= 0; }
 657   bool  is_on_stack() const       { return !is_local(); }
 658   int   local_index() const       { assert(is_local(), ""); return _index; }
 659   int   stack_index() const       { assert(is_on_stack(), ""); return -(_index+1); }
 660 
 661   Value operand_at(int i) const;
 662   int   operand_count() const;
 663 
 664   void   set(Flag f)              { _pf_flags |=  f; }
 665   void   clear(Flag f)            { _pf_flags &= ~f; }
 666   bool   is_set(Flag f) const     { return (_pf_flags & f) != 0; }
 667 
 668   // Invalidates phis corresponding to merges of locals of two different types
 669   // (these should never be referenced, otherwise the bytecodes are illegal)
 670   void   make_illegal() {
 671     set(cannot_simplify);
 672     set_type(illegalType);
 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   {
 719     assert(type->is_constant(), "must be a constant");
 720   }
 721 
 722   Constant(ValueType* type, ValueStack* state_before, bool kills_memory = false):
 723     Instruction(type, state_before, /*type_is_constant*/ true)
 724   {
 725     assert(state_before != NULL, "only used for constants which need patching");
 726     assert(type->is_constant(), "must be a constant");
 727     set_flag(KillsMemoryFlag, kills_memory);
 728     pin(); // since it's patching it needs to be pinned
 729   }
 730 
 731   // generic
 732   virtual bool can_trap() const                  { return state_before() != NULL; }
 733   virtual void input_values_do(ValueVisitor* f)   { /* no values */ }
 734 
 735   virtual intx hash() const;
 736   virtual bool is_equal(Value v) const;
 737 
 738   virtual ciType* exact_type() const;
 739 
 740   bool kills_memory() const { return check_flag(KillsMemoryFlag); }
 741 
 742   enum CompareResult { not_comparable = -1, cond_false, cond_true };
 743 
 744   virtual CompareResult compare(Instruction::Condition condition, Value right) const;
 745   BlockBegin* compare(Instruction::Condition cond, Value right,
 746                       BlockBegin* true_sux, BlockBegin* false_sux) const {
 747     switch (compare(cond, right)) {
 748     case not_comparable:
 749       return NULL;
 750     case cond_false:
 751       return false_sux;
 752     case cond_true:
 753       return true_sux;
 754     default:
 755       ShouldNotReachHere();
 756       return NULL;
 757     }
 758   }
 759 };
 760 
 761 
 762 BASE(AccessField, Instruction)
 763  private:
 764   Value       _obj;
 765   int         _offset;
 766   ciField*    _field;
 767   NullCheck*  _explicit_null_check;              // For explicit null check elimination
 768 
 769  public:
 770   // creation
 771   AccessField(Value obj, int offset, ciField* field, bool is_static,
 772               ValueStack* state_before, bool needs_patching)
 773   : Instruction(as_ValueType(field->type()->basic_type()), state_before)
 774   , _obj(obj)
 775   , _offset(offset)
 776   , _field(field)
 777   , _explicit_null_check(NULL)
 778   {
 779     set_needs_null_check(!is_static);
 780     set_flag(IsStaticFlag, is_static);
 781     set_flag(NeedsPatchingFlag, needs_patching);
 782     ASSERT_VALUES
 783     // pin of all instructions with memory access
 784     pin();
 785   }
 786 
 787   // accessors
 788   Value obj() const                              { return _obj; }
 789   int offset() const                             { return _offset; }
 790   ciField* field() const                         { return _field; }
 791   BasicType field_type() const                   { return _field->type()->basic_type(); }
 792   bool is_static() const                         { return check_flag(IsStaticFlag); }
 793   NullCheck* explicit_null_check() const         { return _explicit_null_check; }
 794   bool needs_patching() const                    { return check_flag(NeedsPatchingFlag); }
 795 
 796   // Unresolved getstatic and putstatic can cause initialization.
 797   // Technically it occurs at the Constant that materializes the base
 798   // of the static fields but it's simpler to model it here.
 799   bool is_init_point() const                     { return is_static() && (needs_patching() || !_field->holder()->is_initialized()); }
 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   }
 870 
 871   Value array() const                            { return _array; }
 872 
 873   // generic
 874   virtual bool can_trap() const                  { return needs_null_check(); }
 875   virtual void input_values_do(ValueVisitor* f)   { f->visit(&_array); }
 876 };
 877 
 878 
 879 LEAF(ArrayLength, AccessArray)
 880  private:
 881   NullCheck*  _explicit_null_check;              // For explicit null check elimination
 882 
 883  public:
 884   // creation
 885   ArrayLength(Value array, ValueStack* state_before)
 886   : AccessArray(intType, array, state_before)
 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); }
1014 };
1015 
1016 
1017 BASE(Op2, Instruction)
1018  private:
1019   Bytecodes::Code _op;
1020   Value           _x;
1021   Value           _y;
1022 
1023  public:
1024   // creation
1025   Op2(ValueType* type, Bytecodes::Code op, Value x, Value y, ValueStack* state_before = NULL)
1026   : Instruction(type, state_before)
1027   , _op(op)
1028   , _x(x)
1029   , _y(y)
1030   {
1031     ASSERT_VALUES
1032   }
1033 
1034   // accessors
1035   Bytecodes::Code op() const                     { return _op; }
1036   Value x() const                                { return _x; }
1037   Value y() const                                { return _y; }
1038 
1039   // manipulators
1040   void swap_operands() {
1041     assert(is_commutative(), "operation must be commutative");
1042     Value t = _x; _x = _y; _y = t;
1043   }
1044 
1045   // generic
1046   virtual bool is_commutative() const            { return false; }
1047   virtual void input_values_do(ValueVisitor* f)   { f->visit(&_x); f->visit(&_y); }
1048 };
1049 
1050 
1051 LEAF(ArithmeticOp, Op2)
1052  public:
1053   // creation
1054   ArithmeticOp(Bytecodes::Code op, Value x, Value y, ValueStack* state_before)
1055   : Op2(x->type()->meet(y->type()), op, x, y, state_before)
1056   {
1057     if (can_trap()) pin();
1058   }
1059 
1060   // generic
1061   virtual bool is_commutative() const;
1062   virtual bool can_trap() const;
1063   HASHING3(Op2, true, op(), x()->subst(), y()->subst())
1064 };
1065 
1066 
1067 LEAF(ShiftOp, Op2)
1068  public:
1069   // creation
1070   ShiftOp(Bytecodes::Code op, Value x, Value s) : Op2(x->type()->base(), op, x, s) {}
1071 
1072   // generic
1073   HASHING3(Op2, true, op(), x()->subst(), y()->subst())
1074 };
1075 
1076 
1077 LEAF(LogicOp, Op2)
1078  public:
1079   // creation
1080   LogicOp(Bytecodes::Code op, Value x, Value y) : Op2(x->type()->meet(y->type()), op, x, y) {}
1081 
1082   // generic
1083   virtual bool is_commutative() const;
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 
1143   // generic
1144   virtual void input_values_do(ValueVisitor* f)   { f->visit(&_value); }
1145   HASHING2(Convert, true, op(), value()->subst())
1146 };
1147 
1148 
1149 LEAF(NullCheck, Instruction)
1150  private:
1151   Value       _obj;
1152 
1153  public:
1154   // creation
1155   NullCheck(Value obj, ValueStack* state_before)
1156   : Instruction(obj->type()->base(), state_before)
1157   , _obj(obj)
1158   {
1159     ASSERT_VALUES
1160     set_can_trap(true);
1161     assert(_obj->type()->is_object(), "null check must be applied to objects only");
1162     pin(Instruction::PinExplicitNullCheck);
1163   }
1164 
1165   // accessors
1166   Value obj() const                              { return _obj; }
1167 
1168   // setters
1169   void set_can_trap(bool can_trap)               { set_flag(CanTrapFlag, can_trap); }
1170 
1171   // generic
1172   virtual bool can_trap() const                  { return check_flag(CanTrapFlag); /* null-check elimination sets to false */ }
1173   virtual void input_values_do(ValueVisitor* f)   { f->visit(&_obj); }
1174   HASHING1(NullCheck, true, obj()->subst())
1175 };
1176 
1177 
1178 // This node is supposed to cast the type of another node to a more precise
1179 // declared type.
1180 LEAF(TypeCast, Instruction)
1181  private:
1182   ciType* _declared_type;
1183   Value   _obj;
1184 
1185  public:
1186   // The type of this node is the same type as the object type (and it might be constant).
1187   TypeCast(ciType* type, Value obj, ValueStack* state_before)
1188   : Instruction(obj->type(), state_before, obj->type()->is_constant()),
1189     _declared_type(type),
1190     _obj(obj) {}
1191 
1192   // accessors
1193   ciType* declared_type() const                  { return _declared_type; }
1194   Value   obj() const                            { return _obj; }
1195 
1196   // generic
1197   virtual void input_values_do(ValueVisitor* f)  { f->visit(&_obj); }
1198 };
1199 
1200 
1201 BASE(StateSplit, Instruction)
1202  private:
1203   ValueStack* _state;
1204 
1205  protected:
1206   static void substitute(BlockList& list, BlockBegin* old_block, BlockBegin* new_block);
1207 
1208  public:
1209   // creation
1210   StateSplit(ValueType* type, ValueStack* state_before = NULL)
1211   : Instruction(type, state_before)
1212   , _state(NULL)
1213   {
1214     pin(PinStateSplitConstructor);
1215   }
1216 
1217   // accessors
1218   ValueStack* state() const                      { return _state; }
1219   IRScope* scope() const;                        // the state's scope
1220 
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 
1262   virtual bool needs_exception_state() const     { return false; }
1263 
1264   // generic
1265   virtual bool can_trap() const                  { return true; }
1266   virtual void input_values_do(ValueVisitor* f) {
1267     StateSplit::input_values_do(f);
1268     if (has_receiver()) f->visit(&_recv);
1269     for (int i = 0; i < _args->length(); i++) f->visit(_args->adr_at(i));
1270   }
1271   virtual void state_values_do(ValueVisitor *f);
1272 };
1273 
1274 
1275 LEAF(NewInstance, StateSplit)
1276  private:
1277   ciInstanceKlass* _klass;
1278   bool _is_unresolved;
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; }
1319   ciType* declared_type() const;
1320 
1321   // generic
1322   virtual bool can_trap() const                  { return true; }
1323   virtual void input_values_do(ValueVisitor* f)   { StateSplit::input_values_do(f); f->visit(&_length); }
1324 };
1325 
1326 
1327 LEAF(NewTypeArray, NewArray)
1328  private:
1329   BasicType _elt_type;
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; }
1407   Value obj() const                              { return _obj; }
1408   bool is_loaded() const                         { return klass() != NULL; }
1409   bool direct_compare() const                    { return check_flag(DirectCompareFlag); }
1410 
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 };
1453 
1454 
1455 LEAF(InstanceOf, TypeCheck)
1456  public:
1457   // creation
1458   InstanceOf(ciKlass* klass, Value obj, ValueStack* state_before) : TypeCheck(klass, obj, intType, state_before) {}
1459 
1460   virtual bool needs_exception_state() const     { return false; }
1461 };
1462 
1463 
1464 BASE(AccessMonitor, StateSplit)
1465  private:
1466   Value       _obj;
1467   int         _monitor_no;
1468 
1469  public:
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;
1518   Value            _recv;
1519   ArgsNonNullState _nonnull_state;
1520 
1521  public:
1522   // preserves_state can be set to true for Intrinsics
1523   // which are guaranteed to preserve register state across any slow
1524   // cases; setting it to true does not mean that the Intrinsic can
1525   // not trap, only that if we continue execution in the same basic
1526   // block after the Intrinsic, all of the registers are intact. This
1527   // allows load elimination and common expression elimination to be
1528   // performed across the Intrinsic.  The default value is false.
1529   Intrinsic(ValueType* type,
1530             vmIntrinsics::ID id,
1531             Values* args,
1532             bool has_receiver,
1533             ValueStack* state_before,
1534             bool preserves_state,
1535             bool cantrap = true)
1536   : StateSplit(type, state_before)
1537   , _id(id)
1538   , _args(args)
1539   , _recv(NULL)
1540   {
1541     assert(args != NULL, "args must exist");
1542     ASSERT_VALUES
1543     set_flag(PreservesStateFlag, preserves_state);
1544     set_flag(CanTrapFlag,        cantrap);
1545     if (has_receiver) {
1546       _recv = argument_at(0);
1547     }
1548     set_needs_null_check(has_receiver);
1549 
1550     // some intrinsics can't trap, so don't force them to be pinned
1551     if (!can_trap() && !vmIntrinsics::should_be_pinned(_id)) {
1552       unpin(PinStateSplitConstructor);
1553     }
1554   }
1555 
1556   // accessors
1557   vmIntrinsics::ID id() const                    { return _id; }
1558   int number_of_arguments() const                { return _args->length(); }
1559   Value argument_at(int i) const                 { return _args->at(i); }
1560 
1561   bool has_receiver() const                      { return (_recv != NULL); }
1562   Value receiver() const                         { assert(has_receiver(), "must have receiver"); return _recv; }
1563   bool preserves_state() const                   { return check_flag(PreservesStateFlag); }
1564 
1565   bool arg_needs_null_check(int i) const {
1566     return _nonnull_state.arg_needs_null_check(i);
1567   }
1568 
1569   void set_arg_needs_null_check(int i, bool check) {
1570     _nonnull_state.set_arg_needs_null_check(i, check);
1571   }
1572 
1573   // generic
1574   virtual bool can_trap() const                  { return check_flag(CanTrapFlag); }
1575   virtual void input_values_do(ValueVisitor* f) {
1576     StateSplit::input_values_do(f);
1577     for (int i = 0; i < _args->length(); i++) f->visit(_args->adr_at(i));
1578   }
1579 };
1580 
1581 
1582 class LIR_List;
1583 
1584 LEAF(BlockBegin, StateSplit)
1585  private:
1586   int        _block_id;                          // the unique block id
1587   int        _bci;                               // start-bci of block
1588   int        _depth_first_number;                // number of this block in a depth-first ordering
1589   int        _linear_scan_number;                // number of this block in linear-scan ordering
1590   int        _dominator_depth;
1591   int        _loop_depth;                        // the loop nesting level of this block
1592   int        _loop_index;                        // number of the innermost loop of this block
1593   int        _flags;                             // the flags associated with this block
1594 
1595   // fields used by BlockListBuilder
1596   int            _total_preds;                   // number of predecessors found by BlockListBuilder
1597   ResourceBitMap _stores_to_locals;              // bit is set when a local variable is stored in the block
1598 
1599   // SSA specific fields: (factor out later)
1600   BlockList   _predecessors;                     // the predecessors of this block
1601   BlockList   _dominates;                        // list of blocks that are dominated by this block
1602   BlockBegin* _dominator;                        // the dominator of this block
1603   // SSA specific ends
1604   BlockEnd*  _end;                               // the last instruction of this block
1605   BlockList  _exception_handlers;                // the exception handlers potentially invoked by this block
1606   ValueStackStack* _exception_states;            // only for xhandler entries: states of all instructions that have an edge to this xhandler
1607   int        _exception_handler_pco;             // if this block is the start of an exception handler,
1608                                                  // this records the PC offset in the assembly code of the
1609                                                  // first instruction in this block
1610   Label      _label;                             // the label associated with this block
1611   LIR_List*  _lir;                               // the low level intermediate representation for this block
1612 
1613   ResourceBitMap _live_in;                       // set of live LIR_Opr registers at entry to this block
1614   ResourceBitMap _live_out;                      // set of live LIR_Opr registers at exit from this block
1615   ResourceBitMap _live_gen;                      // set of registers used before any redefinition in this block
1616   ResourceBitMap _live_kill;                     // set of registers defined in this block
1617 
1618   ResourceBitMap _fpu_register_usage;
1619   intArray*      _fpu_stack_state;               // For x86 FPU code generation with UseLinearScan
1620   int            _first_lir_instruction_id;      // ID of first LIR instruction in this block
1621   int            _last_lir_instruction_id;       // ID of last LIR instruction in this block
1622 
1623   void iterate_preorder (boolArray& mark, BlockClosure* closure);
1624   void iterate_postorder(boolArray& mark, BlockClosure* closure);
1625 
1626   friend class SuxAndWeightAdjuster;
1627 
1628  public:
1629    void* operator new(size_t size) throw() {
1630     Compilation* c = Compilation::current();
1631     void* res = c->arena()->Amalloc(size);
1632     return res;
1633   }
1634 
1635   // initialization/counting
1636   static int  number_of_blocks() {
1637     return Compilation::current()->number_of_blocks();
1638   }
1639 
1640   // creation
1641   BlockBegin(int bci)
1642   : StateSplit(illegalType)
1643   , _block_id(Compilation::current()->get_next_block_id())
1644   , _bci(bci)
1645   , _depth_first_number(-1)
1646   , _linear_scan_number(-1)
1647   , _dominator_depth(-1)
1648   , _loop_depth(0)
1649   , _loop_index(-1)
1650   , _flags(0)
1651   , _total_preds(0)
1652   , _stores_to_locals()
1653   , _predecessors(2)
1654   , _dominates(2)
1655   , _dominator(NULL)
1656   , _end(NULL)
1657   , _exception_handlers(1)
1658   , _exception_states(NULL)
1659   , _exception_handler_pco(-1)
1660   , _lir(NULL)
1661   , _live_in()
1662   , _live_out()
1663   , _live_gen()
1664   , _live_kill()
1665   , _fpu_register_usage()
1666   , _fpu_stack_state(NULL)
1667   , _first_lir_instruction_id(-1)
1668   , _last_lir_instruction_id(-1)
1669   {
1670     _block = this;
1671 #ifndef PRODUCT
1672     set_printable_bci(bci);
1673 #endif
1674   }
1675 
1676   // accessors
1677   int block_id() const                           { return _block_id; }
1678   int bci() const                                { return _bci; }
1679   BlockList* dominates()                         { return &_dominates; }
1680   BlockBegin* dominator() const                  { return _dominator; }
1681   int loop_depth() const                         { return _loop_depth; }
1682   int dominator_depth() const                    { return _dominator_depth; }
1683   int depth_first_number() const                 { return _depth_first_number; }
1684   int linear_scan_number() const                 { return _linear_scan_number; }
1685   BlockEnd* end() const                          { return _end; }
1686   Label* label()                                 { return &_label; }
1687   LIR_List* lir() const                          { return _lir; }
1688   int exception_handler_pco() const              { return _exception_handler_pco; }
1689   ResourceBitMap& live_in()                      { return _live_in;        }
1690   ResourceBitMap& live_out()                     { return _live_out;       }
1691   ResourceBitMap& live_gen()                     { return _live_gen;       }
1692   ResourceBitMap& live_kill()                    { return _live_kill;      }
1693   ResourceBitMap& fpu_register_usage()           { return _fpu_register_usage; }
1694   intArray* fpu_stack_state() const              { return _fpu_stack_state;    }
1695   int first_lir_instruction_id() const           { return _first_lir_instruction_id; }
1696   int last_lir_instruction_id() const            { return _last_lir_instruction_id; }
1697   int total_preds() const                        { return _total_preds; }
1698   BitMap& stores_to_locals()                     { return _stores_to_locals; }
1699 
1700   // manipulation
1701   void set_dominator(BlockBegin* dom)            { _dominator = dom; }
1702   void set_loop_depth(int d)                     { _loop_depth = d; }
1703   void set_dominator_depth(int d)                { _dominator_depth = d; }
1704   void set_depth_first_number(int dfn)           { _depth_first_number = dfn; }
1705   void set_linear_scan_number(int lsn)           { _linear_scan_number = lsn; }
1706   void set_end(BlockEnd* new_end);
1707   static void disconnect_edge(BlockBegin* from, BlockBegin* to);
1708   BlockBegin* insert_block_between(BlockBegin* sux);
1709   void substitute_sux(BlockBegin* old_sux, BlockBegin* new_sux);
1710   void set_lir(LIR_List* lir)                    { _lir = lir; }
1711   void set_exception_handler_pco(int pco)        { _exception_handler_pco = pco; }
1712   void set_live_in  (const ResourceBitMap& map)  { _live_in = map;   }
1713   void set_live_out (const ResourceBitMap& map)  { _live_out = map;  }
1714   void set_live_gen (const ResourceBitMap& map)  { _live_gen = map;  }
1715   void set_live_kill(const ResourceBitMap& map)  { _live_kill = map; }
1716   void set_fpu_register_usage(const ResourceBitMap& map) { _fpu_register_usage = map; }
1717   void set_fpu_stack_state(intArray* state)      { _fpu_stack_state = state;  }
1718   void set_first_lir_instruction_id(int id)      { _first_lir_instruction_id = id;  }
1719   void set_last_lir_instruction_id(int id)       { _last_lir_instruction_id = id;  }
1720   void increment_total_preds(int n = 1)          { _total_preds += n; }
1721   void init_stores_to_locals(int locals_count)   { _stores_to_locals.initialize(locals_count); }
1722 
1723   // generic
1724   virtual void state_values_do(ValueVisitor* f);
1725 
1726   // successors and predecessors
1727   int number_of_sux() const;
1728   BlockBegin* sux_at(int i) const;
1729   void add_predecessor(BlockBegin* pred);
1730   void remove_predecessor(BlockBegin* pred);
1731   bool is_predecessor(BlockBegin* pred) const    { return _predecessors.contains(pred); }
1732   int number_of_preds() const                    { return _predecessors.length(); }
1733   BlockBegin* pred_at(int i) const               { return _predecessors.at(i); }
1734 
1735   // exception handlers potentially invoked by this block
1736   void add_exception_handler(BlockBegin* b);
1737   bool is_exception_handler(BlockBegin* b) const { return _exception_handlers.contains(b); }
1738   int  number_of_exception_handlers() const      { return _exception_handlers.length(); }
1739   BlockBegin* exception_handler_at(int i) const  { return _exception_handlers.at(i); }
1740 
1741   // states of the instructions that have an edge to this exception handler
1742   int number_of_exception_states()               { assert(is_set(exception_entry_flag), "only for xhandlers"); return _exception_states == NULL ? 0 : _exception_states->length(); }
1743   ValueStack* exception_state_at(int idx) const  { assert(is_set(exception_entry_flag), "only for xhandlers"); return _exception_states->at(idx); }
1744   int add_exception_state(ValueStack* state);
1745 
1746   // flags
1747   enum Flag {
1748     no_flag                       = 0,
1749     std_entry_flag                = 1 << 0,
1750     osr_entry_flag                = 1 << 1,
1751     exception_entry_flag          = 1 << 2,
1752     subroutine_entry_flag         = 1 << 3,
1753     backward_branch_target_flag   = 1 << 4,
1754     is_on_work_list_flag          = 1 << 5,
1755     was_visited_flag              = 1 << 6,
1756     parser_loop_header_flag       = 1 << 7,  // set by parser to identify blocks where phi functions can not be created on demand
1757     critical_edge_split_flag      = 1 << 8, // set for all blocks that are introduced when critical edges are split
1758     linear_scan_loop_header_flag  = 1 << 9, // set during loop-detection for LinearScan
1759     linear_scan_loop_end_flag     = 1 << 10, // set during loop-detection for LinearScan
1760     donot_eliminate_range_checks  = 1 << 11  // Should be try to eliminate range checks in this block
1761   };
1762 
1763   void set(Flag f)                               { _flags |= f; }
1764   void clear(Flag f)                             { _flags &= ~f; }
1765   bool is_set(Flag f) const                      { return (_flags & f) != 0; }
1766   bool is_entry_block() const {
1767     const int entry_mask = std_entry_flag | osr_entry_flag | exception_entry_flag;
1768     return (_flags & entry_mask) != 0;
1769   }
1770 
1771   // iteration
1772   void iterate_preorder   (BlockClosure* closure);
1773   void iterate_postorder  (BlockClosure* closure);
1774 
1775   void block_values_do(ValueVisitor* f);
1776 
1777   // loops
1778   void set_loop_index(int ix)                    { _loop_index = ix;        }
1779   int  loop_index() const                        { return _loop_index;      }
1780 
1781   // merging
1782   bool try_merge(ValueStack* state, bool has_irreducible_loops);  // try to merge states at block begin
1783   void merge(ValueStack* state, bool has_irreducible_loops) {
1784     bool b = try_merge(state, has_irreducible_loops);
1785     assert(b, "merge failed");
1786   }
1787 
1788   // debugging
1789   void print_block()                             PRODUCT_RETURN;
1790   void print_block(InstructionPrinter& ip, bool live_only = false) PRODUCT_RETURN;
1791 
1792 };
1793 
1794 
1795 BASE(BlockEnd, StateSplit)
1796  private:
1797   BlockList*  _sux;
1798 
1799  protected:
1800   BlockList* sux() const                         { return _sux; }
1801 
1802   void set_sux(BlockList* sux) {
1803 #ifdef ASSERT
1804     assert(sux != NULL, "sux must exist");
1805     for (int i = sux->length() - 1; i >= 0; i--) assert(sux->at(i) != NULL, "sux must exist");
1806 #endif
1807     _sux = sux;
1808   }
1809 
1810  public:
1811   // creation
1812   BlockEnd(ValueType* type, ValueStack* state_before, bool is_safepoint)
1813   : StateSplit(type, state_before)
1814   , _sux(NULL)
1815   {
1816     set_flag(IsSafepointFlag, is_safepoint);
1817   }
1818 
1819   // accessors
1820   bool is_safepoint() const                      { return check_flag(IsSafepointFlag); }
1821   // For compatibility with old code, for new code use block()
1822   BlockBegin* begin() const                      { return _block; }
1823 
1824   // manipulation
1825   inline void remove_sux_at(int i) { _sux->remove_at(i);}
1826   inline int find_sux(BlockBegin* sux) {return _sux->find(sux);}
1827 
1828   // successors
1829   int number_of_sux() const                      { return _sux != NULL ? _sux->length() : 0; }
1830   BlockBegin* sux_at(int i) const                { return _sux->at(i); }
1831   bool is_sux(BlockBegin* sux) const             { return _sux == NULL ? false : _sux->contains(sux); }
1832   BlockBegin* default_sux() const                { return sux_at(number_of_sux() - 1); }
1833   void substitute_sux(BlockBegin* old_sux, BlockBegin* new_sux);
1834 };
1835 
1836 
1837 LEAF(Goto, BlockEnd)
1838  public:
1839   enum Direction {
1840     none,            // Just a regular goto
1841     taken, not_taken // Goto produced from If
1842   };
1843  private:
1844   ciMethod*   _profiled_method;
1845   int         _profiled_bci;
1846   Direction   _direction;
1847  public:
1848   // creation
1849   Goto(BlockBegin* sux, ValueStack* state_before, bool is_safepoint = false)
1850     : BlockEnd(illegalType, state_before, is_safepoint)
1851     , _profiled_method(NULL)
1852     , _profiled_bci(0)
1853     , _direction(none) {
1854     BlockList* s = new BlockList(1);
1855     s->append(sux);
1856     set_sux(s);
1857   }
1858 
1859   Goto(BlockBegin* sux, bool is_safepoint) : BlockEnd(illegalType, NULL, is_safepoint)
1860                                            , _profiled_method(NULL)
1861                                            , _profiled_bci(0)
1862                                            , _direction(none) {
1863     BlockList* s = new BlockList(1);
1864     s->append(sux);
1865     set_sux(s);
1866   }
1867 
1868   bool should_profile() const                    { return check_flag(ProfileMDOFlag); }
1869   ciMethod* profiled_method() const              { return _profiled_method; } // set only for profiled branches
1870   int profiled_bci() const                       { return _profiled_bci; }
1871   Direction direction() const                    { return _direction; }
1872 
1873   void set_should_profile(bool value)            { set_flag(ProfileMDOFlag, value); }
1874   void set_profiled_method(ciMethod* method)     { _profiled_method = method; }
1875   void set_profiled_bci(int bci)                 { _profiled_bci = bci; }
1876   void set_direction(Direction d)                { _direction = d; }
1877 };
1878 
1879 #ifdef ASSERT
1880 LEAF(Assert, Instruction)
1881   private:
1882   Value       _x;
1883   Condition   _cond;
1884   Value       _y;
1885   char        *_message;
1886 
1887  public:
1888   // creation
1889   // unordered_is_true is valid for float/double compares only
1890    Assert(Value x, Condition cond, bool unordered_is_true, Value y);
1891 
1892   // accessors
1893   Value x() const                                { return _x; }
1894   Condition cond() const                         { return _cond; }
1895   bool unordered_is_true() const                 { return check_flag(UnorderedIsTrueFlag); }
1896   Value y() const                                { return _y; }
1897   const char *message() const                    { return _message; }
1898 
1899   // generic
1900   virtual void input_values_do(ValueVisitor* f)  { f->visit(&_x); f->visit(&_y); }
1901 };
1902 #endif
1903 
1904 LEAF(RangeCheckPredicate, StateSplit)
1905  private:
1906   Value       _x;
1907   Condition   _cond;
1908   Value       _y;
1909 
1910   void check_state();
1911 
1912  public:
1913   // creation
1914   // unordered_is_true is valid for float/double compares only
1915    RangeCheckPredicate(Value x, Condition cond, bool unordered_is_true, Value y, ValueStack* state) : StateSplit(illegalType)
1916   , _x(x)
1917   , _cond(cond)
1918   , _y(y)
1919   {
1920     ASSERT_VALUES
1921     set_flag(UnorderedIsTrueFlag, unordered_is_true);
1922     assert(x->type()->tag() == y->type()->tag(), "types must match");
1923     this->set_state(state);
1924     check_state();
1925   }
1926 
1927   // Always deoptimize
1928   RangeCheckPredicate(ValueStack* state) : StateSplit(illegalType)
1929   {
1930     this->set_state(state);
1931     _x = _y = NULL;
1932     check_state();
1933   }
1934 
1935   // accessors
1936   Value x() const                                { return _x; }
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; }
2022   int length() const                             { return number_of_sux() - 1; }
2023 
2024   virtual bool needs_exception_state() const     { return false; }
2025 
2026   // generic
2027   virtual void input_values_do(ValueVisitor* f)   { BlockEnd::input_values_do(f); f->visit(&_tag); }
2028 };
2029 
2030 
2031 LEAF(TableSwitch, Switch)
2032  private:
2033   int _lo_key;
2034 
2035  public:
2036   // creation
2037   TableSwitch(Value tag, BlockList* sux, int lo_key, ValueStack* state_before, bool is_safepoint)
2038     : Switch(tag, sux, state_before, is_safepoint)
2039   , _lo_key(lo_key) { assert(_lo_key <= hi_key(), "integer overflow"); }
2040 
2041   // accessors
2042   int lo_key() const                             { return _lo_key; }
2043   int hi_key() const                             { return _lo_key + (length() - 1); }
2044 };
2045 
2046 
2047 LEAF(LookupSwitch, Switch)
2048  private:
2049   intArray* _keys;
2050 
2051  public:
2052   // creation
2053   LookupSwitch(Value tag, BlockList* sux, intArray* keys, ValueStack* state_before, bool is_safepoint)
2054   : Switch(tag, sux, state_before, is_safepoint)
2055   , _keys(keys) {
2056     assert(keys != NULL, "keys must exist");
2057     assert(keys->length() == length(), "sux & keys have incompatible lengths");
2058   }
2059 
2060   // accessors
2061   int key_at(int i) const                        { return _keys->at(i); }
2062 };
2063 
2064 
2065 LEAF(Return, BlockEnd)
2066  private:
2067   Value _result;
2068 
2069  public:
2070   // creation
2071   Return(Value result) :
2072     BlockEnd(result == NULL ? voidType : result->type()->base(), NULL, true),
2073     _result(result) {}
2074 
2075   // accessors
2076   Value result() const                           { return _result; }
2077   bool has_result() const                        { return result() != NULL; }
2078 
2079   // generic
2080   virtual void input_values_do(ValueVisitor* f) {
2081     BlockEnd::input_values_do(f);
2082     if (has_result()) f->visit(&_result);
2083   }
2084 };
2085 
2086 
2087 LEAF(Throw, BlockEnd)
2088  private:
2089   Value _exception;
2090 
2091  public:
2092   // creation
2093   Throw(Value exception, ValueStack* state_before) : BlockEnd(illegalType, state_before, true), _exception(exception) {
2094     ASSERT_VALUES
2095   }
2096 
2097   // accessors
2098   Value exception() const                        { return _exception; }
2099 
2100   // generic
2101   virtual bool can_trap() const                  { return true; }
2102   virtual void input_values_do(ValueVisitor* f)   { BlockEnd::input_values_do(f); f->visit(&_exception); }
2103 };
2104 
2105 
2106 LEAF(Base, BlockEnd)
2107  public:
2108   // creation
2109   Base(BlockBegin* std_entry, BlockBegin* osr_entry) : BlockEnd(illegalType, NULL, false) {
2110     assert(std_entry->is_set(BlockBegin::std_entry_flag), "std entry must be flagged");
2111     assert(osr_entry == NULL || osr_entry->is_set(BlockBegin::osr_entry_flag), "osr entry must be flagged");
2112     BlockList* s = new BlockList(2);
2113     if (osr_entry != NULL) s->append(osr_entry);
2114     s->append(std_entry); // must be default sux!
2115     set_sux(s);
2116   }
2117 
2118   // accessors
2119   BlockBegin* std_entry() const                  { return default_sux(); }
2120   BlockBegin* osr_entry() const                  { return number_of_sux() < 2 ? NULL : sux_at(0); }
2121 };
2122 
2123 
2124 LEAF(OsrEntry, Instruction)
2125  public:
2126   // creation
2127 #ifdef _LP64
2128   OsrEntry() : Instruction(longType) { pin(); }
2129 #else
2130   OsrEntry() : Instruction(intType)  { pin(); }
2131 #endif
2132 
2133   // generic
2134   virtual void input_values_do(ValueVisitor* f)   { }
2135 };
2136 
2137 
2138 // Models the incoming exception at a catch site
2139 LEAF(ExceptionObject, Instruction)
2140  public:
2141   // creation
2142   ExceptionObject() : Instruction(objectType) {
2143     pin();
2144   }
2145 
2146   // generic
2147   virtual void input_values_do(ValueVisitor* f)   { }
2148 };
2149 
2150 
2151 // Models needed rounding for floating-point values on Intel.
2152 // Currently only used to represent rounding of double-precision
2153 // values stored into local variables, but could be used to model
2154 // intermediate rounding of single-precision values as well.
2155 LEAF(RoundFP, Instruction)
2156  private:
2157   Value _input;             // floating-point value to be rounded
2158 
2159  public:
2160   RoundFP(Value input)
2161   : Instruction(input->type()) // Note: should not be used for constants
2162   , _input(input)
2163   {
2164     ASSERT_VALUES
2165   }
2166 
2167   // accessors
2168   Value input() const                            { return _input; }
2169 
2170   // generic
2171   virtual void input_values_do(ValueVisitor* f)   { f->visit(&_input); }
2172 };
2173 
2174 
2175 BASE(UnsafeOp, Instruction)
2176  private:
2177   Value _object;                                 // Object to be fetched from or mutated
2178   Value _offset;                                 // Offset within object
2179   bool  _is_volatile;                            // true if volatile - dl/JSR166
2180   BasicType _basic_type;                         // ValueType can not express byte-sized integers
2181 
2182  protected:
2183   // creation
2184   UnsafeOp(BasicType basic_type, Value object, Value offset, bool is_put, bool is_volatile)
2185     : Instruction(is_put ? voidType : as_ValueType(basic_type)),
2186     _object(object), _offset(offset), _is_volatile(is_volatile), _basic_type(basic_type)
2187   {
2188     //Note:  Unsafe ops are not not guaranteed to throw NPE.
2189     // Convservatively, Unsafe operations must be pinned though we could be
2190     // looser about this if we wanted to..
2191     pin();
2192   }
2193 
2194  public:
2195   // accessors
2196   BasicType basic_type()                         { return _basic_type; }
2197   Value object()                                 { return _object; }
2198   Value offset()                                 { return _offset; }
2199   bool  is_volatile()                            { return _is_volatile; }
2200 
2201   // generic
2202   virtual void input_values_do(ValueVisitor* f)   { f->visit(&_object);
2203                                                     f->visit(&_offset); }
2204 };
2205 
2206 LEAF(UnsafeGet, UnsafeOp)
2207  private:
2208   bool _is_raw;
2209  public:
2210   UnsafeGet(BasicType basic_type, Value object, Value offset, bool is_volatile)
2211   : UnsafeOp(basic_type, object, offset, false, is_volatile)
2212   {
2213     ASSERT_VALUES
2214     _is_raw = false;
2215   }
2216   UnsafeGet(BasicType basic_type, Value object, Value offset, bool is_volatile, bool is_raw)
2217   : UnsafeOp(basic_type, object, offset, false, is_volatile), _is_raw(is_raw)
2218   {
2219     ASSERT_VALUES
2220   }
2221 
2222   // accessors
2223   bool is_raw()                             { return _is_raw; }
2224 };
2225 
2226 
2227 LEAF(UnsafePut, UnsafeOp)
2228  private:
2229   Value _value;                                  // Value to be stored
2230  public:
2231   UnsafePut(BasicType basic_type, Value object, Value offset, Value value, bool is_volatile)
2232   : UnsafeOp(basic_type, object, offset, true, is_volatile)
2233     , _value(value)
2234   {
2235     ASSERT_VALUES
2236   }
2237 
2238   // accessors
2239   Value value()                                  { return _value; }
2240 
2241   // generic
2242   virtual void input_values_do(ValueVisitor* f)   { UnsafeOp::input_values_do(f);
2243                                                    f->visit(&_value); }
2244 };
2245 
2246 LEAF(UnsafeGetAndSet, UnsafeOp)
2247  private:
2248   Value _value;                                  // Value to be stored
2249   bool  _is_add;
2250  public:
2251   UnsafeGetAndSet(BasicType basic_type, Value object, Value offset, Value value, bool is_add)
2252   : UnsafeOp(basic_type, object, offset, false, false)
2253     , _value(value)
2254     , _is_add(is_add)
2255   {
2256     ASSERT_VALUES
2257   }
2258 
2259   // accessors
2260   bool is_add() const                            { return _is_add; }
2261   Value value()                                  { return _value; }
2262 
2263   // generic
2264   virtual void input_values_do(ValueVisitor* f)   { UnsafeOp::input_values_do(f);
2265                                                    f->visit(&_value); }
2266 };
2267 
2268 LEAF(ProfileCall, Instruction)
2269  private:
2270   ciMethod*        _method;
2271   int              _bci_of_invoke;
2272   ciMethod*        _callee;         // the method that is called at the given bci
2273   Value            _recv;
2274   ciKlass*         _known_holder;
2275   Values*          _obj_args;       // arguments for type profiling
2276   ArgsNonNullState _nonnull_state;  // Do we know whether some arguments are never null?
2277   bool             _inlined;        // Are we profiling a call that is inlined
2278 
2279  public:
2280   ProfileCall(ciMethod* method, int bci, ciMethod* callee, Value recv, ciKlass* known_holder, Values* obj_args, bool inlined)
2281     : Instruction(voidType)
2282     , _method(method)
2283     , _bci_of_invoke(bci)
2284     , _callee(callee)
2285     , _recv(recv)
2286     , _known_holder(known_holder)
2287     , _obj_args(obj_args)
2288     , _inlined(inlined)
2289   {
2290     // The ProfileCall has side-effects and must occur precisely where located
2291     pin();
2292   }
2293 
2294   ciMethod* method()             const { return _method; }
2295   int bci_of_invoke()            const { return _bci_of_invoke; }
2296   ciMethod* callee()             const { return _callee; }
2297   Value recv()                   const { return _recv; }
2298   ciKlass* known_holder()        const { return _known_holder; }
2299   int nb_profiled_args()         const { return _obj_args == NULL ? 0 : _obj_args->length(); }
2300   Value profiled_arg_at(int i)   const { return _obj_args->at(i); }
2301   bool arg_needs_null_check(int i) const {
2302     return _nonnull_state.arg_needs_null_check(i);
2303   }
2304   bool inlined()                 const { return _inlined; }
2305 
2306   void set_arg_needs_null_check(int i, bool check) {
2307     _nonnull_state.set_arg_needs_null_check(i, check);
2308   }
2309 
2310   virtual void input_values_do(ValueVisitor* f)   {
2311     if (_recv != NULL) {
2312       f->visit(&_recv);
2313     }
2314     for (int i = 0; i < nb_profiled_args(); i++) {
2315       f->visit(_obj_args->adr_at(i));
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 
2372   const char* entry_name() const  { return _entry_name; }
2373   address entry() const           { return _entry; }
2374   int number_of_arguments() const { return _args->length(); }
2375   Value argument_at(int i) const  { return _args->at(i); }
2376   bool pass_thread() const        { return _pass_thread; }
2377 
2378   virtual void input_values_do(ValueVisitor* f)   {
2379     for (int i = 0; i < _args->length(); i++) f->visit(_args->adr_at(i));
2380   }
2381 };
2382 
2383 // Use to trip invocation counter of an inlined method
2384 
2385 LEAF(ProfileInvoke, Instruction)
2386  private:
2387   ciMethod*   _inlinee;
2388   ValueStack* _state;
2389 
2390  public:
2391   ProfileInvoke(ciMethod* inlinee,  ValueStack* state)
2392     : Instruction(voidType)
2393     , _inlinee(inlinee)
2394     , _state(state)
2395   {
2396     // The ProfileInvoke has side-effects and must occur precisely where located QQQ???
2397     pin();
2398   }
2399 
2400   ciMethod* inlinee()      { return _inlinee; }
2401   ValueStack* state()      { return _state; }
2402   virtual void input_values_do(ValueVisitor*)   {}
2403   virtual void state_values_do(ValueVisitor*);
2404 };
2405 
2406 LEAF(MemBar, Instruction)
2407  private:
2408   LIR_Code _code;
2409 
2410  public:
2411   MemBar(LIR_Code code)
2412     : Instruction(voidType)
2413     , _code(code)
2414   {
2415     pin();
2416   }
2417 
2418   LIR_Code code()           { return _code; }
2419 
2420   virtual void input_values_do(ValueVisitor*)   {}
2421 };
2422 
2423 class BlockPair: public CompilationResourceObj {
2424  private:
2425   BlockBegin* _from;
2426   BlockBegin* _to;
2427  public:
2428   BlockPair(BlockBegin* from, BlockBegin* to): _from(from), _to(to) {}
2429   BlockBegin* from() const { return _from; }
2430   BlockBegin* to() const   { return _to;   }
2431   bool is_same(BlockBegin* from, BlockBegin* to) const { return  _from == from && _to == to; }
2432   bool is_same(BlockPair* p) const { return  _from == p->from() && _to == p->to(); }
2433   void set_to(BlockBegin* b)   { _to = b; }
2434   void set_from(BlockBegin* b) { _from = b; }
2435 };
2436 
2437 typedef GrowableArray<BlockPair*> BlockPairList;
2438 
2439 inline int         BlockBegin::number_of_sux() const            { assert(_end != NULL, "need end"); return _end->number_of_sux(); }
2440 inline BlockBegin* BlockBegin::sux_at(int i) const              { assert(_end != NULL , "need end"); return _end->sux_at(i); }
2441 
2442 #undef ASSERT_VALUES
2443 
2444 #endif // SHARE_C1_C1_INSTRUCTION_HPP