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