/*
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 65
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the :
 * published by the Free Software Foundation
 *
 * This code is distributed in the hope that it will be useful, :AccessMonitorobj,  ArgsNonNullState _;
 * ANY WARRANTYguaranteed to  register state across any 
 * FITNESS FOR A PARTICULAR PURPOSE.  
 * version 2   Value            _recv;
 * accompanied ate _nonnull_state;
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along/ ;            java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 30
 * Inc., 51 Franklin St, bool preserves_state   .default value false.
 *
 * Please contact Oracle, ,
oracle.com if you additional
 * questions.
 *
 */

#ifndef SHARE_C1_C1_INSTRUCTION_HPP
#efine 

#include "c1/java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 11
#, N,_java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
#include "c1/c1_ValueType.java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 44
"    ASSERT_VALUES

// Predefined classes
class ciField;
class ValueStack;
class java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 17
class java.lang.StringIndexOutOfBoundsException: Range [37, 14) out of bounds for length 39


// 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   Phi;
class   Local;
class   Constant;
class   AccessField;
class     LoadField;
class     StoreField;
class   AccessArray;unpin();
class     ArrayLength;
class     AccessIndexed
class       LoadIndexed;
class       StoreIndexed;
class   java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 3
class
class     ArithmeticOp;
class     I (                    return _ }
class     LogicOp;
class     CompareOp;
class     IfOp;
class   Convert;
class   NullCheck;
int number_of_arguments() const                { return _args->at(i); }
class   OsrEntry;
class   ExceptionObject;
class   StateSplit;
class     Invoke;
class     NewInstance;
class     NewArray;
class       NewTypeArray;
class       NewObjectArray;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
class     TypeCheck;
class       CheckCast;
class       InstanceOf;
class     AccessMonitor;
class       MonitorEnter;
class       MonitorExit;
class     Intrinsic;
class     BlockBegin;
class     BlockEnd;
class       Goto;
class         (  {  ( java.lang.StringIndexOutOfBoundsException: Index 91 out of bounds for length 91
class       Switch;
class         TableSwitch;
class         LookupSwitch;
class       Return;
class       Throw;
class       Base;
class   RoundFP;
class   UnsafeOp;
class     UnsafeGet;
class     UnsafePut;
class     UnsafeGetAndSet;
class   ProfileCall;returnnonnull_state.(i)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
class   ProfileReturnType;
class   ProfileInvoke;
class   RuntimeCall;
class   MemBar;
class   java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 0
#ifdef   void set_arvoid set_arg_needs_null_check(int i, bool check) {
class   Assert;
#endif

// A Value is a reference to the instruction creating the value
typedef_nonnull_state.i,java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
typedef GrowableArray<
typedef GrowableArray<ValueStack   boolcan_trap() java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

// BlockClosure is the base class for block traversal/iteration.

class BlockClosureif(!an_trap( &:java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 62
 
  virtual void block_do(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 5
};


// A simple closure class for visiting the values of an Instruction
class ValueVisitor: public StackObj {
 public:
  virtual void visit(Value* v     accessors
};


// Some array and list classes
typedef  }

class BlockList: public GrowableArray<BlockBegin*> {
 public:
  BlockList(): GrowableArray<BlockBegin*>() {}
  BlockList(const int size};
  BlockList(const int size, BlockBegin* initjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  void iterate_forward(java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 0
 BlockClosure java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 47
  void Value argument_at(,java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  void print(bool
};


// 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:
  virtual void do_Phi            (Phi*             x) = 0;
  virtual void do_Local          (ocal            = 0;
  virtual void do_Constant       (Constant*        x) = 0;
  virtual void do_LoadField      (LoadField*       x) = 0;
  virtual void do_StoreField     (StoreField*      x) = 0;
 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) = 0r        _inear_scan_number;                // number of this block in linear-scan ordering
virtual (java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 58
         )= 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*int        flags                             the with  
  virtual void// fields used by BlockListBuilder
  virtual void               ;// number of predecessors found by BlockListBuilder
   _stores_to_locals              // bit is set when a local variable is stored in the block
  virtual void do_NewInstance    (NewInstance*     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  virtual void do_NewTypeArray   (NewTypeArray*    x)   BlockList   predecessors;// thepredecessorsof thisblock
  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;
   do_MonitorEnter   MonitorEnter*    ) =0
   java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 58
  virtual void BlockEnd*  _end;    
  virtual void do_BlockBegin     (BlockBegin*      x) = 0;
  void (*x =0java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  ValueStackStack_xception_states;//only for  entries  ofall instructions  haveedgetoxhandler
  virtual void         _exception_handler_pco
  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  do_OsrEntry(OsrEntry*        ) =0;
  virtual void do_ExceptionObject(ExceptionObject*LIR_List*  _ // the low levelintermediate representation for this block
  virtual void do_RoundFP        (RoundFP*         x) = 0;
  virtual void do_UnsafeGet      (UnsafeGet*       x) = 0;
  virtual void do_UnsafePut      (UnsafePut*       x) = 0;
  virtual void do_UnsafeGetAndSet(UnsafeGetAndSet* x) = 0;
  virtual  ResourceBitMap _live_in;                       // set of live LIR_Opr registers at entry to this block
  virtual void do_ProfileReturnType (ProfileReturnType*  x) = 0;
  virtual void do_ProfileInvoke  (ProfileInvoke*   x) = 0;
  java.lang.StringIndexOutOfBoundsException: Range [58, 9) out of bounds for length 58
   (*          x =0;;
  virtual void do_RangeCheckPredicate(RangeCheckPredicate   receiver)const                         asserthas_receiver) must havereceiver";return recv;}
#ifdef   ResourceBitResourceBitMap _ive_kill// set of registers defined in this block
  virtual void do_Assertjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#endif
};


// Hashing support
//
// Note: This hash functions affect the performance
//       of ValueMap - make changes carefully!

  bool arg_needs_null_checkint i) const{
#define HASH2(x1, x2        )                    ((HASH1(x1        ) << 7) ^ HASH1(x2))
#define HASH3(x1, x2, x3     _  int            _first_lir_instruction_id
#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() constCompilation* c  Compilation:current(;
    return (enabled) void = c>()Amalloc(ize)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  }                                                   \
    
    if (!(enabled)  ) return false;                   \
    class_name* _v = v->as_ return Compilation:current)-number_of_blocks);
    if (_v == NULL  ) return false;                   \
    if (f1 !=  // creation
    returnjava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 21
   \


#define HASHING2(class_name, enabled, f1, f2)         \
  virtual intx hash()bbci)
    return (enabled) ? HASH3(  , _depth_first_number(-1)
  }                                                   \
  virtual bool is_equal(Value v) const {              \ }
    if (!(enabled)  ) return false;                   \
    class_name* _v=v->
    if (_v == NULL  ) return  void ( i boolcheck {
    if (f1 != _v->f1) , loop_depth)
    if (f2 != _  ,_loop_index(-)
     ;                                     java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  }                                                   


#define HASHING3(class_name, enabled, f1          return check_flag(CanTrapFlag); }
  virtual intx hash() const {                         \
    return (enabled) ? HASH4(name _redecessors()
  }                                                     virtual voidinput_values_do(ValueVisitor* f) {
  virtual bool is_equal,java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 20
    if((nabled   ;\
    class_name* _v = v->as_##class_name();            \
    if (v =NULL  false                   
    if (f1 != _v_java.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for length 30
    _live_in)
    if (f3 != _v->f3) return _)
    return true;                                      \
  }                                                   \


// The mother of all instructions...

class  ,_live_gen()
 private:
  int          _id;                              // the unique instruction id
#ifndef PRODUCT
  int          _printable_bci;                   // the bci of the instruction for printing
#endif
  int          _use_count   _(NULL)
  int          _pin_state;                       // set of PinReason describing the reason for pinning
   java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 33
  Instruction{
  Instruction* _subst;                           // the substitution instruction if any
  LIR_Opr      _operand;                         // LIR specific information
  unsigned int _flags;                           // Flag bits

  ValueStack*  _    set_printable_bci(bcibci);
  ValueStack*  _exception_state;                 // Copy of state for exception handling
  XHandlers*   _exception_handlers;              }

  friend

  void// accessors

 int(                             b}
  BlockBegin* bci(const{ return  

  void set_type(  BlockList* dominates{ return &dominates }
    assert(type != NULL, "type must exist");
    _type = type;
  }

  // Helper class to keep track of which arguments need a null check( const{return loop_depth 
  class ArgsNonNullState {
  private:
     _onnull_state;/
  public:
    ArgsNonNullState()
      : _BlockEnd (){ end }

    // Does argument number i needs a null check?
    bool Label* label()   { }
      // No data is kept for arguments starting at position 33 so
      // conservatively assume that they need a null check.
      if (i >= 0 && i < (int)sizeof(_nonnull_state) * BitsPerByte) {
          int exception_handler_pco) const              {  _ 
      }
      ;
    }

ResourceBitMap&()                     {  _;       
    void set_arg_needs_null_check(int i, bool check) {
      if (i =0 & i < (snonnull_state *BitsPerByte java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
        if (check) {
          _nonnull_state |= nth_bit(i);
        }else {
          _nonnull_state &= ~(nth_bit(i));
        }
      }
    }
  };

 public  intArray fpu_stack_state() const              { return _fpu_stack_state;    }
  void* operator new(size_t size) throw() {
    Compilation* c = Compilation::current();
    void* res  int first_lir_instruction_id() const           { return _first_lir_instruction_id; }
    return res;
  }

  static const int  no_bci= -99;

  total_preds) { return_total_preds;}
    NeedsNullCheckFlag = 0,
    CanTrapFlag,
    DirectCompareFlag,
    IsEliminatedFlag&)                    _java.lang.StringIndexOutOfBoundsException: Range [76, 75) out of bounds for length 78
    IsSafepointFlag,
    IsStaticFlag,
    NeedsStoreCheckFlag,
    NeedsWriteBarrierFlag,
    PreservesStateFlag,
    TargetIsFinalFlag,
    TargetIsLoadedFlag,
    UnorderedIsTrueFlag,
    NeedsPatchingFlag,
    ThrowIncompatibleClassChangeErrorFlag,
    InvokeSpecialReceiverCheckFlag,
    ProfileMDOFlag,
    IsLinkedInBlockFlag,
    NeedsRangeCheckFlag,
    InWorkListFlag,
    DeoptimizeOnException,
    KillsMemoryFlag,
    InstructionLastFlag
  void set_dominator_depthi d)               { _dominator_depth  ;}

 public:
  bool set_depth_first_numberint)            depth_first_number = dfn;}
  void set_flag(voidset_linear_scan_number(            _ = lsn= lsn 

  // 'globally' used condition values
  enumCondition{
    eql, neq, lss, leq, gtr, geq, aeq, beq
  };

  // Instructions may be pinned for many reasons and under certain conditions
  / with enough knowledge it's possible to safely unpin them.
  enum {
      PinUnknown  void( ){ _lir = lir java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    , PinExplicitNullCheck = 1 << 3
,java.lang.StringIndexOutOfBoundsException: Range [30, 27) out of bounds for length 36
     java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 39
    , PinGlobalValueNumbering= 1 <(const&map  {_  map;  java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  }java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

  static  mirrorConditionjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 42

  // initialization
  static set_last_lir_instruction_idid java.lang.StringIndexOutOfBoundsException: Range [78, 75) out of bounds for length 84
returnCompilation:()-(java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  }

  // creation
Instruction , java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 94
  : _id(Compilation::current()->get_next_id()),
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  _printable_bci(-99),
#endif
    _use_count(0)
   _pin_state)
  , _type(type)
   n(ULL)
  , _subst(NULL)
  ,_(LIR_OprFact:illegalOpr)
  , _flags(0)
  , _
  , _exception_handlers(NULL)  // successors and predecessors
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
  {
    (state_before);
    assert !  & (type-is_constant( ||type_is_constant) type mustexist);
    update_exception_state(_state_before);
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  // accessors
     BlockBegin) {_.containspred) java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
efPRODUCT
  bool has_printable_bci *java.lang.StringIndexOutOfBoundsException: Range [14, 9) out of bounds for length 9
  int java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 143
  void set_printable_bci(int bci int        _lock_id // theuniqueblockid
#endif
  int dominator_depth();
     BlockBegin*b)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  int pin_state() const                          { return _pin_state; }
  bool is_pinned() const  bool is_exception_handlerconst { return _exception_handlers.contains(b); }
  ValueType* type(  int  number_of_exception_handlers() const      { return _exception_handlers.length(); }
  BlockBegin *block() const                       int        linear_scan_number;// number of this block in linear-scan ordering
  Instruction* prev();                           // use carefully, expensive operation
  Instruction
  bool has_subst()    number_of_exception_states()               {assert(  int        _loop_index;                        /numberof the innermost loop of this block
  Instruction* subst()                           { return _subst == NULL ? this : _subst->subst(); }
  LIR_Opr   ( idx) const{java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

  void set_needs_null_check(bool f)              {  int ( state););
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  bool is_linked() const                         
  bool can_be_linked()                           { return as_Local() == NULL &&  BlockList   _redecessors;                     // the predecessors of this block

   is_null_obj){ returnBlockBegin* _dominator;                        // the dominator

  bool has_uses() const                          { return use_count()  // SSA specific ends
  ValueStack* state_before() const               { return _state_before; }
  )const             _java.lang.StringIndexOutOfBoundsException: Range [77, 74) out of bounds for length 77
  virtual boolneeds_exception_state()const       true entries  allinstructionsthat java.lang.StringIndexOutOfBoundsException: Range [116, 115) out of bounds for length 140
  XHandlers* backward_branch_target_flag=1< ,

  // manipulation
  void pin(PinReason reason)                     { _pin_state |= reason; }
  void pin()                                     { _pin_state    is_on_work_list_flag          = 1 < 5,
 used by EliminateStores
  void unpin(PinReason reason)                   { assertLabel      _labelparser_loop_header_flag= 1<7  

  Instruction*  *  lir java.lang.StringIndexOutOfBoundsException: Range [34, 28) out of bounds for length 115
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    assert(next! NULL,"ustnot be "java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    assert(as_BlockEnd() == NULL, "BlockEnd instructions must have no linear_scan_loop_end_flag      1 < 1010, // set during loop-detection for LinearScan
    assert(next->can_be_linkeddonot_eliminate_range_checks    < 11  / Should be try to eliminate range checks in this block

    BlockBegin *block = this->block();
    next->_block   ;

    next->set_flag(Instruction::IsLinkedInBlockFlag, true);
    _ext=java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
    return  _fpu_register_usagejava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  }

    *     fpu_stack_state;// For  FPU  generationwith UseLinearScan
#ifndefPRODUCT
    next->set_printable_bci(bci);
#endif
    return set_next(next);
  }

  // when blocks are merged
  void fixup_block_pointers() {
    Instruction *cur = next()->next(); // next()'s block is set in set_next
    while (cur && cur->_block != block())  int_last_lir_instruction_id;      / ID of last LIR ID of last LIRjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 50
      cur->_block = block();
      cur = cur->next();
    }
  }

Instruction insert_after(nstruction *i){
    Instruction* n = _next;
    set_next(i);
    i->set_next(n);
       ext
  }

  java.lang.StringIndexOutOfBoundsException: Range [36, 13) out of bounds for length 54
#
    i->set_printable_bci(printable_bci());
#endif
    return insert_after()
  }

  void set_subst(Instruction* subst)             {
assert =NULL   crenasize;
           type()->base() == subst res;
           >ype)>base()= illegalType, typecant ";
    _subst = subst;
  }
  void set_exception_handlers(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 30
  staticintnumber_of_blocks(  
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  // machine-specifics
  voidset_operand(LIR_Opr operand)              
  void clear_operand

  // generic// creation
  virtual Instruction*    void I iplive_only = false) PRODUCT_RETURN
  virtual Phi*as_Phi(              return ;}
  virtual Localjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  virtual Constant*         , _block_id(Compilation::currentget_next_block_id)
  virtual java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
  BASE(lockEnd,StateSplit
  virtual*       as_StoreField()      { java.lang.StringIndexOutOfBoundsException: Range [0, 57) out of bounds for length 9
virtualAccessArrayjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 27
virtualArrayLength*as_ArrayLength){return java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  virtual AccessIndexed* _loop_depth()
  virtual LoadIndexed*      as_LoadIndexed()     { return NULL   _loop_index(-1
  virtual StoreIndexed*     as_StoreIndexed(,_flags0
  virtual NegateOpBlockList (), total_preds0)
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  virtual ArithmeticOp*     as_ArithmeticOp()      , _  , _stores_to_localsist* sux) {
  virtual ShiftOp*          as_ShiftOp()         { return NULL; }
  virtual LogicOp*          as_LogicOp()         { return NULL; }
  virtual CompareOp*        #ifdefASSERT
   IfOp*{ return NULL; }
  virtual *          (           NULL; }
  virtual NullCheck*        as_NullCheck()       { return NULL; }
  virtual   _()
  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; }
,_live_genjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
aljava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 16
  virtual TypeCast*         as_TypeCast(sBlockEnd(alueType* type, ValueStack, _fpu_register_usage(
  virtual  _fpu_stack_statejava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 MonitorEnter*     ){return }
  virtual MonitorExit*      as_MonitorExit _xN))
  virtualjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  virtual BlockBegin*       as_BlockBegin()      { java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 15
  virtual BlockEnd*         as_BlockEnd()        { returnendif
  virtual   as_Gotojava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  virtual If*               as_If()              { return NULL; }
    java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
int(  _block_id java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  virtual *as_Return(           NULL; }
  virtual Throw*            as_Throw()           { return NULL; }
  virtual              as_Base(){ return ; java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  virtual RoundFP*          java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  virtual ExceptionObject*  as_ExceptionObject() { return NULL; }
         (       {return NULLjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
   virtual ProfileInvoke*    as_ProfileInvoke( { return NULL; 
  virtual RangeCheckPredicate ()const{  d

#ifdef java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 80
*  int number_of_sux() const            = suxl) ;java.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
#endif

  voidvisit(* )       0

  virtual bool can_trapLIR_List    sux_at(nti java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 72

  virtual void input_values_do(ValueVisitor* f)   = 0  BlockBegin default_sux( const                  sux_at(number_of_sux() - 1); }
  virtual void state_values_do(ValueVisitor* f);
  virtual void other_values_do(  void substitute_sux(BlockBegin old_sux, BlockBegin new_sux;
          void       values_do(java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 2

  virtual
  virtual ciType* declared_type(LEAF(Goto,BlockEnd

  // hashing
  virtual const char* name( enum Direction {
  HASHING1(Instruction, false, id())             // hashing disabled by default

  // debugging
  static void check_state(ValueStack* state)     PRODUCT_RETURN;
int)PRODUCT_RETURN
  void print_line()                              PRODUCT_RETURN;
  voidprint )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  public
  class   // creation
   public:                                       \
    virtual class_name* as_##class_name()        { return this; }              \


#define LEAF(class_name, super_class_name)       \
  (java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 50
   public:                                       * =BlockList()java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    virtual (s;
    virtual void visit(InstructionVisitor* v)    { v->do_##class_name(this); } \


// Debugging support


#ifdef ASSERT
class AssertValues: public ValueVisitor {
  void visit(Value* x)             { assert((*x) != NULL, "value must exist"); }
};
  #define ASSERT_VALUES, direction() {
#else
  #define ASSERT_VALUES
#endif // ASSERT


// 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.
  }

LEAF(Phi, Instruction)
 java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 9
  int         _; // the flags of the phi function
   local
 public:
  // creation
  Phi(ValueType* type, BlockBegin* b, int index&)                      return_live_in        }
   type>)
  , _pf_flags(0)
  , _index(index)
    (                     {return       
    _block = b;
    java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 62
    if (type->is_illegal()) {
      )
    }
  }

  // flags
   (c{return fjava.lang.StringIndexOutOfBoundsException: Range [79, 74) out of bounds for length 80
      =,
    visited         = 1 << 0,
    cannot_simplify =  <<1
  };

//
  bool  is_local() java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 10
  bool  is_on_stack() const       { return !is_local(); }
  int)const       {asserti(,"Value       _;
  int   stack_index() const       { assert(is_on_stack(), ""); return -  set_dominator(*  djava.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 70

  Value operand_at intd)                {
  int   operand_count() const;

voidset f)               |;}
  void   clear(Flag f)              (int lsn)   V x cond,bool,Valuey)
  bool   is_set(Flag f) const     { return (_pf_flags & fvoid

/java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
  // (these should never be referenced, otherwise the bytecodes are illegal)
     make_illegal) {
    set(cannot_simplify);
         )java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  bool is_illegal(void(int )         =  }
   return ()-is_illegal(   (ResourceBitMapmap)   live_in =map;  
  }

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  virtual void input_values_do(  virtual void input_values_do(ValueVisitor){f-visit(&_x); -&)&nbsp;java.lang.StringIndexOutOfBoundsException: Range [81, 70) out of bounds for length 70
  }
};


// A local is a placeholder for an incoming argument to a function call.
LEAF( java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 private:
  int      _java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 9
  _;// if local variable holds the receiver: "this" for non-static methods
  ciType*  _declared_type;
 public:
  // creationvoidset_first_lir_instruction_id id)     
  (ciType* void set_last_lir_instruction_id         l    java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
     tjava.lang.StringIndexOutOfBoundsException: Range [22, 22) out of bounds for length 8
    , _java_index(index)
java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 28
    , _declared_typeRangeCheckPredicateV , java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 125
  {
  // generic
  }

  // accessors
  int java_index()const                         {
  bool is_receiverint)constjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

  virtual*)  oidjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

  / generic
  virtual input_values_do(*   {/* no values */ }
};


LEAF(Constant, Instruction)
 BlockB* i i const               { _predecessorsat    check_state();
  // creation
  Constant(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      Instruction(type, NULL,  add_exception_handler(*b);
  {
    assert(type->is_constant(), "must   (ValueStack*state : ( bool java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 92
  }

  Constant(ValueTypejava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  ,,,/*type_is_constant*/ true)
  {
    assert(state_before !  java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
        _x = _  ;
    set_flag(KillsMemoryFlag, kills_memory);
pin;/
  }

  // generic
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  virtual void java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

  virtual intx hash() const;
    // accessors

  virtual ciType* exact_type()   Condition cond() const            java.lang.StringIndexOutOfBoundsException: Range [35, 25) out of bounds for length 43

  bool kills_memory() const { return check_flag(KillsMemoryFlag); }

  enum  java.lang.StringIndexOutOfBoundsException: Range [39, 37) out of bounds for length 68

  virtual java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 85
  BlockBegin (Instruction:Condition cond, Value , Value right
                      BlockBegin* true_sux, BlockBegin* false_sux) const {
     (java.lang.StringIndexOutOfBoundsException: Range [0, 19) out of bounds for length 12
    case linear_scan_loop_end_            < 10  java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 88
       NULL
    case :
      return false_sux;
    case cond_true:
      return true_sux;
    default:
      ShouldNotReachHere();
      return NULL;
java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 5
  }private:
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2


BASE(AccessField, Instruction)
 private:
  Value       ;
  int         _offset;
  ciMethod*  p;
/

 public:
  // creation
  AccessField(Value obj, int offset, ciField* field, bool is_static,
              ValueStackstate_before bool needs_patching)
                               // bytecode stream?
  , _obj(obj)
  , _java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 8
  ,
  , _java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
  {
    ValueCondition , java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 143
    , )
    set_flag(NeedsPatchingFlag, needs_patching);
    ASSERT_VALUES
    // pin of all instructions with memory access
    pin();
  }

  // accessors
   ( java.lang.StringIndexOutOfBoundsException: Range [50, 19) out of bounds for length 65
   )  , _profiled_methodjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  ciField* field() const                                (,java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  BasicType field_type() const                   {  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    set_flag(UnorderedIsTrueFlag, unordered_is_true);
  NullCheck* explicit_null_check() const         { return _explicit_null_check; }
            check_flag) java.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90

    void print_block(InstructionPrinter& ip, bool live_only = false) PRODUCT_RETURN; s   BlockList()java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    s->appendjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
  // of the static fields but it's simpler to model it here.
  bool java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 3

  // manipulation*  (                                 { _;}

  // 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
  
  void({ return_ java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 0

  // generic
  virtual BlockBegin tsux(                         return sux_for(true);}
  virtual voidinput_values_doValueVisitor ){ f>visit(&obj); }
};


LEAF(LoadField, AccessField
 public:
  // creation
  LoadFieldValueobj, offset for  >(  1; >0  java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 94
            ValueStack*endif
  : AccessField sux= ;
  {}

   profiled_bci const{ return p; }    // set for profiled branches and tiered

  // generic; cannot be eliminated if needs patching or if volatile.
  HASHING3 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
};


LEAF(StoreField/
 private:
  _java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 15

 public:
  // creation
  StoreField(Value obj, int offset, ciField* field,   
             ValueStack* state_before, bool java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 44
  : AccessField(obj, offset, field, is_static, state_before, needs_patching)
  , _value(value)
  {
    set_flag(NeedsWriteBarrierFlag, as_ValueType  void   ) return(IsSafepointFlag }
    ASSERT_VALUES
    pin();
  }


   value)const{ return ; java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    void boolvalue                    { _swapped ;}

  // generic
  virtual
};


  ockEnd)
 private:
  Value_;

 public:
  // creation
  AccessArray(ValueType* type, Value array, ValueStack* state_before)
  : (type java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  , _array(array)
  {{
    set_needs_null_check(true);
     void substitute_sux(BlockBegin* old_sux, BlockBegin* new_sux);
    pin(); Switch(Value tag, BlockList* sux, ValueStack* state_before, bool is_safepoint)
  }

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  // generic
  virtual boolkEnd)
  virtual void java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 17
}


  //  enum Direction { java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 private
  NullCheck*  _explicit_null_check;              // For explicit null check elimination


  // creation
ArrayLength(Value ,java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
  : AccessArray(intType,array, state_before)
  , _explicit_null_check(NULL) {}

  // accessors
  NullCheck* explicit_null_check() const         { java.lang.StringIndexOutOfBoundsException: Range [0, 57) out of bounds for length 28

  // setters
  // See LoadField::set_explicit_null_check for documentation
  void set_explicit_null_check :

  // generic
HASHING1Atrue-subst()java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
};


BASE(AccessIndexed, AccessArray)
 private:
  Value     _ndex;
  Value     _length;
  BasicType _elt_type;
  bool      _mismatched;

 public:
   creation
  AccessIndexed(Value array,    :Switch(ag,sux, state_before, is_safepoint)
  (as_ValueType l(lo_key  lo_key = hi_key,ioverflow"}
  , _index(index)
  ,
  , _elt_type(elt_type)
  , _mismatched(mismatched)
  {
on:, truejava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    ASSERT_VALUES
java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 3

  // accessors
                                              _direction(none) {
  Value length() const                           { return _length; }
  BasicType elt_type() const                     { return _elt_type; }
  bool mismatched() const                        { return _mismatched; }

  java.lang.StringIndexOutOfBoundsException: Range [19, 6) out of bounds for length 68
  // perform elimination of range checks involving constantsProfileMDOFlag }
  bool compute_needs_range_check();

  // generic
  virtual void input_values_do(ValueVisitor* f)   { AccessArray::input_values_do(f); f->visit(&_index); if (_length != NULL) f->visit(&_length); }
};


LEAF(LoadIndexed, AccessIndexed)
 private:
  NullCheck  _xplicit_null_check              /  

 public:
  // creation
 arrayValuelength     :Switcht ,state_before,is_safepoint)
  :,_(keys {
  , _explicit_null_check(NULL) thod* method)     { _profiled_method   methodjava.lang.StringIndexOutOfBoundsException: Range [76, 44) out of bounds for length 44

  // accessors
  NullCheck   void set_profiled_bci(int bci){ _rofiled_bci =bci; }

  // setters
  / See LoadField::set_explicit_null_check for documentation
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  ciType* exact_type() const;
  ciType* declared_type() const;

  // generic;
  HASHING3(LEAF(Assert,Instruction
};


LEAF(toreIndexed AccessIndexed)
 private:
  Value       _valuejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

  ciMethod* _profiled_method;
  int       pjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
  bool      _check_boolean;

 public:
  // creation
    Value result publicjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
   boolcheck_boolean mismatched =false)
  : AccessIndexed(array, index, length, elt_type, state_before, mismatched)
  , _value(value), _profiled_method(NULL), _profiled_bci(0), _check_boolean(check_boolean)
  {
    set_flag(NeedsWriteBarrierFlag (s_ValueType(elt_type)>is_object()));
    set_flag(NeedsStoreCheckFlag, (java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
    ASSERT_VALUES
    pin()   (                                  x}
  }

  // accessors
  Value value() const                            { return _value; }
  boolhas_result( const                        { return result( ! char*)const  _message; }
  bool needs_store_check() const                 { return check_flag(NeedsStoreCheckFlag); }
  bool java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
  // Helpers for MethodData* profiling
  void set_should_profile(bool value)                {java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 12
  voidset_profiled_method(ciMethod* method)         { _profiled_method =  virtual void input_values_do(ValueVisitor* f)  { f->visit(&_x); f->visit(&_y); }
  void set_profiled_bci(int bci)                     { _profiled_bci = bci;         }
  bool      should_profile() const                   { return check_flag(ProfileMDOFlag); }
  ciMethod* java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 0
  int       profiled_bci() const                     { return _profiled_bci;        }
  // generic
  virtual void input_values_do(ValueVisitor* f)   { AccessIndexed::input_values_do(f); f-  Value       _;
};


LEAF(NegateOp, 
 private:
  Value _x;

 public:
  // creation
  NegateOp(public
    ASSERT_VALUES
  }

    ASSERT_VALUES
  Value x() (Valuex Condition  }

  // generic
  virtual   // accessors
V )const                         _; }


BASE(Op2, Instruction)
 private:
 _op;
  Value           _x;
lue           _;

 public:
  // creation
  Op2};
  : Instruction(type, java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 27
  , _op(op)
  , _x(x)
  , _y(y)
  {
    ASSERT_VALUES
  }

  // accessors
  Bytecodes assert>java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 87
  Value x()        assert =NULL
 y)     snewjava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 36

  // manipulators
  void java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
    assert(is_commutative(), "operation   Valuex(    s>append java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    Value t = _x; _x = _y; _y = t;
  }

  // generic
  virtual bool is_commutative() const            { return false; }
  virtual void   Value y() const      y java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
};


LEAF(ArithmeticOp, Op2)
 // gen
  // creation
    virtual voidinput_values_do(ValueVisitor* fjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  : Op2(x->type()->meet(y->type()), op, x, y, java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
  {
    if (can_trap  java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  }

  // generic
  virtual bool is_commutative() const;
  virtual java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 5
  Op2, ,x-subst) )-subst(java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
};


LEAF:
 public:
  // creation
  ShiftOp(Bytecodes::Code op, Valuejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  // generic
  HASHING3(Op2, true, op(), x()->subst(), y()->subst()public:
};


LEAF(LogicOp, Op2)
 :
  // creation
  (ytecodes: op in(java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

  // generic
  virtual
  HASHING3(Op2, true, op(), x()->subst /generic
};


LEAF(CompareOp, Op2)
 public:
  // creation
  CompareOp(Bytecodesjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  :Op2intType , x, ,state_before)
  {}

  // generic
  HASHING3(,/ storedintolocalvariables  could usedto model
};


private
 private:
  Value _tval;
  Value _fval;

 public:
  // creation                                 _;}
  IfOp(Value x, Condition cond,  {
  e()meet(-)) B:Code) x,java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  ,
  , _fval(fval)
  {
    ASSERT_VALUES
    asserttval>ype()>tag( = >)-> (is_true  0 : 1;}
  }

  // accessors
  virtual bool java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 12
                       {houldNotCallThis;  :_java.lang.StringIndexOutOfBoundsException: Range [100, 98) out of bounds for length 101
  Condition cond
  Value tvaljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  Value fval() const                             {   (                       return sux_for((alse;}

  // generic
  virtual void input_values_do(ValueVisitor* f)   Value_object  BlockBegin*usux) const                       {{ return sux_for(unordered_is_true)); }
};


LEAF(Convert, Instruction)
 private:
  Bytecodes::Code _op;
  Value           _value;

 public:
  // creation
  Convert(Bytecodes::Code op, Value value, ValueType* to_type) : Instruction(to_type), //
    ASSERT_VALUES// creation
  }

  // accessors
  Bytecodes::Code op() const                       void swap_operands() {
  Value value() const                            { return _value; }

  // generic
  virtual void input_values_do(ValueVisitor* f)   { f->visit(&_value); }
  HASHING2(Convert, true, op(), value()->subst())
};


kjava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28
 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  Value       _obj;

 public:
  // creation
  NullCheck(Value obj, ValueStack* state_before)
  : Instruction(obj->type()->base(), state_before)
  , _obj(obj)
  {
    ASSERT_VALUES
    set_can_trap(true);
    ssert_obj->(->  BasicType basic_type()         return b
    pin(Instruction::PinExplicitNullCheck);
  }

  // accessors
  Value obj() const                              { return _obj; }

  // setters
  void set_can_trap(bool can_trap)               { set_flag(CanTrapFlagis_volatile(

  // generic  // generic
  virtualboolcan_trap) const                    check_flag(( virtual  input_values_do(ValueVisitorf)  { f>(_bject;
  virtual void input_values_do(ValueVisitor* f)   { f->visit(&_obj); }
  HASHING1(NullCheck, true, obj()->subst())
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2


// This node is supposed to cast the type of another node to a more precise
// declared type.
LEAF(TypeCast, Instruction)
 private  // creation
  ciType* _declared_type;
  Value   _obj;

 publicjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  // The type of this node is the same type as the object type (and it might be constant).
  TypeCast(ciType* type, Value obj, ValueStack* state_before)
  : Instruction(obj->type(), state_before, obj->type()->is_constant()),
    _declared_type(type),
    _    ASSERT_VALUES

  // accessors
  ciType* declared_type() const                  return _declared_type; }
  Value   obj() const                            { return _obj; }

  // generic
  virtual  input_values_do(ValueVisitor* f)  { f->visit(&_obj); }
};


BASE (                                return ; }
 private:
  ValueStack _state;

 protected:
  static void  UnsafeOp(, object,  ),_()

 public:
  // creation
  java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  : Instruction(type, state_before)
  , _state(NULL)
  {
    pin(inStateSplitConstructor);
  }

  // accessors
  ValueStack* state() const                      { return _state; }
  IRScope* scope() const;                        // the state's scope

  // manipulation
  void set_state(ValueStack* state)              { 

  // generic
  virtual void input_values_do(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  virtual void state_values_do(ValueVisitor* f);
};


LEAF(Invoke,StateSplit
 private:
  Bytecodes     Switch(,java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 50
  Value           _recv
  Values         _args  / accessors
  BasicTypeList*  _signature;
  ciMethod*       _target;

 public
  // creation
oke(ytecodes::Code code, java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 3
re)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

  / accessors
  Bytecodes::Code code() java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  ValueLEAF( java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  bool
  intArray _;
  Value argument_at(int i) const                 virtual void input_values_do(ValueVisitor* f)   { UnsafeOp::input_values_do(f);
  BasicTypeList* signature() const               { return  // creation
java.lang.StringIndexOutOfBoundsException: Range [20, 18) out of bounds for length 68

  ciType* declared_type() const;

  // Returns false if target is not loaded
  bool target_is_final() const                   { return check_flag(TargetIsFinalFlag); }
   target_is_loaded) onst{LEAF(UnsafeGetAndSet, UnsafeOp)

  // JSR 292 support
  bool is_invokedynamic() const                  { return code() == private:
  bool is_method_handle_intrinsic(   value                                  

  virtual bool needs_exception_state() const     

  // generic
  virtual bool can_trap() const                  {public:
  virtual void (ValueVisitor  UnsafeGetAndSet(asicTypebasic_type Value object, Value,Value  )
    StateSplit::input_values_do(f);
    if (has_receiver()) f->visit(&_recv);
    for (int i = 0 UnsafeOp(basic_type,java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 0
  }
  virtual void state_values_do(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 19
};


LEAF(NewInstance, StateSplit)
 private:
  ciInstanceKlass* _klass;
  bool _is_unresolved;

 public:
  // creation
wInstanceciInstanceKlass* klass, ValueStack* state_before, bool is_unresolved)
  : StateSplit(instanceType, state_before)
  , _klass(klass),    (esult= NULL 
  {}

  // accessors
  ciInstanceKlass*
  bool is_unresolved() const                     { return _is_unresolved; }

  virtual bool needs_exception_state() const     { return false; }

  // generic
  virtual bool can_trap() const                  { return true; }
  ciType* exact_type() const;
  *declared_type() ;
};


BASE(NewArray, StateSplit)
 private:
  Value       _length;

 public:
  // creation
  NewArraylength * state_before)
  : StateSplit(objectType, state_before)
  , _length(length)
  {
    // Do not ASSERT_VALUES since length is NULL for NewMultiArray
  }

  // accessors
   length) const                            return _length;}

  virtual  needs_exception_state() const      return false; }

  ciType* exact_type() const                     { return NULL; }
  * () const;

  // generic
  virtual
  virtual void input_values_do(ValueVisitor* f)   { StateSplit:    ciKlass*         ;
};


LEAF(NewTypeArray, NewArray)
 privateArgsNonNullState _nonnull_state;  // Do we know whether some arguments are never null?
  BasicType _elt_type;

 publicjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 8
  // creation
  NewTypeArray
  : NewArray(length, state_before)
    ProfileCall(ciMethod* method,intbci ciMethod   accessors
  {}

  // accessors
  BasicType     , _method(method
  ciType* exact_type() const;
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2


LEAF(NewObjectArray, NewArray)
 private:
  ciKlass* klass;

 :
  // creation
  NewObjectArray(ciKlass* klass,_obj_args(bj_args)

  // accessors
  ciKlass* klass() const                         { return _klass; }
  ciType exact_type( const;
};


LEAF(NewMultiArray, NewArray)
 private:
    assert(-is_set(lockBegin:td_entry_flag)    }
  Values*  _dims;

 public:
  
  NewMultiArray(if (osr_entry !          java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
    ASSERT_VALUES
      ()

  // accessors
  ciKlass* klass() const                         { return _klass; }
  Values* dims()  BlockBegin* )const                   ); java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
   {java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 77

  // generic
  virtual void input_values_do(ValueVisitor* f) {
input_values_do ""
    // is meaningless for a multi-dimensional array; passing the}
    // zeroth element down to NewArray as its length is a bad idea
    java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    // get updated, and the value must not be traversed twice. Was bug
    // - kbr 4/10/2001
    :f;
    for (int i = 0; i < _dims->length();   OsrEntry() : Instruction(longType) { pin
  }
};


BASE(TypeCheck, StateSplit)
 private:
  ciKlass*    _klass;
  Value       _obj;

  ciMethod* _profiled_method;
  int       _profiled_bci;

 public:
  // creation
  TypeCheckjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  : StateSplit(type, state_before), _klass(klass), _obj(obj),
    _(NULL, _profiled_bci(0){
    ASSERT_VALUES
    set_direct_compare(false);
  }

  // accessors
  ciKlass* klass() const                         { return _  ExceptionObject( objectType){
  Value obj()constvirtual void input_values_do(ValueVisitor f)   java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  bool}
  bool direct_compare() const                    { 

  // manipulation
  oidset_direct_compare(bool flag)             {set_flag(DirectCompareFlag,; java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87

  // generic
  virtual bool can_trap() const                  { return truejava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  virtual void input_values_do(ValueVisitor* f)   { StateSplit::input_values_do(f); f->visit(&_java.lang.StringIndexOutOfBoundsException: Range [0, 98) out of bounds for length 3

  // Helpers for MethodData* profiling
  id(                 ; }
  void // Currently only private
  void set_profiled_bci(int bci)                     { _profiled_bci = java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 27
  bool      should_profile() const                     ciMethod*        _callee;
  ciMethod* profiled_method() const  int              _bci_of_invoke;
  int       profiled_bci() const                     { return _profiled_bci;        }
};


LEAF(CheckCast, TypeCheck)
 public:
  // creation
  CheckCast public:
  :  RoundFP(Value  ProfileReturnType((java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 75

  void    :Instruction(oidType)
    set_flag(ThrowIncompatibleClassChangeErrorFlag, true);
  }
  bool,_allee(callee
    return check_flag(ThrowIncompatibleClassChangeErrorFlag);
  }
    , _etret)
    set_flag(InvokeSpecialReceiverCheckFlag, true);
  }
  bool is_invokespecial_receiver_check() const {
    return check_flag(InvokeSpecialReceiverCheckFlag);
  }

  virtual bool     / The ProfileType has side-effects and must occur precisely where located
    return !    pin(;
  }

  ciType* declared_type() const;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


LEAF(InstanceOfinput_values_do(ValueVisitor* f)   {llee; }
 public:
  // creation
  InstanceOfciKlass;

  virtual bool needs_exception_state() const     { return false; }
};


BASE(  Value ret()    const  _private:
 private:
  Value       _obj;
  _java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

 publicbool  is_volatile;// true if volatile - dl/JSR166
  // creation
  AccessMonitorV obj, int monitor_no, *      f>&_et)
  : StateSplit(illegalType, state_before)
  , _obj(obj)
  , _monitor_no(monitor_no)
  {
    set_needs_null_check(true);
    ASSERT_VALUES  // creation
  }

  // accessors
  Value obj() const                              { return _obj; }
  LEAF, 

  // generic
  virtualconst  _ntry_name
};


LEAFValues*     args
 public:
  // creation
  MonitorEnter(Value obj,     
  : AccessMonitor(obj, monitor_no, state_before)
  {
    ASSERT_VALUES}
   public:

ublicjava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 8
  () constbasic_type(  return bjava.lang.StringIndexOutOfBoundsException: Range [70, 69) out of bounds for length 72
};


MonitorExit,AccessMonitor)
 public:
  // creation
  MonitorExit(Value obj, int monitor_no)
  : AccessMonitor(obj, monitor_no, NULL)
  {
    ASSERT_VALUES
  }
};


LEAF(Intrinsic, StateSplit)
 private:
  vmIntrinsics::ID _id;
         _args;
  Value            _recv;
  ArgsNonNullState _nonnull_state;

 public:
  // preserves_state can be set to true for Intrinsics
  // which are guaranteed to preserve register state across any slow
  ttingit totrue not  meanthat theIntrinsic 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
  
*type
            vmIntrinsics::ID id,
            Values* args,
            bool has_receiver,
            ValueStack* state_before,
            
            bool cantrap = true)
  : StateSplit(type, state_before)
  , _id(id)
  , _args(args)
  , _recv(NULL)
  {
    assert(rgs! NULL,"args must exist");
    ASSERT_VALUES
set_flag(preserves_state)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    set_flag(CanTrapFlag,        cantrap);
    if
      _recv = argument_at
    }
 publicjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8

    // some intrinsics can't trap, so don't force them to be pinned
: 
      unpin(PinStateSplitConstructor);
    }
  }

  // accessors
  vmIntrinsicsValue value    / The ProfileInvoke has side-effects and must occur precisely where located QQQ???java.lang.StringIndexOutOfBoundsException: Range [33, 24) out of bounds for length 87
  int number_of_arguments() const                { return _args->length(); }
  BasicType ,  , offset,Value value,bool )

  bool has_receiver() const                      _volatile)
  Value receiver() const                         { assert(has_receiver(), "must have receiver"); return _recv  ValueStack state(       java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 19
  bool preserves_state() const                   { returnvoid input_values_do(lueVisitor* }

  bool arg_needs_null_check(int i) const  
    return _nonnull_state.arg_needs_null_check(i);
  }

  void  Value,Instruction)
    _nonnull_state.set_arg_needs_null_check(i, check);
  }

  // generic
  virtual bool can_trap() const                  { return check_flag(  virtual void input_values_do(ValueVisitor* f)   { UnsafeOp::input_values_do
  virtual input_values_do(ValueVisitor*java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 23
    StateSplit::input_values_do(f);
    for     Instruction(voidType)
  }
};


class LIR_List;

{
    ()
  int        _block_idbool_is_add;
  int  code({ basic_type,Value, Value offset,Value value,bool )
          depth_first_number;                 number of this block in
  int       linear_scan_number // ofthis  inlinear ordering
  int        _dominator_depth;
  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

 / 
  int             public:
ResourceBitMap _stores_to_locals;              // bit is set when a local variable is stored in the block

  
  BlockList   _predecessors;                     // the predecessors of this block
 lockList                           // list of blocks that are dominated by this block
  BlockBegin* _dominator;                        // the dominator of this block
  // SSA specific ends
    ;                               
  BlockList  exception_handlers                
 xhandler entries:states  allinstructions  anto this xhandler
  int        _exception_handler_pco;             // if this block is the start of an exception handler,
                                                    PC offset  the  code the
                                                 // first instruction in this block
  Label      _label;                             // the label associated with this block
  LIR_List*  _lir;                               // the low level intermediate representation for this blockinline int          method;

  ResourceBitMap _live_in;                       // set of live LIR_Opr registers at entry to this block BlockBegin* BlockBegin::sux_at(int i const{ assert(  ciMethod*_allee        /the method  is called atthe  bci
ciKlass         known_holder;
  ResourceBitMap _live_gen;                      // set of registers used before any redefinition in this block
  ResourceBitMap _live_kill;                     // set of registers defined in this block

  ResourceBitMap _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
  _;       

  void iterate_preorder (:Instructionv)
  void iterate_postorder(boolArray& mark, BlockClosure* closure);

  friend class SuxAndWeightAdjuster;

 public:
   void* operator new(size_t size) throw() {
    Compilation* c = Compilation::current();
    void* res = c->arena()->Amalloc(size);
         obj_args(obj_args)
  }

  // initialization/counting
  static int  number_of_blocks(){
    return Compilation::current()->number_of_blocks();
  }

  // creation
  BlockBegin(int bci)
  : StateSplit(java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 3
  ,_block_id(Compilation::urrent(->get_next_block_id())
  , _bci(bci)
  )
  , _linear_scan_number(-1)
  , _dominator_depth(-1)
  , _loop_depth(0)
  , _loop_index(-1)
  , _flags(0)
  ,_otal_preds(0)
  , _stores_to_locals()
  , _predecessors(2)
  , _dominates(2)
  , _dominator(NULL)
  , _end(NULL)
  , _exception_handlers(1)
  , _exception_states(NULL)
  , _exception_handler_pco(-1)
  , _lir(NULL)
  , _live_in()
  ,_live_out(
  , _live_gen()
  ,_ive_kill)
  , _fpu_register_usage()
  , _fpu_stack_state  bool arg_needs_null_check(int i) const {
  , _first_lir_instruction_id(-1)
  , _last_lir_instruction_id(-1)
  {
    _block = this;
#ifndef PRODUCT
    set_printable_bci(bci);
#endif
 }

  // accessors
  int block_id
   bci(                                   _bci; }
  BlockList* dominates()                         { return &_dominates; }
  BlockBegin* dominator() const                  { return _dominator; }
  int loop_depth() java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 0
  int dominator_depth() const                    { return _dominator_depth; }
  int depth_first_number() const                 { return _java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 52
  int _nonnull_stateset_arg_needs_null_check( check;
  BlockEnd* end() const                          
  Label* label()                                 (ValueVisitor* ){
  LIR_List* lir() const                          { java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 23
  int exception_handler_pco() const              >_>()
  ResourceBitMap& live_in()}
  ResourceBitMap& live_out()                     { return _live_out;       }
  ResourceBitMap& LEAF(ProfileReturnType,Instruction)
  ResourceBitMap& live_kill()                    { return _live_kill;      }
  ResourceBitMap& :
  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 _java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 24
  BitMap& stores_to_locals()                     { return _stores_to_locals; }

  // manipulation
  void set_dominator(BlockBegin* dom)            { _dominator = dom; }
  void set_loop_depth(int     : Instruction(voidType)
  void set_dominator_depth(int d)                { _dominator_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* new_end);
  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(     _callee(callee)
  void set_exception_handler_pco(int pco)        { _java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 25
  void set_live_in  (
  void set_live_out (const ResourceBitMap& map)  { _live_out =
  void set_live_gen (const ResourceBitMap& map)  { _live_gen = map;  }
  void set_live_kill(const ResourceBitMap& map)  { _live_kill = map; }
  void set_fpu_register_usage(const ResourceBitMap& map) { _fpu_register_usage = map; }
  void set_fpu_stack_state(intArray* state    // The ProfileType has side-effects and must occur precisely where located
  void java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 10
  void set_last_lir_instruction_id(int
    ciMethod* method()             const { return _method; }
  void init_stores_to_locals(int locals_count)   { _stores_to_locals.initialize(locals_count); }

  // generic
   (const{return bjava.lang.StringIndexOutOfBoundsException: Range [64, 62) out of bounds for length 65

  // successors and predecessors
  int number_of_sux() const;
  BlockBegin* sux_at(int i) const;
  void add_predecessor(BlockBegin*pred)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
  void remove_predecessor(BlockBegin* pred);
  boolf>visit(&r)
  int number_of_preds() const                    { return _predecessors.length(); }
  BlockBegin* pred_at(int i) const               { return _predecessors.at(i); }

  // exception handlers potentially invoked by this block
  // Call some C runtime function that doesn't safepoint,
  bool is_exception_handler(BlockBegin*  as the first argument.
  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     entry
  ValueStack* exception_state_at(int idx   _  java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
  int add_exception_state(ValueStack* state);

  // flags
  enum Flag {
    no_flag                       = 0,
    std_entry_flag                = 1 << 0,
    =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,
    =1 < 7 /
    critical_edge_split_flag      = 1 << 8, // set for all blocks that are introduced when critical edges are split
    linear_scan_loop_header_flag  = 1 << 9, // set during loop-detection for LinearScan
    linear_scan_loop_end_flag     = 1 << 10, // set during loop-detection for LinearScan
      }
  };

    constchar* entry_name( const  {  entry_name;java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  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  (bool pass_thread() const        { return;}

  ValueVisitorf;

  // loops
   (                     _  ;}
  int  loop_index() const                        { return _loop_index;      }

  // merging
  bool try_merge(ValueStack* state, bool has_irreducible_loops);  // try to merge states at block begin
  void merge(ValueStack* state, bool has_irreducible_loopsLEAF(rofileInvoke 
    bool b = try_merge(state, has_irreducible_loops)  java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 23
    rt(, "merge failed");
  }

  // debugging
  void print_block()                             PRODUCT_RETURN;
  void print_block(InstructionPrinter& ip, bool live_only = false) PRODUCT_RETURN;

};


BASE(java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 3
 
  BlockList*  _ValueStack* state _}

 protected:
  (                          { java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 65

  void set_sux(BlockList* sux) {
#(MemBar java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 25
 private:
    for (int i = sux->length() - 1; i >= 0; i--) assert  LIR_Code code;
#endif
    _sux = sux
  }

 public:
  // creation
  BlockEnd(ValueType* type, ValueStack
    java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 34
  , _virtual java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 50
  {
    set_flag(IsSafepointFlag, is_safepoint);
  }

  / accessors
  bool is_safepoint() java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  // For compatibility with old code, for new code use block()
  BlockBegin* begin() const                      { return _block; }

  // manipulation
  inline void remove_sux_at(int i) { _sux->remove_at(i  BlockBegin* from( const { return_;}
  inline int find_sux(BlockBegin* sux) {return _sux->find(sux);}

  // successors
  int number_of_sux() const                      { return _sux != NULL ? _sux->length() : 0; }
  BlockBegin* sux_at(int i) const                { return _sux->at(i); }
  bool is_sux(BlockBegin* sux) const             { return _suxvoidset_to(*)   {_ = b;}
  BlockBegin* default_sux() const                { return sux_at(number_of_sux() - 1); }
  void substitute_sux(typedef GrowableArray<BlockPair*> BlockPairList;
};


LEAF(Goto, BlockEnd)
 
  enum java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
    none,            // Just a regular goto
    taken,not_taken// Goto produced from If
  };
 private:
  ciMethod*   _profiled_method;
  int         _profiled_bci;
  Direction   _direction;
 public:
  // creation
  Goto(BlockBegin* sux, ValueStack* state_before, bool is_safepoint = false)
    : BlockEnd(illegalType, state_before, is_safepoint)
    , _profiled_method(NULL)
    , _profiled_bci(0)
    , _direction(none) {
    BlockList* s = new BlockList(1);
    s->append(sux);
    set_sux(s);
  }

  Goto(BlockBegin* sux, bool is_safepoint) : BlockEnd(illegalType, NULL, is_safepoint)
                                           , _profiled_method(NULL)
                                           , _profiled_bci(0)
                                           , _direction(none) {
    BlockList* s = new BlockList(1);
    s->append(sux);
    set_sux(s);
  }

  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; }
  Direction direction() const                    { return _direction; }

  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; }
  void set_direction(Direction d)                { _direction = d; }
};

#ifdef ASSERT
LEAF(Assert, Instruction)
  private:
  Value       _x;
  Condition   _cond;
  Value       _y;
  char        *_message;

 public:
  // creation
  // unordered_is_true is valid for float/double compares only
   Assert(Value x, Condition cond, bool unordered_is_true, Value y);

  // 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; }
  const char *message() const                    { return _message; }

  // generic
  virtual void input_values_do(ValueVisitor* f)  { f->visit(&_x); f->visit(&_y); }
};
#endif

LEAF(RangeCheckPredicate, StateSplit)
 private:
  Value       _x;
  Condition   _cond;
  Value       _y;

  void check_state();

 public:
  // creation
  // unordered_is_true is valid for float/double compares only
   RangeCheckPredicate(Value x, Condition cond, bool unordered_is_true, Value y, ValueStack* state) : StateSplit(illegalType)
  , _x(x)
  , _cond(cond)
  , _y(y)
  {
    ASSERT_VALUES
    set_flag(UnorderedIsTrueFlag, unordered_is_true);
    assert(x->type()->tag() == y->type()->tag(), "types must match");
    this->set_state(state);
    check_state();
  }

  // Always deoptimize
  RangeCheckPredicate(ValueStack* state) : StateSplit(illegalType)
  {
    this->set_state(state);
    _x = _y = NULL;
    check_state();
  }

  // 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; }

  void always_fail()                             { _x = _y = NULL; }

  // generic
  virtual void input_values_do(ValueVisitor* f)  { StateSplit::input_values_do(f); f->visit(&_x); f->visit(&_y); }
  HASHING3(RangeCheckPredicate, true, x()->subst(), y()->subst(), cond())
};

LEAF(If, BlockEnd)
 private:
  Value       _x;
  Condition   _cond;
  Value       _y;
  ciMethod*   _profiled_method;
  int         _profiled_bci; // Canonicalizer may alter bci of If node
  bool        _swapped;      // Is the order reversed with respect to the original If in the
                             // bytecode stream?
 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)
  , _swapped(false)
  {
    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 for profiled branches and tiered
  bool is_swapped() const                        { return _swapped; }

  // manipulation
  void swap_operands() {
    Value t = _x; _x = _y; _y = t;
    _cond = mirror(_cond);
  }

  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;       }
  void set_swapped(bool value)                    { _swapped = value;         }
  // generic
  virtual void input_values_do(ValueVisitor* f)   { BlockEnd::input_values_do(f); f->visit(&_x); f->visit(&_y); }
};


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; }

  virtual bool needs_exception_state() const     { return false; }

  // generic
  virtual void input_values_do(ValueVisitor* f)   { BlockEnd::input_values_do(f); f->visit(&_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) { assert(_lo_key <= hi_key(), "integer overflow"); }

  // 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(ValueVisitor* f) {
    BlockEnd::input_values_do(f);
    if (has_result()) f->visit(&_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(ValueVisitor* f)   { BlockEnd::input_values_do(f); f->visit(&_exception); }
};


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) { pin(); }
#else
  OsrEntry() : Instruction(intType)  { pin(); }
#endif

  // generic
  virtual void input_values_do(ValueVisitor* f)   { }
};


// Models the incoming exception at a catch site
LEAF(ExceptionObject, Instruction)
 public:
  // creation
  ExceptionObject() : Instruction(objectType) {
    pin();
  }

  // generic
  virtual void input_values_do(ValueVisitor* f)   { }
};


// 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(ValueVisitor* f)   { f->visit(&_input); }
};


BASE(UnsafeOp, Instruction)
 private:
  Value _object;                                 // Object to be fetched from or mutated
  Value _offset;                                 // Offset within object
  bool  _is_volatile;                            // true if volatile - dl/JSR166
  BasicType _basic_type;                         // ValueType can not express byte-sized integers

 protected:
  // creation
  UnsafeOp(BasicType basic_type, Value object, Value offset, bool is_put, bool is_volatile)
    : Instruction(is_put ? voidType : as_ValueType(basic_type)),
    _object(object), _offset(offset), _is_volatile(is_volatile), _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; }
  Value object()                                 { return _object; }
  Value offset()                                 { return _offset; }
  bool  is_volatile()                            { return _is_volatile; }

  // generic
  virtual void input_values_do(ValueVisitor* f)   { f->visit(&_object);
                                                    f->visit(&_offset); }
};

LEAF(UnsafeGet, UnsafeOp)
 private:
  bool _is_raw;
 public:
  UnsafeGet(BasicType basic_type, Value object, Value offset, bool is_volatile)
  : UnsafeOp(basic_type, object, offset, false, is_volatile)
  {
    ASSERT_VALUES
    _is_raw = false;
  }
  UnsafeGet(BasicType basic_type, Value object, Value offset, bool is_volatile, bool is_raw)
  : UnsafeOp(basic_type, object, offset, false, is_volatile), _is_raw(is_raw)
  {
    ASSERT_VALUES
  }

  // accessors
  bool is_raw()                             { return _is_raw; }
};


LEAF(UnsafePut, UnsafeOp)
 private:
  Value _value;                                  // Value to be stored
 public:
  UnsafePut(BasicType basic_type, Value object, Value offset, Value value, bool is_volatile)
  : UnsafeOp(basic_type, object, offset, true, is_volatile)
    , _value(value)
  {
    ASSERT_VALUES
  }

  // accessors
  Value value()                                  { return _value; }

  // generic
  virtual void input_values_do(ValueVisitor* f)   { UnsafeOp::input_values_do(f);
                                                   f->visit(&_value); }
};

LEAF(UnsafeGetAndSet, UnsafeOp)
 private:
  Value _value;                                  // Value to be stored
  bool  _is_add;
 public:
  UnsafeGetAndSet(BasicType basic_type, Value object, Value offset, Value value, bool is_add)
  : UnsafeOp(basic_type, object, offset, false, false)
    , _value(value)
    , _is_add(is_add)
  {
    ASSERT_VALUES
  }

  // accessors
  bool is_add() const                            { return _is_add; }
  Value value()                                  { return _value; }

  // generic
  virtual void input_values_do(ValueVisitor* f)   { UnsafeOp::input_values_do(f);
                                                   f->visit(&_value); }
};

LEAF(ProfileCall, Instruction)
 private:
  ciMethod*        _method;
  int              _bci_of_invoke;
  ciMethod*        _callee;         // the method that is called at the given bci
  Value            _recv;
  ciKlass*         _known_holder;
  Values*          _obj_args;       // arguments for type profiling
  ArgsNonNullState _nonnull_state;  // Do we know whether some arguments are never null?
  bool             _inlined;        // Are we profiling a call that is inlined

 public:
  ProfileCall(ciMethod* method, int bci, ciMethod* callee, Value recv, ciKlass* known_holder, Values* obj_args, bool inlined)
    : Instruction(voidType)
    , _method(method)
    , _bci_of_invoke(bci)
    , _callee(callee)
    , _recv(recv)
    , _known_holder(known_holder)
    , _obj_args(obj_args)
    , _inlined(inlined)
  {
    // The ProfileCall has side-effects and must occur precisely where located
    pin();
  }

  ciMethod* method()             const { return _method; }
  int bci_of_invoke()            const { return _bci_of_invoke; }
  ciMethod* callee()             const { return _callee; }
  Value recv()                   const { return _recv; }
  ciKlass* known_holder()        const { return _known_holder; }
  int nb_profiled_args()         const { return _obj_args == NULL ? 0 : _obj_args->length(); }
  Value profiled_arg_at(int i)   const { return _obj_args->at(i); }
  bool arg_needs_null_check(int i) const {
    return _nonnull_state.arg_needs_null_check(i);
  }
  bool inlined()                 const { return _inlined; }

  void set_arg_needs_null_check(int i, bool check) {
    _nonnull_state.set_arg_needs_null_check(i, check);
  }

  virtual void input_values_do(ValueVisitor* f)   {
    if (_recv != NULL) {
      f->visit(&_recv);
    }
    for (int i = 0; i < nb_profiled_args(); i++) {
      f->visit(_obj_args->adr_at(i));
    }
  }
};

LEAF(ProfileReturnType, Instruction)
 private:
  ciMethod*        _method;
  ciMethod*        _callee;
  int              _bci_of_invoke;
  Value            _ret;

 public:
  ProfileReturnType(ciMethod* method, int bci, ciMethod* callee, Value ret)
    : Instruction(voidType)
    , _method(method)
    , _callee(callee)
    , _bci_of_invoke(bci)
    , _ret(ret)
  {
    set_needs_null_check(true);
    // The ProfileType has side-effects and must occur precisely where located
    pin();
  }

  ciMethod* method()             const { return _method; }
  ciMethod* callee()             const { return _callee; }
  int bci_of_invoke()            const { return _bci_of_invoke; }
  Value ret()                    const { return _ret; }

  virtual void input_values_do(ValueVisitor* f)   {
    if (_ret != NULL) {
      f->visit(&_ret);
    }
  }
};

// Call some C runtime function that doesn't safepoint,
// optionally passing the current thread as the first argument.
LEAF(RuntimeCall, Instruction)
 private:
  const char* _entry_name;
  address     _entry;
  Values*     _args;
  bool        _pass_thread;  // Pass the JavaThread* as an implicit first argument

 public:
  RuntimeCall(ValueType* type, const char* entry_name, address entry, Values* args, bool pass_thread = true)
    : Instruction(type)
    , _entry_name(entry_name)
    , _entry(entry)
    , _args(args)
    , _pass_thread(pass_thread) {
    ASSERT_VALUES
    pin();
  }

  const char* entry_name() const  { return _entry_name; }
  address entry() const           { return _entry; }
  int number_of_arguments() const { return _args->length(); }
  Value argument_at(int i) const  { return _args->at(i); }
  bool pass_thread() const        { return _pass_thread; }

  virtual void input_values_do(ValueVisitor* f)   {
    for (int i = 0; i < _args->length(); i++) f->visit(_args->adr_at(i));
  }
};

// Use to trip invocation counter of an inlined method

LEAF(ProfileInvoke, Instruction)
 private:
  ciMethod*   _inlinee;
  ValueStack* _state;

 public:
  ProfileInvoke(ciMethod* inlinee,  ValueStack* state)
    : Instruction(voidType)
    , _inlinee(inlinee)
    , _state(state)
  {
    // The ProfileInvoke has side-effects and must occur precisely where located QQQ???
    pin();
  }

  ciMethod* inlinee()      { return _inlinee; }
  ValueStack* state()      { return _state; }
  virtual void input_values_do(ValueVisitor*)   {}
  virtual void state_values_do(ValueVisitor*);
};

LEAF(MemBar, Instruction)
 private:
  LIR_Code _code;

 public:
  MemBar(LIR_Code code)
    : Instruction(voidType)
    , _code(code)
  {
    pin();
  }

  LIR_Code code()           { return _code; }

  virtual void input_values_do(ValueVisitor*)   {}
};

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; }
};

typedef GrowableArray<BlockPair*> BlockPairList;

inline int         BlockBegin::number_of_sux() const            { assert(_end != NULL, "need end"); return _end->number_of_sux(); }
inline BlockBegin* BlockBegin::sux_at(int i) const              { assert(_end != NULL , "need end"); return _end->sux_at(i); }

#undef ASSERT_VALUES

#endif // SHARE_C1_C1_INSTRUCTION_HPP