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