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