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