--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/share/vm/c1/c1_Instruction.hpp	Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,2291 @@
+/*
+ * 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