jdk8-mips64-public/hotspot: src/share/vm/c1/c1_Instruction.hpp@ba263cfb7611 (annotated)

src/share/vm/c1/c1_Instruction.hpp@ba263cfb7611 (annotated)

src/share/vm/c1/c1_Instruction.hpp

Fri, 29 Jan 2010 12:13:05 +0100

author: twisti
date: Fri, 29 Jan 2010 12:13:05 +0100
changeset 1635: ba263cfb7611
parent 435: a61af66fc99e
child 1730: 3cf667df43ef
permissions: -rw-r--r--

6917766: JSR 292 needs its own deopt handler
Summary: We need to introduce a new MH deopt handler so we can easily determine if the deopt happened at a MH call site or not.
Reviewed-by: never, jrose

 /*
  * Copyright 1999-2006 Sun Microsystems, Inc.  All Rights Reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  * CA 95054 USA or visit www.sun.com if you need additional information or
  * have any questions.
  *
  */
 // Predefined classes
 class ciField;
 class ValueStack;
 class InstructionPrinter;
 class IRScope;
 class LIR_OprDesc;
 typedef LIR_OprDesc* LIR_Opr;
 // Instruction class hierarchy
 //
 // All leaf classes in the class hierarchy are concrete classes
 // (i.e., are instantiated). All other classes are abstract and
 // serve factoring.
 class Instruction;
 class   HiWord;
 class   Phi;
 class   Local;
 class   Constant;
 class   AccessField;
 class     LoadField;
 class     StoreField;
 class   AccessArray;
 class     ArrayLength;
 class     AccessIndexed;
 class       LoadIndexed;
 class       StoreIndexed;
 class   NegateOp;
 class   Op2;
 class     ArithmeticOp;
 class     ShiftOp;
 class     LogicOp;
 class     CompareOp;
 class     IfOp;
 class   Convert;
 class   NullCheck;
 class   OsrEntry;
 class   ExceptionObject;
 class   StateSplit;
 class     Invoke;
 class     NewInstance;
 class     NewArray;
 class       NewTypeArray;
 class       NewObjectArray;
 class       NewMultiArray;
 class     TypeCheck;
 class       CheckCast;
 class       InstanceOf;
 class     AccessMonitor;
 class       MonitorEnter;
 class       MonitorExit;
 class     Intrinsic;
 class     BlockBegin;
 class     BlockEnd;
 class       Goto;
 class       If;
 class       IfInstanceOf;
 class       Switch;
 class         TableSwitch;
 class         LookupSwitch;
 class       Return;
 class       Throw;
 class       Base;
 class   RoundFP;
 class   UnsafeOp;
 class     UnsafeRawOp;
 class       UnsafeGetRaw;
 class       UnsafePutRaw;
 class     UnsafeObjectOp;
 class       UnsafeGetObject;
 class       UnsafePutObject;
 class       UnsafePrefetch;
 class         UnsafePrefetchRead;
 class         UnsafePrefetchWrite;
 class   ProfileCall;
 class   ProfileCounter;
 // A Value is a reference to the instruction creating the value
 typedef Instruction* Value;
 define_array(ValueArray, Value)
 define_stack(Values, ValueArray)
 define_array(ValueStackArray, ValueStack*)
 define_stack(ValueStackStack, ValueStackArray)
 // BlockClosure is the base class for block traversal/iteration.
 class BlockClosure: public CompilationResourceObj {
  public:
   virtual void block_do(BlockBegin* block)       = 0;
 };
 // Some array and list classes
 define_array(BlockBeginArray, BlockBegin*)
 define_stack(_BlockList, BlockBeginArray)
 class BlockList: public _BlockList {
  public:
   BlockList(): _BlockList() {}
   BlockList(const int size): _BlockList(size) {}
   BlockList(const int size, BlockBegin* init): _BlockList(size, init) {}
   void iterate_forward(BlockClosure* closure);
   void iterate_backward(BlockClosure* closure);
   void blocks_do(void f(BlockBegin*));
   void values_do(void f(Value*));
   void print(bool cfg_only = false, bool live_only = false) PRODUCT_RETURN;
 };
 // InstructionVisitors provide type-based dispatch for instructions.
 // For each concrete Instruction class X, a virtual function do_X is
 // provided. Functionality that needs to be implemented for all classes
 // (e.g., printing, code generation) is factored out into a specialised
 // visitor instead of added to the Instruction classes itself.
 class InstructionVisitor: public StackObj {
  public:
           void do_HiWord         (HiWord*          x) { ShouldNotReachHere(); }
   virtual void do_Phi            (Phi*             x) = 0;
   virtual void do_Local          (Local*           x) = 0;
   virtual void do_Constant       (Constant*        x) = 0;
   virtual void do_LoadField      (LoadField*       x) = 0;
   virtual void do_StoreField     (StoreField*      x) = 0;
   virtual void do_ArrayLength    (ArrayLength*     x) = 0;
   virtual void do_LoadIndexed    (LoadIndexed*     x) = 0;
   virtual void do_StoreIndexed   (StoreIndexed*    x) = 0;
   virtual void do_NegateOp       (NegateOp*        x) = 0;
   virtual void do_ArithmeticOp   (ArithmeticOp*    x) = 0;
   virtual void do_ShiftOp        (ShiftOp*         x) = 0;
   virtual void do_LogicOp        (LogicOp*         x) = 0;
   virtual void do_CompareOp      (CompareOp*       x) = 0;
   virtual void do_IfOp           (IfOp*            x) = 0;
   virtual void do_Convert        (Convert*         x) = 0;
   virtual void do_NullCheck      (NullCheck*       x) = 0;
   virtual void do_Invoke         (Invoke*          x) = 0;
   virtual void do_NewInstance    (NewInstance*     x) = 0;
   virtual void do_NewTypeArray   (NewTypeArray*    x) = 0;
   virtual void do_NewObjectArray (NewObjectArray*  x) = 0;
   virtual void do_NewMultiArray  (NewMultiArray*   x) = 0;
   virtual void do_CheckCast      (CheckCast*       x) = 0;
   virtual void do_InstanceOf     (InstanceOf*      x) = 0;
   virtual void do_MonitorEnter   (MonitorEnter*    x) = 0;
   virtual void do_MonitorExit    (MonitorExit*     x) = 0;
   virtual void do_Intrinsic      (Intrinsic*       x) = 0;
   virtual void do_BlockBegin     (BlockBegin*      x) = 0;
   virtual void do_Goto           (Goto*            x) = 0;
   virtual void do_If             (If*              x) = 0;
   virtual void do_IfInstanceOf   (IfInstanceOf*    x) = 0;
   virtual void do_TableSwitch    (TableSwitch*     x) = 0;
   virtual void do_LookupSwitch   (LookupSwitch*    x) = 0;
   virtual void do_Return         (Return*          x) = 0;
   virtual void do_Throw          (Throw*           x) = 0;
   virtual void do_Base           (Base*            x) = 0;
   virtual void do_OsrEntry       (OsrEntry*        x) = 0;
   virtual void do_ExceptionObject(ExceptionObject* x) = 0;
   virtual void do_RoundFP        (RoundFP*         x) = 0;
   virtual void do_UnsafeGetRaw   (UnsafeGetRaw*    x) = 0;
   virtual void do_UnsafePutRaw   (UnsafePutRaw*    x) = 0;
   virtual void do_UnsafeGetObject(UnsafeGetObject* x) = 0;
   virtual void do_UnsafePutObject(UnsafePutObject* x) = 0;
   virtual void do_UnsafePrefetchRead (UnsafePrefetchRead*  x) = 0;
   virtual void do_UnsafePrefetchWrite(UnsafePrefetchWrite* x) = 0;
   virtual void do_ProfileCall    (ProfileCall*     x) = 0;
   virtual void do_ProfileCounter (ProfileCounter*  x) = 0;
 };
 // Hashing support
 //
 // Note: This hash functions affect the performance
 //       of ValueMap - make changes carefully!
 #define HASH1(x1            )                    ((intx)(x1))
 #define HASH2(x1, x2        )                    ((HASH1(x1        ) << 7) ^ HASH1(x2))
 #define HASH3(x1, x2, x3    )                    ((HASH2(x1, x2    ) << 7) ^ HASH1(x3))
 #define HASH4(x1, x2, x3, x4)                    ((HASH3(x1, x2, x3) << 7) ^ HASH1(x4))
 // The following macros are used to implement instruction-specific hashing.
 // By default, each instruction implements hash() and is_equal(Value), used
 // for value numbering/common subexpression elimination. The default imple-
 // mentation disables value numbering. Each instruction which can be value-
 // numbered, should define corresponding hash() and is_equal(Value) functions
 // via the macros below. The f arguments specify all the values/op codes, etc.
 // that need to be identical for two instructions to be identical.
 //
 // Note: The default implementation of hash() returns 0 in order to indicate
 //       that the instruction should not be considered for value numbering.
 //       The currently used hash functions do not guarantee that never a 0
 //       is produced. While this is still correct, it may be a performance
 //       bug (no value numbering for that node). However, this situation is
 //       so unlikely, that we are not going to handle it specially.
 #define HASHING1(class_name, enabled, f1)             \
   virtual intx hash() const {                         \
     return (enabled) ? HASH2(name(), f1) : 0;         \
   }                                                   \
   virtual bool is_equal(Value v) const {              \
     if (!(enabled)  ) return false;                   \
     class_name* _v = v->as_##class_name();            \
     if (_v == NULL  ) return false;                   \
     if (f1 != _v->f1) return false;                   \
     return true;                                      \
   }                                                   \
 #define HASHING2(class_name, enabled, f1, f2)         \
   virtual intx hash() const {                         \
     return (enabled) ? HASH3(name(), f1, f2) : 0;     \
   }                                                   \
   virtual bool is_equal(Value v) const {              \
     if (!(enabled)  ) return false;                   \
     class_name* _v = v->as_##class_name();            \
     if (_v == NULL  ) return false;                   \
     if (f1 != _v->f1) return false;                   \
     if (f2 != _v->f2) return false;                   \
     return true;                                      \
   }                                                   \
 #define HASHING3(class_name, enabled, f1, f2, f3)     \
   virtual intx hash() const {                          \
     return (enabled) ? HASH4(name(), f1, f2, f3) : 0; \
   }                                                   \
   virtual bool is_equal(Value v) const {              \
     if (!(enabled)  ) return false;                   \
     class_name* _v = v->as_##class_name();            \
     if (_v == NULL  ) return false;                   \
     if (f1 != _v->f1) return false;                   \
     if (f2 != _v->f2) return false;                   \
     if (f3 != _v->f3) return false;                   \
     return true;                                      \
   }                                                   \
 // The mother of all instructions...
 class Instruction: public CompilationResourceObj {
  private:
   static int   _next_id;                         // the node counter
   int          _id;                              // the unique instruction id
   int          _bci;                             // the instruction bci
   int          _use_count;                       // the number of instructions refering to this value (w/o prev/next); only roots can have use count = 0 or > 1
   int          _pin_state;                       // set of PinReason describing the reason for pinning
   ValueType*   _type;                            // the instruction value type
   Instruction* _next;                            // the next instruction if any (NULL for BlockEnd instructions)
   Instruction* _subst;                           // the substitution instruction if any
   LIR_Opr      _operand;                         // LIR specific information
   unsigned int _flags;                           // Flag bits
   XHandlers*   _exception_handlers;              // Flat list of exception handlers covering this instruction
 #ifdef ASSERT
   HiWord*      _hi_word;
 #endif
   friend class UseCountComputer;
  protected:
   void set_bci(int bci)                          { assert(bci == SynchronizationEntryBCI || bci >= 0, "illegal bci"); _bci = bci; }
   void set_type(ValueType* type) {
     assert(type != NULL, "type must exist");
     _type = type;
   }
  public:
   enum InstructionFlag {
     NeedsNullCheckFlag = 0,
     CanTrapFlag,
     DirectCompareFlag,
     IsEliminatedFlag,
     IsInitializedFlag,
     IsLoadedFlag,
     IsSafepointFlag,
     IsStaticFlag,
     IsStrictfpFlag,
     NeedsStoreCheckFlag,
     NeedsWriteBarrierFlag,
     PreservesStateFlag,
     TargetIsFinalFlag,
     TargetIsLoadedFlag,
     TargetIsStrictfpFlag,
     UnorderedIsTrueFlag,
     NeedsPatchingFlag,
     ThrowIncompatibleClassChangeErrorFlag,
     ProfileMDOFlag,
     InstructionLastFlag
   };
  public:
   bool check_flag(InstructionFlag id) const      { return (_flags & (1 << id)) != 0;    }
   void set_flag(InstructionFlag id, bool f)      { _flags = f ? (_flags | (1 << id)) : (_flags & ~(1 << id)); };
   // 'globally' used condition values
   enum Condition {
     eql, neq, lss, leq, gtr, geq
   };
   // Instructions may be pinned for many reasons and under certain conditions
   // with enough knowledge it's possible to safely unpin them.
   enum PinReason {
       PinUnknown           = 1 << 0
     , PinExplicitNullCheck = 1 << 3
     , PinStackForStateSplit= 1 << 12
     , PinStateSplitConstructor= 1 << 13
     , PinGlobalValueNumbering= 1 << 14
   };
   static Condition mirror(Condition cond);
   static Condition negate(Condition cond);
   // initialization
   static void initialize()                       { _next_id = 0; }
   static int number_of_instructions()            { return _next_id; }
   // creation
   Instruction(ValueType* type, bool type_is_constant = false, bool create_hi = true)
   : _id(_next_id++)
   , _bci(-99)
   , _use_count(0)
   , _pin_state(0)
   , _type(type)
   , _next(NULL)
   , _subst(NULL)
   , _flags(0)
   , _operand(LIR_OprFact::illegalOpr)
   , _exception_handlers(NULL)
 #ifdef ASSERT
   , _hi_word(NULL)
 #endif
   {
     assert(type != NULL && (!type->is_constant() || type_is_constant), "type must exist");
 #ifdef ASSERT
     if (create_hi && type->is_double_word()) {
       create_hi_word();
     }
 #endif
   }
   // accessors
   int id() const                                 { return _id; }
   int bci() const                                { return _bci; }
   int use_count() const                          { return _use_count; }
   int pin_state() const                          { return _pin_state; }
   bool is_pinned() const                         { return _pin_state != 0 || PinAllInstructions; }
   ValueType* type() const                        { return _type; }
   Instruction* prev(BlockBegin* block);          // use carefully, expensive operation
   Instruction* next() const                      { return _next; }
   bool has_subst() const                         { return _subst != NULL; }
   Instruction* subst()                           { return _subst == NULL ? this : _subst->subst(); }
   LIR_Opr operand() const                        { return _operand; }
   void set_needs_null_check(bool f)              { set_flag(NeedsNullCheckFlag, f); }
   bool needs_null_check() const                  { return check_flag(NeedsNullCheckFlag); }
   bool has_uses() const                          { return use_count() > 0; }
   bool is_root() const                           { return is_pinned() || use_count() > 1; }
   XHandlers* exception_handlers() const          { return _exception_handlers; }
   // manipulation
   void pin(PinReason reason)                     { _pin_state |= reason; }
   void pin()                                     { _pin_state |= PinUnknown; }
   // DANGEROUS: only used by EliminateStores
   void unpin(PinReason reason)                   { assert((reason & PinUnknown) == 0, "can't unpin unknown state"); _pin_state &= ~reason; }
   virtual void set_lock_stack(ValueStack* l)     { /* do nothing*/ }
   virtual ValueStack* lock_stack() const         { return NULL; }
   Instruction* set_next(Instruction* next, int bci) {
     if (next != NULL) {
       assert(as_BlockEnd() == NULL, "BlockEnd instructions must have no next");
       assert(next->as_Phi() == NULL && next->as_Local() == NULL, "shouldn't link these instructions into list");
       next->set_bci(bci);
     }
     _next = next;
     return next;
   }
   void set_subst(Instruction* subst)             {
     assert(subst == NULL ||
            type()->base() == subst->type()->base() ||
            subst->type()->base() == illegalType, "type can't change");
     _subst = subst;
   }
   void set_exception_handlers(XHandlers *xhandlers) { _exception_handlers = xhandlers; }
 #ifdef ASSERT
   // HiWord is used for debugging and is allocated early to avoid
   // allocation at inconvenient points
   HiWord* hi_word() { return _hi_word; }
   void create_hi_word();
 #endif
   // machine-specifics
   void set_operand(LIR_Opr operand)              { assert(operand != LIR_OprFact::illegalOpr, "operand must exist"); _operand = operand; }
   void clear_operand()                           { _operand = LIR_OprFact::illegalOpr; }
   // generic
   virtual Instruction*      as_Instruction()     { return this; } // to satisfy HASHING1 macro
   virtual HiWord*           as_HiWord()          { return NULL; }
   virtual Phi*           as_Phi()          { return NULL; }
   virtual Local*            as_Local()           { return NULL; }
   virtual Constant*         as_Constant()        { return NULL; }
   virtual AccessField*      as_AccessField()     { return NULL; }
   virtual LoadField*        as_LoadField()       { return NULL; }
   virtual StoreField*       as_StoreField()      { return NULL; }
   virtual AccessArray*      as_AccessArray()     { return NULL; }
   virtual ArrayLength*      as_ArrayLength()     { return NULL; }
   virtual AccessIndexed*    as_AccessIndexed()   { return NULL; }
   virtual LoadIndexed*      as_LoadIndexed()     { return NULL; }
   virtual StoreIndexed*     as_StoreIndexed()    { return NULL; }
   virtual NegateOp*         as_NegateOp()        { return NULL; }
   virtual Op2*              as_Op2()             { return NULL; }
   virtual ArithmeticOp*     as_ArithmeticOp()    { return NULL; }
   virtual ShiftOp*          as_ShiftOp()         { return NULL; }
   virtual LogicOp*          as_LogicOp()         { return NULL; }
   virtual CompareOp*        as_CompareOp()       { return NULL; }
   virtual IfOp*             as_IfOp()            { return NULL; }
   virtual Convert*          as_Convert()         { return NULL; }
   virtual NullCheck*        as_NullCheck()       { return NULL; }
   virtual OsrEntry*         as_OsrEntry()        { return NULL; }
   virtual StateSplit*       as_StateSplit()      { return NULL; }
   virtual Invoke*           as_Invoke()          { return NULL; }
   virtual NewInstance*      as_NewInstance()     { return NULL; }
   virtual NewArray*         as_NewArray()        { return NULL; }
   virtual NewTypeArray*     as_NewTypeArray()    { return NULL; }
   virtual NewObjectArray*   as_NewObjectArray()  { return NULL; }
   virtual NewMultiArray*    as_NewMultiArray()   { return NULL; }
   virtual TypeCheck*        as_TypeCheck()       { return NULL; }
   virtual CheckCast*        as_CheckCast()       { return NULL; }
   virtual InstanceOf*       as_InstanceOf()      { return NULL; }
   virtual AccessMonitor*    as_AccessMonitor()   { return NULL; }
   virtual MonitorEnter*     as_MonitorEnter()    { return NULL; }
   virtual MonitorExit*      as_MonitorExit()     { return NULL; }
   virtual Intrinsic*        as_Intrinsic()       { return NULL; }
   virtual BlockBegin*       as_BlockBegin()      { return NULL; }
   virtual BlockEnd*         as_BlockEnd()        { return NULL; }
   virtual Goto*             as_Goto()            { return NULL; }
   virtual If*               as_If()              { return NULL; }
   virtual IfInstanceOf*     as_IfInstanceOf()    { return NULL; }
   virtual TableSwitch*      as_TableSwitch()     { return NULL; }
   virtual LookupSwitch*     as_LookupSwitch()    { return NULL; }
   virtual Return*           as_Return()          { return NULL; }
   virtual Throw*            as_Throw()           { return NULL; }
   virtual Base*             as_Base()            { return NULL; }
   virtual RoundFP*          as_RoundFP()         { return NULL; }
   virtual ExceptionObject*  as_ExceptionObject() { return NULL; }
   virtual UnsafeOp*         as_UnsafeOp()        { return NULL; }
   virtual void visit(InstructionVisitor* v)      = 0;
   virtual bool can_trap() const                  { return false; }
   virtual void input_values_do(void f(Value*))   = 0;
   virtual void state_values_do(void f(Value*))   { /* usually no state - override on demand */ }
   virtual void other_values_do(void f(Value*))   { /* usually no other - override on demand */ }
           void       values_do(void f(Value*))   { input_values_do(f); state_values_do(f); other_values_do(f); }
   virtual ciType* exact_type() const             { return NULL; }
   virtual ciType* declared_type() const          { return NULL; }
   // hashing
   virtual const char* name() const               = 0;
   HASHING1(Instruction, false, id())             // hashing disabled by default
   // debugging
   void print()                                   PRODUCT_RETURN;
   void print_line()                              PRODUCT_RETURN;
   void print(InstructionPrinter& ip)             PRODUCT_RETURN;
 };
 // The following macros are used to define base (i.e., non-leaf)
 // and leaf instruction classes. They define class-name related
 // generic functionality in one place.
 #define BASE(class_name, super_class_name)       \
   class class_name: public super_class_name {    \
    public:                                       \
     virtual class_name* as_##class_name()        { return this; }              \
 #define LEAF(class_name, super_class_name)       \
   BASE(class_name, super_class_name)             \
    public:                                       \
     virtual const char* name() const             { return #class_name; }       \
     virtual void visit(InstructionVisitor* v)    { v->do_##class_name(this); } \
 // Debugging support
 #ifdef ASSERT
   static void assert_value(Value* x)             { assert((*x) != NULL, "value must exist"); }
   #define ASSERT_VALUES                          values_do(assert_value);
 #else
   #define ASSERT_VALUES
 #endif // ASSERT
 // A HiWord occupies the 'high word' of a 2-word
 // expression stack entry. Hi & lo words must be
 // paired on the expression stack (otherwise the
 // bytecode sequence is illegal). Note that 'hi'
 // refers to the IR expression stack format and
 // does *not* imply a machine word ordering. No
 // HiWords are used in optimized mode for speed,
 // but NULL pointers are used instead.
 LEAF(HiWord, Instruction)
  private:
   Value _lo_word;
  public:
   // creation
   HiWord(Value lo_word)
     : Instruction(illegalType, false, false),
       _lo_word(lo_word) {
     // hi-words are also allowed for illegal lo-words
     assert(lo_word->type()->is_double_word() || lo_word->type()->is_illegal(),
            "HiWord must be used for 2-word values only");
   }
   // accessors
   Value lo_word() const                          { return _lo_word->subst(); }
   // for invalidating of HiWords
   void make_illegal()                            { set_type(illegalType); }
   // generic
   virtual void input_values_do(void f(Value*))   { ShouldNotReachHere(); }
 };
 // A Phi is a phi function in the sense of SSA form. It stands for
 // the value of a local variable at the beginning of a join block.
 // A Phi consists of n operands, one for every incoming branch.
 LEAF(Phi, Instruction)
  private:
   BlockBegin* _block;    // the block to which the phi function belongs
   int         _pf_flags; // the flags of the phi function
   int         _index;    // to value on operand stack (index < 0) or to local
  public:
   // creation
   Phi(ValueType* type, BlockBegin* b, int index)
   : Instruction(type->base())
   , _pf_flags(0)
   , _block(b)
   , _index(index)
   {
     if (type->is_illegal()) {
       make_illegal();
     }
   }
   // flags
   enum Flag {
     no_flag         = 0,
     visited         = 1 << 0,
     cannot_simplify = 1 << 1
   };
   // accessors
   bool  is_local() const          { return _index >= 0; }
   bool  is_on_stack() const       { return !is_local(); }
   int   local_index() const       { assert(is_local(), ""); return _index; }
   int   stack_index() const       { assert(is_on_stack(), ""); return -(_index+1); }
   Value operand_at(int i) const;
   int   operand_count() const;
   BlockBegin* block() const       { return _block; }
   void   set(Flag f)              { _pf_flags |=  f; }
   void   clear(Flag f)            { _pf_flags &= ~f; }
   bool   is_set(Flag f) const     { return (_pf_flags & f) != 0; }
   // Invalidates phis corresponding to merges of locals of two different types
   // (these should never be referenced, otherwise the bytecodes are illegal)
   void   make_illegal() {
     set(cannot_simplify);
     set_type(illegalType);
   }
   bool is_illegal() const {
     return type()->is_illegal();
   }
   // generic
   virtual void input_values_do(void f(Value*)) {
   }
 };
 // A local is a placeholder for an incoming argument to a function call.
 LEAF(Local, Instruction)
  private:
   int      _java_index;                          // the local index within the method to which the local belongs
  public:
   // creation
   Local(ValueType* type, int index)
     : Instruction(type)
     , _java_index(index)
   {}
   // accessors
   int java_index() const                         { return _java_index; }
   // generic
   virtual void input_values_do(void f(Value*))   { /* no values */ }
 };
 LEAF(Constant, Instruction)
   ValueStack* _state;
  public:
   // creation
   Constant(ValueType* type):
       Instruction(type, true)
   , _state(NULL) {
     assert(type->is_constant(), "must be a constant");
   }
   Constant(ValueType* type, ValueStack* state):
     Instruction(type, true)
   , _state(state) {
     assert(state != NULL, "only used for constants which need patching");
     assert(type->is_constant(), "must be a constant");
     // since it's patching it needs to be pinned
     pin();
   }
   ValueStack* state() const               { return _state; }
   // generic
   virtual bool can_trap() const                  { return state() != NULL; }
   virtual void input_values_do(void f(Value*))   { /* no values */ }
   virtual void other_values_do(void f(Value*));
   virtual intx hash() const;
   virtual bool is_equal(Value v) const;
   virtual BlockBegin* compare(Instruction::Condition condition, Value right,
                               BlockBegin* true_sux, BlockBegin* false_sux);
 };
 BASE(AccessField, Instruction)
  private:
   Value       _obj;
   int         _offset;
   ciField*    _field;
   ValueStack* _state_before;                     // state is set only for unloaded or uninitialized fields
   ValueStack* _lock_stack;                       // contains lock and scope information
   NullCheck*  _explicit_null_check;              // For explicit null check elimination
  public:
   // creation
   AccessField(Value obj, int offset, ciField* field, bool is_static, ValueStack* lock_stack,
               ValueStack* state_before, bool is_loaded, bool is_initialized)
   : Instruction(as_ValueType(field->type()->basic_type()))
   , _obj(obj)
   , _offset(offset)
   , _field(field)
   , _lock_stack(lock_stack)
   , _state_before(state_before)
   , _explicit_null_check(NULL)
   {
     set_needs_null_check(!is_static);
     set_flag(IsLoadedFlag, is_loaded);
     set_flag(IsInitializedFlag, is_initialized);
     set_flag(IsStaticFlag, is_static);
     ASSERT_VALUES
       if (!is_loaded || (PatchALot && !field->is_volatile())) {
       // need to patch if the holder wasn't loaded or we're testing
       // using PatchALot.  Don't allow PatchALot for fields which are
       // known to be volatile they aren't patchable.
       set_flag(NeedsPatchingFlag, true);
     }
     // pin of all instructions with memory access
     pin();
   }
   // accessors
   Value obj() const                              { return _obj; }
   int offset() const                             { return _offset; }
   ciField* field() const                         { return _field; }
   BasicType field_type() const                   { return _field->type()->basic_type(); }
   bool is_static() const                         { return check_flag(IsStaticFlag); }
   bool is_loaded() const                         { return check_flag(IsLoadedFlag); }
   bool is_initialized() const                    { return check_flag(IsInitializedFlag); }
   ValueStack* state_before() const               { return _state_before; }
   ValueStack* lock_stack() const                 { return _lock_stack; }
   NullCheck* explicit_null_check() const         { return _explicit_null_check; }
   bool needs_patching() const                    { return check_flag(NeedsPatchingFlag); }
   // manipulation
   void set_lock_stack(ValueStack* l)             { _lock_stack = l; }
   // Under certain circumstances, if a previous NullCheck instruction
   // proved the target object non-null, we can eliminate the explicit
   // null check and do an implicit one, simply specifying the debug
   // information from the NullCheck. This field should only be consulted
   // if needs_null_check() is true.
   void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
   // generic
   virtual bool can_trap() const                  { return needs_null_check() || needs_patching(); }
   virtual void input_values_do(void f(Value*))   { f(&_obj); }
   virtual void other_values_do(void f(Value*));
 };
 LEAF(LoadField, AccessField)
  public:
   // creation
   LoadField(Value obj, int offset, ciField* field, bool is_static, ValueStack* lock_stack,
             ValueStack* state_before, bool is_loaded, bool is_initialized)
   : AccessField(obj, offset, field, is_static, lock_stack, state_before, is_loaded, is_initialized)
   {}
   ciType* declared_type() const;
   ciType* exact_type() const;
   // generic
   HASHING2(LoadField, is_loaded() && !field()->is_volatile(), obj()->subst(), offset())  // cannot be eliminated if not yet loaded or if volatile
 };
 LEAF(StoreField, AccessField)
  private:
   Value _value;
  public:
   // creation
   StoreField(Value obj, int offset, ciField* field, Value value, bool is_static, ValueStack* lock_stack,
              ValueStack* state_before, bool is_loaded, bool is_initialized)
   : AccessField(obj, offset, field, is_static, lock_stack, state_before, is_loaded, is_initialized)
   , _value(value)
   {
     set_flag(NeedsWriteBarrierFlag, as_ValueType(field_type())->is_object());
     ASSERT_VALUES
     pin();
   }
   // accessors
   Value value() const                            { return _value; }
   bool needs_write_barrier() const               { return check_flag(NeedsWriteBarrierFlag); }
   // generic
   virtual void input_values_do(void f(Value*))   { AccessField::input_values_do(f); f(&_value); }
 };
 BASE(AccessArray, Instruction)
  private:
   Value       _array;
   ValueStack* _lock_stack;
  public:
   // creation
   AccessArray(ValueType* type, Value array, ValueStack* lock_stack)
   : Instruction(type)
   , _array(array)
   , _lock_stack(lock_stack) {
     set_needs_null_check(true);
     ASSERT_VALUES
     pin(); // instruction with side effect (null exception or range check throwing)
   }
   Value array() const                            { return _array; }
   ValueStack* lock_stack() const                 { return _lock_stack; }
   // setters
   void set_lock_stack(ValueStack* l)             { _lock_stack = l; }
   // generic
   virtual bool can_trap() const                  { return needs_null_check(); }
   virtual void input_values_do(void f(Value*))   { f(&_array); }
   virtual void other_values_do(void f(Value*));
 };
 LEAF(ArrayLength, AccessArray)
  private:
   NullCheck*  _explicit_null_check;              // For explicit null check elimination
  public:
   // creation
   ArrayLength(Value array, ValueStack* lock_stack)
   : AccessArray(intType, array, lock_stack)
   , _explicit_null_check(NULL) {}
   // accessors
   NullCheck* explicit_null_check() const         { return _explicit_null_check; }
   // setters
   // See LoadField::set_explicit_null_check for documentation
   void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
   // generic
   HASHING1(ArrayLength, true, array()->subst())
 };
 BASE(AccessIndexed, AccessArray)
  private:
   Value     _index;
   Value     _length;
   BasicType _elt_type;
  public:
   // creation
   AccessIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* lock_stack)
   : AccessArray(as_ValueType(elt_type), array, lock_stack)
   , _index(index)
   , _length(length)
   , _elt_type(elt_type)
   {
     ASSERT_VALUES
   }
   // accessors
   Value index() const                            { return _index; }
   Value length() const                           { return _length; }
   BasicType elt_type() const                     { return _elt_type; }
   // perform elimination of range checks involving constants
   bool compute_needs_range_check();
   // generic
   virtual void input_values_do(void f(Value*))   { AccessArray::input_values_do(f); f(&_index); if (_length != NULL) f(&_length); }
 };
 LEAF(LoadIndexed, AccessIndexed)
  private:
   NullCheck*  _explicit_null_check;              // For explicit null check elimination
  public:
   // creation
   LoadIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* lock_stack)
   : AccessIndexed(array, index, length, elt_type, lock_stack)
   , _explicit_null_check(NULL) {}
   // accessors
   NullCheck* explicit_null_check() const         { return _explicit_null_check; }
   // setters
   // See LoadField::set_explicit_null_check for documentation
   void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
   ciType* exact_type() const;
   ciType* declared_type() const;
   // generic
   HASHING2(LoadIndexed, true, array()->subst(), index()->subst())
 };
 LEAF(StoreIndexed, AccessIndexed)
  private:
   Value       _value;
  public:
   // creation
   StoreIndexed(Value array, Value index, Value length, BasicType elt_type, Value value, ValueStack* lock_stack)
   : AccessIndexed(array, index, length, elt_type, lock_stack)
   , _value(value)
   {
     set_flag(NeedsWriteBarrierFlag, (as_ValueType(elt_type)->is_object()));
     set_flag(NeedsStoreCheckFlag, (as_ValueType(elt_type)->is_object()));
     ASSERT_VALUES
     pin();
   }
   // accessors
   Value value() const                            { return _value; }
   IRScope* scope() const;                        // the state's scope
   bool needs_write_barrier() const               { return check_flag(NeedsWriteBarrierFlag); }
   bool needs_store_check() const                 { return check_flag(NeedsStoreCheckFlag); }
   // generic
   virtual void input_values_do(void f(Value*))   { AccessIndexed::input_values_do(f); f(&_value); }
 };
 LEAF(NegateOp, Instruction)
  private:
   Value _x;
  public:
   // creation
   NegateOp(Value x) : Instruction(x->type()->base()), _x(x) {
     ASSERT_VALUES
   }
   // accessors
   Value x() const                                { return _x; }
   // generic
   virtual void input_values_do(void f(Value*))   { f(&_x); }
 };
 BASE(Op2, Instruction)
  private:
   Bytecodes::Code _op;
   Value           _x;
   Value           _y;
  public:
   // creation
   Op2(ValueType* type, Bytecodes::Code op, Value x, Value y) : Instruction(type), _op(op), _x(x), _y(y) {
     ASSERT_VALUES
   }
   // accessors
   Bytecodes::Code op() const                     { return _op; }
   Value x() const                                { return _x; }
   Value y() const                                { return _y; }
   // manipulators
   void swap_operands() {
     assert(is_commutative(), "operation must be commutative");
     Value t = _x; _x = _y; _y = t;
   }
   // generic
   virtual bool is_commutative() const            { return false; }
   virtual void input_values_do(void f(Value*))   { f(&_x); f(&_y); }
 };
 LEAF(ArithmeticOp, Op2)
  private:
   ValueStack* _lock_stack;                       // used only for division operations
  public:
   // creation
   ArithmeticOp(Bytecodes::Code op, Value x, Value y, bool is_strictfp, ValueStack* lock_stack)
   : Op2(x->type()->meet(y->type()), op, x, y)
   ,  _lock_stack(lock_stack) {
     set_flag(IsStrictfpFlag, is_strictfp);
     if (can_trap()) pin();
   }
   // accessors
   ValueStack* lock_stack() const                 { return _lock_stack; }
   bool        is_strictfp() const                { return check_flag(IsStrictfpFlag); }
   // setters
   void set_lock_stack(ValueStack* l)             { _lock_stack = l; }
   // generic
   virtual bool is_commutative() const;
   virtual bool can_trap() const;
   virtual void other_values_do(void f(Value*));
   HASHING3(Op2, true, op(), x()->subst(), y()->subst())
 };
 LEAF(ShiftOp, Op2)
  public:
   // creation
   ShiftOp(Bytecodes::Code op, Value x, Value s) : Op2(x->type()->base(), op, x, s) {}
   // generic
   HASHING3(Op2, true, op(), x()->subst(), y()->subst())
 };
 LEAF(LogicOp, Op2)
  public:
   // creation
   LogicOp(Bytecodes::Code op, Value x, Value y) : Op2(x->type()->meet(y->type()), op, x, y) {}
   // generic
   virtual bool is_commutative() const;
   HASHING3(Op2, true, op(), x()->subst(), y()->subst())
 };
 LEAF(CompareOp, Op2)
  private:
   ValueStack* _state_before;                     // for deoptimization, when canonicalizing
  public:
   // creation
   CompareOp(Bytecodes::Code op, Value x, Value y, ValueStack* state_before)
   : Op2(intType, op, x, y)
   , _state_before(state_before)
   {}
   // accessors
   ValueStack* state_before() const               { return _state_before; }
   // generic
   HASHING3(Op2, true, op(), x()->subst(), y()->subst())
   virtual void other_values_do(void f(Value*));
 };
 LEAF(IfOp, Op2)
  private:
   Value _tval;
   Value _fval;
  public:
   // creation
   IfOp(Value x, Condition cond, Value y, Value tval, Value fval)
   : Op2(tval->type()->meet(fval->type()), (Bytecodes::Code)cond, x, y)
   , _tval(tval)
   , _fval(fval)
   {
     ASSERT_VALUES
     assert(tval->type()->tag() == fval->type()->tag(), "types must match");
   }
   // accessors
   virtual bool is_commutative() const;
   Bytecodes::Code op() const                     { ShouldNotCallThis(); return Bytecodes::_illegal; }
   Condition cond() const                         { return (Condition)Op2::op(); }
   Value tval() const                             { return _tval; }
   Value fval() const                             { return _fval; }
   // generic
   virtual void input_values_do(void f(Value*))   { Op2::input_values_do(f); f(&_tval); f(&_fval); }
 };
 LEAF(Convert, Instruction)
  private:
   Bytecodes::Code _op;
   Value           _value;
  public:
   // creation
   Convert(Bytecodes::Code op, Value value, ValueType* to_type) : Instruction(to_type), _op(op), _value(value) {
     ASSERT_VALUES
   }
   // accessors
   Bytecodes::Code op() const                     { return _op; }
   Value value() const                            { return _value; }
   // generic
   virtual void input_values_do(void f(Value*))   { f(&_value); }
   HASHING2(Convert, true, op(), value()->subst())
 };
 LEAF(NullCheck, Instruction)
  private:
   Value       _obj;
   ValueStack* _lock_stack;
  public:
   // creation
   NullCheck(Value obj, ValueStack* lock_stack) : Instruction(obj->type()->base()), _obj(obj), _lock_stack(lock_stack) {
     ASSERT_VALUES
     set_can_trap(true);
     assert(_obj->type()->is_object(), "null check must be applied to objects only");
     pin(Instruction::PinExplicitNullCheck);
   }
   // accessors
   Value obj() const                              { return _obj; }
   ValueStack* lock_stack() const                 { return _lock_stack; }
   // setters
   void set_lock_stack(ValueStack* l)             { _lock_stack = l; }
   void set_can_trap(bool can_trap)               { set_flag(CanTrapFlag, can_trap); }
   // generic
   virtual bool can_trap() const                  { return check_flag(CanTrapFlag); /* null-check elimination sets to false */ }
   virtual void input_values_do(void f(Value*))   { f(&_obj); }
   virtual void other_values_do(void f(Value*));
   HASHING1(NullCheck, true, obj()->subst())
 };
 BASE(StateSplit, Instruction)
  private:
   ValueStack* _state;
  protected:
   static void substitute(BlockList& list, BlockBegin* old_block, BlockBegin* new_block);
  public:
   // creation
   StateSplit(ValueType* type) : Instruction(type), _state(NULL) {
     pin(PinStateSplitConstructor);
   }
   // accessors
   ValueStack* state() const                      { return _state; }
   IRScope* scope() const;                        // the state's scope
   // manipulation
   void set_state(ValueStack* state)              { _state = state; }
   // generic
   virtual void input_values_do(void f(Value*))   { /* no values */ }
   virtual void state_values_do(void f(Value*));
 };
 LEAF(Invoke, StateSplit)
  private:
   Bytecodes::Code           _code;
   Value                     _recv;
   Values*                   _args;
   BasicTypeList*            _signature;
   int                       _vtable_index;
   ciMethod*                 _target;
  public:
   // creation
   Invoke(Bytecodes::Code code, ValueType* result_type, Value recv, Values* args,
          int vtable_index, ciMethod* target);
   // accessors
   Bytecodes::Code code() const                   { return _code; }
   Value receiver() const                         { return _recv; }
   bool has_receiver() const                      { return receiver() != NULL; }
   int number_of_arguments() const                { return _args->length(); }
   Value argument_at(int i) const                 { return _args->at(i); }
   int vtable_index() const                       { return _vtable_index; }
   BasicTypeList* signature() const               { return _signature; }
   ciMethod* target() const                       { return _target; }
   // Returns false if target is not loaded
   bool target_is_final() const                   { return check_flag(TargetIsFinalFlag); }
   bool target_is_loaded() const                  { return check_flag(TargetIsLoadedFlag); }
   // Returns false if target is not loaded
   bool target_is_strictfp() const                { return check_flag(TargetIsStrictfpFlag); }
   // generic
   virtual bool can_trap() const                  { return true; }
   virtual void input_values_do(void f(Value*)) {
     StateSplit::input_values_do(f);
     if (has_receiver()) f(&_recv);
     for (int i = 0; i < _args->length(); i++) f(_args->adr_at(i));
   }
 };
 LEAF(NewInstance, StateSplit)
  private:
   ciInstanceKlass* _klass;
  public:
   // creation
   NewInstance(ciInstanceKlass* klass) : StateSplit(instanceType), _klass(klass) {}
   // accessors
   ciInstanceKlass* klass() const                 { return _klass; }
   // generic
   virtual bool can_trap() const                  { return true; }
   ciType* exact_type() const;
 };
 BASE(NewArray, StateSplit)
  private:
   Value       _length;
   ValueStack* _state_before;
  public:
   // creation
   NewArray(Value length, ValueStack* state_before) : StateSplit(objectType), _length(length), _state_before(state_before) {
     // Do not ASSERT_VALUES since length is NULL for NewMultiArray
   }
   // accessors
   ValueStack* state_before() const               { return _state_before; }
   Value length() const                           { return _length; }
   // generic
   virtual bool can_trap() const                  { return true; }
   virtual void input_values_do(void f(Value*))   { StateSplit::input_values_do(f); f(&_length); }
   virtual void other_values_do(void f(Value*));
 };
 LEAF(NewTypeArray, NewArray)
  private:
   BasicType _elt_type;
  public:
   // creation
   NewTypeArray(Value length, BasicType elt_type) : NewArray(length, NULL), _elt_type(elt_type) {}
   // accessors
   BasicType elt_type() const                     { return _elt_type; }
   ciType* exact_type() const;
 };
 LEAF(NewObjectArray, NewArray)
  private:
   ciKlass* _klass;
  public:
   // creation
   NewObjectArray(ciKlass* klass, Value length, ValueStack* state_before) : NewArray(length, state_before), _klass(klass) {}
   // accessors
   ciKlass* klass() const                         { return _klass; }
   ciType* exact_type() const;
 };
 LEAF(NewMultiArray, NewArray)
  private:
   ciKlass* _klass;
   Values*  _dims;
  public:
   // creation
   NewMultiArray(ciKlass* klass, Values* dims, ValueStack* state_before) : NewArray(NULL, state_before), _klass(klass), _dims(dims) {
     ASSERT_VALUES
   }
   // accessors
   ciKlass* klass() const                         { return _klass; }
   Values* dims() const                           { return _dims; }
   int rank() const                               { return dims()->length(); }
   // generic
   virtual void input_values_do(void f(Value*)) {
     // NOTE: we do not call NewArray::input_values_do since "length"
     // is meaningless for a multi-dimensional array; passing the
     // zeroth element down to NewArray as its length is a bad idea
     // since there will be a copy in the "dims" array which doesn't
     // get updated, and the value must not be traversed twice. Was bug
     // - kbr 4/10/2001
     StateSplit::input_values_do(f);
     for (int i = 0; i < _dims->length(); i++) f(_dims->adr_at(i));
   }
 };
 BASE(TypeCheck, StateSplit)
  private:
   ciKlass*    _klass;
   Value       _obj;
   ValueStack* _state_before;
  public:
   // creation
   TypeCheck(ciKlass* klass, Value obj, ValueType* type, ValueStack* state_before) : StateSplit(type), _klass(klass), _obj(obj), _state_before(state_before) {
     ASSERT_VALUES
     set_direct_compare(false);
   }
   // accessors
   ValueStack* state_before() const               { return _state_before; }
   ciKlass* klass() const                         { return _klass; }
   Value obj() const                              { return _obj; }
   bool is_loaded() const                         { return klass() != NULL; }
   bool direct_compare() const                    { return check_flag(DirectCompareFlag); }
   // manipulation
   void set_direct_compare(bool flag)             { set_flag(DirectCompareFlag, flag); }
   // generic
   virtual bool can_trap() const                  { return true; }
   virtual void input_values_do(void f(Value*))   { StateSplit::input_values_do(f); f(&_obj); }
   virtual void other_values_do(void f(Value*));
 };
 LEAF(CheckCast, TypeCheck)
  private:
   ciMethod* _profiled_method;
   int       _profiled_bci;
  public:
   // creation
   CheckCast(ciKlass* klass, Value obj, ValueStack* state_before)
   : TypeCheck(klass, obj, objectType, state_before)
   , _profiled_method(NULL)
   , _profiled_bci(0) {}
   void set_incompatible_class_change_check() {
     set_flag(ThrowIncompatibleClassChangeErrorFlag, true);
   }
   bool is_incompatible_class_change_check() const {
     return check_flag(ThrowIncompatibleClassChangeErrorFlag);
   }
   // Helpers for methodDataOop profiling
   void set_should_profile(bool value)                { set_flag(ProfileMDOFlag, value); }
   void set_profiled_method(ciMethod* method)         { _profiled_method = method;   }
   void set_profiled_bci(int bci)                     { _profiled_bci = bci;         }
   bool      should_profile() const                   { return check_flag(ProfileMDOFlag); }
   ciMethod* profiled_method() const                  { return _profiled_method;     }
   int       profiled_bci() const                     { return _profiled_bci;        }
   ciType* declared_type() const;
   ciType* exact_type() const;
 };
 LEAF(InstanceOf, TypeCheck)
  public:
   // creation
   InstanceOf(ciKlass* klass, Value obj, ValueStack* state_before) : TypeCheck(klass, obj, intType, state_before) {}
 };
 BASE(AccessMonitor, StateSplit)
  private:
   Value       _obj;
   int         _monitor_no;
  public:
   // creation
   AccessMonitor(Value obj, int monitor_no)
   : StateSplit(illegalType)
   , _obj(obj)
   , _monitor_no(monitor_no)
   {
     set_needs_null_check(true);
     ASSERT_VALUES
   }
   // accessors
   Value obj() const                              { return _obj; }
   int monitor_no() const                         { return _monitor_no; }
   // generic
   virtual void input_values_do(void f(Value*))   { StateSplit::input_values_do(f); f(&_obj); }
 };
 LEAF(MonitorEnter, AccessMonitor)
  private:
   ValueStack* _lock_stack_before;
  public:
   // creation
   MonitorEnter(Value obj, int monitor_no, ValueStack* lock_stack_before)
   : AccessMonitor(obj, monitor_no)
   , _lock_stack_before(lock_stack_before)
   {
     ASSERT_VALUES
   }
   // accessors
   ValueStack* lock_stack_before() const          { return _lock_stack_before; }
   virtual void state_values_do(void f(Value*));
   // generic
   virtual bool can_trap() const                  { return true; }
 };
 LEAF(MonitorExit, AccessMonitor)
  public:
   // creation
   MonitorExit(Value obj, int monitor_no) : AccessMonitor(obj, monitor_no) {}
 };
 LEAF(Intrinsic, StateSplit)
  private:
   vmIntrinsics::ID _id;
   Values*          _args;
   ValueStack*      _lock_stack;
   Value            _recv;
  public:
   // preserves_state can be set to true for Intrinsics
   // which are guaranteed to preserve register state across any slow
   // cases; setting it to true does not mean that the Intrinsic can
   // not trap, only that if we continue execution in the same basic
   // block after the Intrinsic, all of the registers are intact. This
   // allows load elimination and common expression elimination to be
   // performed across the Intrinsic.  The default value is false.
   Intrinsic(ValueType* type,
             vmIntrinsics::ID id,
             Values* args,
             bool has_receiver,
             ValueStack* lock_stack,
             bool preserves_state,
             bool cantrap = true)
   : StateSplit(type)
   , _id(id)
   , _args(args)
   , _lock_stack(lock_stack)
   , _recv(NULL)
   {
     assert(args != NULL, "args must exist");
     ASSERT_VALUES
     set_flag(PreservesStateFlag, preserves_state);
     set_flag(CanTrapFlag,        cantrap);
     if (has_receiver) {
       _recv = argument_at(0);
     }
     set_needs_null_check(has_receiver);
     // some intrinsics can't trap, so don't force them to be pinned
     if (!can_trap()) {
       unpin(PinStateSplitConstructor);
     }
   }
   // accessors
   vmIntrinsics::ID id() const                    { return _id; }
   int number_of_arguments() const                { return _args->length(); }
   Value argument_at(int i) const                 { return _args->at(i); }
   ValueStack* lock_stack() const                 { return _lock_stack; }
   bool has_receiver() const                      { return (_recv != NULL); }
   Value receiver() const                         { assert(has_receiver(), "must have receiver"); return _recv; }
   bool preserves_state() const                   { return check_flag(PreservesStateFlag); }
   // generic
   virtual bool can_trap() const                  { return check_flag(CanTrapFlag); }
   virtual void input_values_do(void f(Value*)) {
     StateSplit::input_values_do(f);
     for (int i = 0; i < _args->length(); i++) f(_args->adr_at(i));
   }
   virtual void state_values_do(void f(Value*));
 };
 class LIR_List;
 LEAF(BlockBegin, StateSplit)
  private:
   static int _next_block_id;                     // the block counter
   int        _block_id;                          // the unique block id
   int        _depth_first_number;                // number of this block in a depth-first ordering
   int        _linear_scan_number;                // number of this block in linear-scan ordering
   int        _loop_depth;                        // the loop nesting level of this block
   int        _loop_index;                        // number of the innermost loop of this block
   int        _flags;                             // the flags associated with this block
   // fields used by BlockListBuilder
   int        _total_preds;                       // number of predecessors found by BlockListBuilder
   BitMap     _stores_to_locals;                  // bit is set when a local variable is stored in the block
   // SSA specific fields: (factor out later)
   BlockList   _successors;                       // the successors of this block
   BlockList   _predecessors;                     // the predecessors of this block
   BlockBegin* _dominator;                        // the dominator of this block
   // SSA specific ends
   BlockEnd*  _end;                               // the last instruction of this block
   BlockList  _exception_handlers;                // the exception handlers potentially invoked by this block
   ValueStackStack* _exception_states;            // only for xhandler entries: states of all instructions that have an edge to this xhandler
   int        _exception_handler_pco;             // if this block is the start of an exception handler,
                                                  // this records the PC offset in the assembly code of the
                                                  // first instruction in this block
   Label      _label;                             // the label associated with this block
   LIR_List*  _lir;                               // the low level intermediate representation for this block
   BitMap      _live_in;                          // set of live LIR_Opr registers at entry to this block
   BitMap      _live_out;                         // set of live LIR_Opr registers at exit from this block
   BitMap      _live_gen;                         // set of registers used before any redefinition in this block
   BitMap      _live_kill;                        // set of registers defined in this block
   BitMap      _fpu_register_usage;
   intArray*   _fpu_stack_state;                  // For x86 FPU code generation with UseLinearScan
   int         _first_lir_instruction_id;         // ID of first LIR instruction in this block
   int         _last_lir_instruction_id;          // ID of last LIR instruction in this block
   void iterate_preorder (boolArray& mark, BlockClosure* closure);
   void iterate_postorder(boolArray& mark, BlockClosure* closure);
   friend class SuxAndWeightAdjuster;
  public:
   // initialization/counting
   static void initialize()                       { _next_block_id = 0; }
   static int  number_of_blocks()                 { return _next_block_id; }
   // creation
   BlockBegin(int bci)
   : StateSplit(illegalType)
   , _block_id(_next_block_id++)
   , _depth_first_number(-1)
   , _linear_scan_number(-1)
   , _loop_depth(0)
   , _flags(0)
   , _dominator(NULL)
   , _end(NULL)
   , _predecessors(2)
   , _successors(2)
   , _exception_handlers(1)
   , _exception_states(NULL)
   , _exception_handler_pco(-1)
   , _lir(NULL)
   , _loop_index(-1)
   , _live_in()
   , _live_out()
   , _live_gen()
   , _live_kill()
   , _fpu_register_usage()
   , _fpu_stack_state(NULL)
   , _first_lir_instruction_id(-1)
   , _last_lir_instruction_id(-1)
   , _total_preds(0)
   , _stores_to_locals()
   {
     set_bci(bci);
   }
   // accessors
   int block_id() const                           { return _block_id; }
   BlockList* successors()                        { return &_successors; }
   BlockBegin* dominator() const                  { return _dominator; }
   int loop_depth() const                         { return _loop_depth; }
   int depth_first_number() const                 { return _depth_first_number; }
   int linear_scan_number() const                 { return _linear_scan_number; }
   BlockEnd* end() const                          { return _end; }
   Label* label()                                 { return &_label; }
   LIR_List* lir() const                          { return _lir; }
   int exception_handler_pco() const              { return _exception_handler_pco; }
   BitMap& live_in()                              { return _live_in;        }
   BitMap& live_out()                             { return _live_out;       }
   BitMap& live_gen()                             { return _live_gen;       }
   BitMap& live_kill()                            { return _live_kill;      }
   BitMap& fpu_register_usage()                   { return _fpu_register_usage; }
   intArray* fpu_stack_state() const              { return _fpu_stack_state;    }
   int first_lir_instruction_id() const           { return _first_lir_instruction_id; }
   int last_lir_instruction_id() const            { return _last_lir_instruction_id; }
   int total_preds() const                        { return _total_preds; }
   BitMap& stores_to_locals()                     { return _stores_to_locals; }
   // manipulation
   void set_bci(int bci)                          { Instruction::set_bci(bci); }
   void set_dominator(BlockBegin* dom)            { _dominator = dom; }
   void set_loop_depth(int d)                     { _loop_depth = d; }
   void set_depth_first_number(int dfn)           { _depth_first_number = dfn; }
   void set_linear_scan_number(int lsn)           { _linear_scan_number = lsn; }
   void set_end(BlockEnd* end);
   void disconnect_from_graph();
   static void disconnect_edge(BlockBegin* from, BlockBegin* to);
   BlockBegin* insert_block_between(BlockBegin* sux);
   void substitute_sux(BlockBegin* old_sux, BlockBegin* new_sux);
   void set_lir(LIR_List* lir)                    { _lir = lir; }
   void set_exception_handler_pco(int pco)        { _exception_handler_pco = pco; }
   void set_live_in       (BitMap map)            { _live_in = map;        }
   void set_live_out      (BitMap map)            { _live_out = map;       }
   void set_live_gen      (BitMap map)            { _live_gen = map;       }
   void set_live_kill     (BitMap map)            { _live_kill = map;      }
   void set_fpu_register_usage(BitMap map)        { _fpu_register_usage = map; }
   void set_fpu_stack_state(intArray* state)      { _fpu_stack_state = state;  }
   void set_first_lir_instruction_id(int id)      { _first_lir_instruction_id = id;  }
   void set_last_lir_instruction_id(int id)       { _last_lir_instruction_id = id;  }
   void increment_total_preds(int n = 1)          { _total_preds += n; }
   void init_stores_to_locals(int locals_count)   { _stores_to_locals = BitMap(locals_count); _stores_to_locals.clear(); }
   // generic
   virtual void state_values_do(void f(Value*));
   // successors and predecessors
   int number_of_sux() const;
   BlockBegin* sux_at(int i) const;
   void add_successor(BlockBegin* sux);
   void remove_successor(BlockBegin* pred);
   bool is_successor(BlockBegin* sux) const       { return _successors.contains(sux); }
   void add_predecessor(BlockBegin* pred);
   void remove_predecessor(BlockBegin* pred);
   bool is_predecessor(BlockBegin* pred) const    { return _predecessors.contains(pred); }
   int number_of_preds() const                    { return _predecessors.length(); }
   BlockBegin* pred_at(int i) const               { return _predecessors[i]; }
   // exception handlers potentially invoked by this block
   void add_exception_handler(BlockBegin* b);
   bool is_exception_handler(BlockBegin* b) const { return _exception_handlers.contains(b); }
   int  number_of_exception_handlers() const      { return _exception_handlers.length(); }
   BlockBegin* exception_handler_at(int i) const  { return _exception_handlers.at(i); }
   // states of the instructions that have an edge to this exception handler
   int number_of_exception_states()               { assert(is_set(exception_entry_flag), "only for xhandlers"); return _exception_states == NULL ? 0 : _exception_states->length(); }
   ValueStack* exception_state_at(int idx) const  { assert(is_set(exception_entry_flag), "only for xhandlers"); return _exception_states->at(idx); }
   int add_exception_state(ValueStack* state);
   // flags
   enum Flag {
     no_flag                       = 0,
     std_entry_flag                = 1 << 0,
     osr_entry_flag                = 1 << 1,
     exception_entry_flag          = 1 << 2,
     subroutine_entry_flag         = 1 << 3,
     backward_branch_target_flag   = 1 << 4,
     is_on_work_list_flag          = 1 << 5,
     was_visited_flag              = 1 << 6,
     default_exception_handler_flag = 1 << 8, // identify block which represents the default exception handler
     parser_loop_header_flag       = 1 << 9,  // set by parser to identify blocks where phi functions can not be created on demand
     critical_edge_split_flag      = 1 << 10, // set for all blocks that are introduced when critical edges are split
     linear_scan_loop_header_flag  = 1 << 11, // set during loop-detection for LinearScan
     linear_scan_loop_end_flag     = 1 << 12  // set during loop-detection for LinearScan
   };
   void set(Flag f)                               { _flags |= f; }
   void clear(Flag f)                             { _flags &= ~f; }
   bool is_set(Flag f) const                      { return (_flags & f) != 0; }
   bool is_entry_block() const {
     const int entry_mask = std_entry_flag | osr_entry_flag | exception_entry_flag;
     return (_flags & entry_mask) != 0;
   }
   // iteration
   void iterate_preorder   (BlockClosure* closure);
   void iterate_postorder  (BlockClosure* closure);
   void block_values_do(void f(Value*));
   // loops
   void set_loop_index(int ix)                    { _loop_index = ix;        }
   int  loop_index() const                        { return _loop_index;      }
   // merging
   bool try_merge(ValueStack* state);             // try to merge states at block begin
   void merge(ValueStack* state)                  { bool b = try_merge(state); assert(b, "merge failed"); }
   // debugging
   void print_block()                             PRODUCT_RETURN;
   void print_block(InstructionPrinter& ip, bool live_only = false) PRODUCT_RETURN;
 };
 BASE(BlockEnd, StateSplit)
  private:
   BlockBegin* _begin;
   BlockList*  _sux;
   ValueStack* _state_before;
  protected:
   BlockList* sux() const                         { return _sux; }
   void set_sux(BlockList* sux) {
 #ifdef ASSERT
     assert(sux != NULL, "sux must exist");
     for (int i = sux->length() - 1; i >= 0; i--) assert(sux->at(i) != NULL, "sux must exist");
 #endif
     _sux = sux;
   }
  public:
   // creation
   BlockEnd(ValueType* type, ValueStack* state_before, bool is_safepoint)
   : StateSplit(type)
   , _begin(NULL)
   , _sux(NULL)
   , _state_before(state_before) {
     set_flag(IsSafepointFlag, is_safepoint);
   }
   // accessors
   ValueStack* state_before() const               { return _state_before; }
   bool is_safepoint() const                      { return check_flag(IsSafepointFlag); }
   BlockBegin* begin() const                      { return _begin; }
   // manipulation
   void set_begin(BlockBegin* begin);
   // generic
   virtual void other_values_do(void f(Value*));
   // successors
   int number_of_sux() const                      { return _sux != NULL ? _sux->length() : 0; }
   BlockBegin* sux_at(int i) const                { return _sux->at(i); }
   BlockBegin* default_sux() const                { return sux_at(number_of_sux() - 1); }
   BlockBegin** addr_sux_at(int i) const          { return _sux->adr_at(i); }
   int sux_index(BlockBegin* sux) const           { return _sux->find(sux); }
   void substitute_sux(BlockBegin* old_sux, BlockBegin* new_sux);
 };
 LEAF(Goto, BlockEnd)
  public:
   // creation
   Goto(BlockBegin* sux, ValueStack* state_before, bool is_safepoint = false) : BlockEnd(illegalType, state_before, is_safepoint) {
     BlockList* s = new BlockList(1);
     s->append(sux);
     set_sux(s);
   }
   Goto(BlockBegin* sux, bool is_safepoint) : BlockEnd(illegalType, NULL, is_safepoint) {
     BlockList* s = new BlockList(1);
     s->append(sux);
     set_sux(s);
   }
 };
 LEAF(If, BlockEnd)
  private:
   Value       _x;
   Condition   _cond;
   Value       _y;
   ciMethod*   _profiled_method;
   int         _profiled_bci; // Canonicalizer may alter bci of If node
  public:
   // creation
   // unordered_is_true is valid for float/double compares only
   If(Value x, Condition cond, bool unordered_is_true, Value y, BlockBegin* tsux, BlockBegin* fsux, ValueStack* state_before, bool is_safepoint)
     : BlockEnd(illegalType, state_before, is_safepoint)
   , _x(x)
   , _cond(cond)
   , _y(y)
   , _profiled_method(NULL)
   , _profiled_bci(0)
   {
     ASSERT_VALUES
     set_flag(UnorderedIsTrueFlag, unordered_is_true);
     assert(x->type()->tag() == y->type()->tag(), "types must match");
     BlockList* s = new BlockList(2);
     s->append(tsux);
     s->append(fsux);
     set_sux(s);
   }
   // accessors
   Value x() const                                { return _x; }
   Condition cond() const                         { return _cond; }
   bool unordered_is_true() const                 { return check_flag(UnorderedIsTrueFlag); }
   Value y() const                                { return _y; }
   BlockBegin* sux_for(bool is_true) const        { return sux_at(is_true ? 0 : 1); }
   BlockBegin* tsux() const                       { return sux_for(true); }
   BlockBegin* fsux() const                       { return sux_for(false); }
   BlockBegin* usux() const                       { return sux_for(unordered_is_true()); }
   bool should_profile() const                    { return check_flag(ProfileMDOFlag); }
   ciMethod* profiled_method() const              { return _profiled_method; } // set only for profiled branches
   int profiled_bci() const                       { return _profiled_bci; }    // set only for profiled branches
   // manipulation
   void swap_operands() {
     Value t = _x; _x = _y; _y = t;
     _cond = mirror(_cond);
   }
   void swap_sux() {
     assert(number_of_sux() == 2, "wrong number of successors");
     BlockList* s = sux();
     BlockBegin* t = s->at(0); s->at_put(0, s->at(1)); s->at_put(1, t);
     _cond = negate(_cond);
     set_flag(UnorderedIsTrueFlag, !check_flag(UnorderedIsTrueFlag));
   }
   void set_should_profile(bool value)             { set_flag(ProfileMDOFlag, value); }
   void set_profiled_method(ciMethod* method)      { _profiled_method = method; }
   void set_profiled_bci(int bci)                  { _profiled_bci = bci;       }
   // generic
   virtual void input_values_do(void f(Value*))   { BlockEnd::input_values_do(f); f(&_x); f(&_y); }
 };
 LEAF(IfInstanceOf, BlockEnd)
  private:
   ciKlass* _klass;
   Value    _obj;
   bool     _test_is_instance;                    // jump if instance
   int      _instanceof_bci;
  public:
   IfInstanceOf(ciKlass* klass, Value obj, bool test_is_instance, int instanceof_bci, BlockBegin* tsux, BlockBegin* fsux)
   : BlockEnd(illegalType, NULL, false) // temporary set to false
   , _klass(klass)
   , _obj(obj)
   , _test_is_instance(test_is_instance)
   , _instanceof_bci(instanceof_bci)
   {
     ASSERT_VALUES
     assert(instanceof_bci >= 0, "illegal bci");
     BlockList* s = new BlockList(2);
     s->append(tsux);
     s->append(fsux);
     set_sux(s);
   }
   // accessors
   //
   // Note 1: If test_is_instance() is true, IfInstanceOf tests if obj *is* an
   //         instance of klass; otherwise it tests if it is *not* and instance
   //         of klass.
   //
   // Note 2: IfInstanceOf instructions are created by combining an InstanceOf
   //         and an If instruction. The IfInstanceOf bci() corresponds to the
   //         bci that the If would have had; the (this->) instanceof_bci() is
   //         the bci of the original InstanceOf instruction.
   ciKlass* klass() const                         { return _klass; }
   Value obj() const                              { return _obj; }
   int instanceof_bci() const                     { return _instanceof_bci; }
   bool test_is_instance() const                  { return _test_is_instance; }
   BlockBegin* sux_for(bool is_true) const        { return sux_at(is_true ? 0 : 1); }
   BlockBegin* tsux() const                       { return sux_for(true); }
   BlockBegin* fsux() const                       { return sux_for(false); }
   // manipulation
   void swap_sux() {
     assert(number_of_sux() == 2, "wrong number of successors");
     BlockList* s = sux();
     BlockBegin* t = s->at(0); s->at_put(0, s->at(1)); s->at_put(1, t);
     _test_is_instance = !_test_is_instance;
   }
   // generic
   virtual void input_values_do(void f(Value*))   { BlockEnd::input_values_do(f); f(&_obj); }
 };
 BASE(Switch, BlockEnd)
  private:
   Value       _tag;
  public:
   // creation
   Switch(Value tag, BlockList* sux, ValueStack* state_before, bool is_safepoint)
   : BlockEnd(illegalType, state_before, is_safepoint)
   , _tag(tag) {
     ASSERT_VALUES
     set_sux(sux);
   }
   // accessors
   Value tag() const                              { return _tag; }
   int length() const                             { return number_of_sux() - 1; }
   // generic
   virtual void input_values_do(void f(Value*))   { BlockEnd::input_values_do(f); f(&_tag); }
 };
 LEAF(TableSwitch, Switch)
  private:
   int _lo_key;
  public:
   // creation
   TableSwitch(Value tag, BlockList* sux, int lo_key, ValueStack* state_before, bool is_safepoint)
     : Switch(tag, sux, state_before, is_safepoint)
   , _lo_key(lo_key) {}
   // accessors
   int lo_key() const                             { return _lo_key; }
   int hi_key() const                             { return _lo_key + length() - 1; }
 };
 LEAF(LookupSwitch, Switch)
  private:
   intArray* _keys;
  public:
   // creation
   LookupSwitch(Value tag, BlockList* sux, intArray* keys, ValueStack* state_before, bool is_safepoint)
   : Switch(tag, sux, state_before, is_safepoint)
   , _keys(keys) {
     assert(keys != NULL, "keys must exist");
     assert(keys->length() == length(), "sux & keys have incompatible lengths");
   }
   // accessors
   int key_at(int i) const                        { return _keys->at(i); }
 };
 LEAF(Return, BlockEnd)
  private:
   Value _result;
  public:
   // creation
   Return(Value result) :
     BlockEnd(result == NULL ? voidType : result->type()->base(), NULL, true),
     _result(result) {}
   // accessors
   Value result() const                           { return _result; }
   bool has_result() const                        { return result() != NULL; }
   // generic
   virtual void input_values_do(void f(Value*)) {
     BlockEnd::input_values_do(f);
     if (has_result()) f(&_result);
   }
 };
 LEAF(Throw, BlockEnd)
  private:
   Value _exception;
  public:
   // creation
   Throw(Value exception, ValueStack* state_before) : BlockEnd(illegalType, state_before, true), _exception(exception) {
     ASSERT_VALUES
   }
   // accessors
   Value exception() const                        { return _exception; }
   // generic
   virtual bool can_trap() const                  { return true; }
   virtual void input_values_do(void f(Value*))   { BlockEnd::input_values_do(f); f(&_exception); }
   virtual void state_values_do(void f(Value*));
 };
 LEAF(Base, BlockEnd)
  public:
   // creation
   Base(BlockBegin* std_entry, BlockBegin* osr_entry) : BlockEnd(illegalType, NULL, false) {
     assert(std_entry->is_set(BlockBegin::std_entry_flag), "std entry must be flagged");
     assert(osr_entry == NULL || osr_entry->is_set(BlockBegin::osr_entry_flag), "osr entry must be flagged");
     BlockList* s = new BlockList(2);
     if (osr_entry != NULL) s->append(osr_entry);
     s->append(std_entry); // must be default sux!
     set_sux(s);
   }
   // accessors
   BlockBegin* std_entry() const                  { return default_sux(); }
   BlockBegin* osr_entry() const                  { return number_of_sux() < 2 ? NULL : sux_at(0); }
 };
 LEAF(OsrEntry, Instruction)
  public:
   // creation
 #ifdef _LP64
   OsrEntry() : Instruction(longType, false) { pin(); }
 #else
   OsrEntry() : Instruction(intType,  false) { pin(); }
 #endif
   // generic
   virtual void input_values_do(void f(Value*))   { }
 };
 // Models the incoming exception at a catch site
 LEAF(ExceptionObject, Instruction)
  public:
   // creation
   ExceptionObject() : Instruction(objectType, false) {
     pin();
   }
   // generic
   virtual void input_values_do(void f(Value*))   { }
 };
 // Models needed rounding for floating-point values on Intel.
 // Currently only used to represent rounding of double-precision
 // values stored into local variables, but could be used to model
 // intermediate rounding of single-precision values as well.
 LEAF(RoundFP, Instruction)
  private:
   Value _input;             // floating-point value to be rounded
  public:
   RoundFP(Value input)
   : Instruction(input->type()) // Note: should not be used for constants
   , _input(input)
   {
     ASSERT_VALUES
   }
   // accessors
   Value input() const                            { return _input; }
   // generic
   virtual void input_values_do(void f(Value*))   { f(&_input); }
 };
 BASE(UnsafeOp, Instruction)
  private:
   BasicType _basic_type;    // ValueType can not express byte-sized integers
  protected:
   // creation
   UnsafeOp(BasicType basic_type, bool is_put)
   : Instruction(is_put ? voidType : as_ValueType(basic_type))
   , _basic_type(basic_type)
   {
     //Note:  Unsafe ops are not not guaranteed to throw NPE.
     // Convservatively, Unsafe operations must be pinned though we could be
     // looser about this if we wanted to..
     pin();
   }
  public:
   // accessors
   BasicType basic_type()                         { return _basic_type; }
   // generic
   virtual void input_values_do(void f(Value*))   { }
   virtual void other_values_do(void f(Value*))   { }
 };
 BASE(UnsafeRawOp, UnsafeOp)
  private:
   Value _base;                                   // Base address (a Java long)
   Value _index;                                  // Index if computed by optimizer; initialized to NULL
   int   _log2_scale;                             // Scale factor: 0, 1, 2, or 3.
                                                  // Indicates log2 of number of bytes (1, 2, 4, or 8)
                                                  // to scale index by.
  protected:
   UnsafeRawOp(BasicType basic_type, Value addr, bool is_put)
   : UnsafeOp(basic_type, is_put)
   , _base(addr)
   , _index(NULL)
   , _log2_scale(0)
   {
     // Can not use ASSERT_VALUES because index may be NULL
     assert(addr != NULL && addr->type()->is_long(), "just checking");
   }
   UnsafeRawOp(BasicType basic_type, Value base, Value index, int log2_scale, bool is_put)
   : UnsafeOp(basic_type, is_put)
   , _base(base)
   , _index(index)
   , _log2_scale(log2_scale)
   {
   }
  public:
   // accessors
   Value base()                                   { return _base; }
   Value index()                                  { return _index; }
   bool  has_index()                              { return (_index != NULL); }
   int   log2_scale()                             { return _log2_scale; }
   // setters
   void set_base (Value base)                     { _base  = base; }
   void set_index(Value index)                    { _index = index; }
   void set_log2_scale(int log2_scale)            { _log2_scale = log2_scale; }
   // generic
   virtual void input_values_do(void f(Value*))   { UnsafeOp::input_values_do(f);
                                                    f(&_base);
                                                    if (has_index()) f(&_index); }
 };
 LEAF(UnsafeGetRaw, UnsafeRawOp)
  private:
   bool _may_be_unaligned;  // For OSREntry
  public:
   UnsafeGetRaw(BasicType basic_type, Value addr, bool may_be_unaligned)
   : UnsafeRawOp(basic_type, addr, false) {
     _may_be_unaligned = may_be_unaligned;
   }
   UnsafeGetRaw(BasicType basic_type, Value base, Value index, int log2_scale, bool may_be_unaligned)
   : UnsafeRawOp(basic_type, base, index, log2_scale, false) {
     _may_be_unaligned = may_be_unaligned;
   }
   bool may_be_unaligned()                               { return _may_be_unaligned; }
 };
 LEAF(UnsafePutRaw, UnsafeRawOp)
  private:
   Value _value;                                  // Value to be stored
  public:
   UnsafePutRaw(BasicType basic_type, Value addr, Value value)
   : UnsafeRawOp(basic_type, addr, true)
   , _value(value)
   {
     assert(value != NULL, "just checking");
     ASSERT_VALUES
   }
   UnsafePutRaw(BasicType basic_type, Value base, Value index, int log2_scale, Value value)
   : UnsafeRawOp(basic_type, base, index, log2_scale, true)
   , _value(value)
   {
     assert(value != NULL, "just checking");
     ASSERT_VALUES
   }
   // accessors
   Value value()                                  { return _value; }
   // generic
   virtual void input_values_do(void f(Value*))   { UnsafeRawOp::input_values_do(f);
                                                    f(&_value); }
 };
 BASE(UnsafeObjectOp, UnsafeOp)
  private:
   Value _object;                                 // Object to be fetched from or mutated
   Value _offset;                                 // Offset within object
   bool  _is_volatile;                            // true if volatile - dl/JSR166
  public:
   UnsafeObjectOp(BasicType basic_type, Value object, Value offset, bool is_put, bool is_volatile)
     : UnsafeOp(basic_type, is_put), _object(object), _offset(offset), _is_volatile(is_volatile)
   {
   }
   // accessors
   Value object()                                 { return _object; }
   Value offset()                                 { return _offset; }
   bool  is_volatile()                            { return _is_volatile; }
   // generic
   virtual void input_values_do(void f(Value*))   { UnsafeOp::input_values_do(f);
                                                    f(&_object);
                                                    f(&_offset); }
 };
 LEAF(UnsafeGetObject, UnsafeObjectOp)
  public:
   UnsafeGetObject(BasicType basic_type, Value object, Value offset, bool is_volatile)
   : UnsafeObjectOp(basic_type, object, offset, false, is_volatile)
   {
     ASSERT_VALUES
   }
 };
 LEAF(UnsafePutObject, UnsafeObjectOp)
  private:
   Value _value;                                  // Value to be stored
  public:
   UnsafePutObject(BasicType basic_type, Value object, Value offset, Value value, bool is_volatile)
   : UnsafeObjectOp(basic_type, object, offset, true, is_volatile)
     , _value(value)
   {
     ASSERT_VALUES
   }
   // accessors
   Value value()                                  { return _value; }
   // generic
   virtual void input_values_do(void f(Value*))   { UnsafeObjectOp::input_values_do(f);
                                                    f(&_value); }
 };
 BASE(UnsafePrefetch, UnsafeObjectOp)
  public:
   UnsafePrefetch(Value object, Value offset)
   : UnsafeObjectOp(T_VOID, object, offset, false, false)
   {
   }
 };
 LEAF(UnsafePrefetchRead, UnsafePrefetch)
  public:
   UnsafePrefetchRead(Value object, Value offset)
   : UnsafePrefetch(object, offset)
   {
     ASSERT_VALUES
   }
 };
 LEAF(UnsafePrefetchWrite, UnsafePrefetch)
  public:
   UnsafePrefetchWrite(Value object, Value offset)
   : UnsafePrefetch(object, offset)
   {
     ASSERT_VALUES
   }
 };
 LEAF(ProfileCall, Instruction)
  private:
   ciMethod* _method;
   int       _bci_of_invoke;
   Value     _recv;
   ciKlass*  _known_holder;
  public:
   ProfileCall(ciMethod* method, int bci, Value recv, ciKlass* known_holder)
     : Instruction(voidType)
     , _method(method)
     , _bci_of_invoke(bci)
     , _recv(recv)
     , _known_holder(known_holder)
   {
     // The ProfileCall has side-effects and must occur precisely where located
     pin();
   }
   ciMethod* method()      { return _method; }
   int bci_of_invoke()     { return _bci_of_invoke; }
   Value recv()            { return _recv; }
   ciKlass* known_holder() { return _known_holder; }
   virtual void input_values_do(void f(Value*))   { if (_recv != NULL) f(&_recv); }
 };
 //
 // Simple node representing a counter update generally used for updating MDOs
 //
 LEAF(ProfileCounter, Instruction)
  private:
   Value     _mdo;
   int       _offset;
   int       _increment;
  public:
   ProfileCounter(Value mdo, int offset, int increment = 1)
     : Instruction(voidType)
     , _mdo(mdo)
     , _offset(offset)
     , _increment(increment)
   {
     // The ProfileCounter has side-effects and must occur precisely where located
     pin();
   }
   Value mdo()      { return _mdo; }
   int offset()     { return _offset; }
   int increment()  { return _increment; }
   virtual void input_values_do(void f(Value*))   { f(&_mdo); }
 };
 class BlockPair: public CompilationResourceObj {
  private:
   BlockBegin* _from;
   BlockBegin* _to;
  public:
   BlockPair(BlockBegin* from, BlockBegin* to): _from(from), _to(to) {}
   BlockBegin* from() const { return _from; }
   BlockBegin* to() const   { return _to;   }
   bool is_same(BlockBegin* from, BlockBegin* to) const { return  _from == from && _to == to; }
   bool is_same(BlockPair* p) const { return  _from == p->from() && _to == p->to(); }
   void set_to(BlockBegin* b)   { _to = b; }
   void set_from(BlockBegin* b) { _from = b; }
 };
 define_array(BlockPairArray, BlockPair*)
 define_stack(BlockPairList, BlockPairArray)
 inline int         BlockBegin::number_of_sux() const            { assert(_end == NULL || _end->number_of_sux() == _successors.length(), "mismatch"); return _successors.length(); }
 inline BlockBegin* BlockBegin::sux_at(int i) const              { assert(_end == NULL || _end->sux_at(i) == _successors.at(i), "mismatch");          return _successors.at(i); }
 inline void        BlockBegin::add_successor(BlockBegin* sux)   { assert(_end == NULL, "Would create mismatch with successors of BlockEnd");         _successors.append(sux); }
 #undef ASSERT_VALUES

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/c1/c1_Instruction.hpp@ba263cfb7611 (annotated)

src/share/vm/c1/c1_Instruction.hpp