< prev index next >

src/hotspot/share/c1/c1_Instruction.hpp

Print this page


  55 class   AccessArray;
  56 class     ArrayLength;
  57 class     AccessIndexed;
  58 class       LoadIndexed;
  59 class       StoreIndexed;
  60 class   NegateOp;
  61 class   Op2;
  62 class     ArithmeticOp;
  63 class     ShiftOp;
  64 class     LogicOp;
  65 class     CompareOp;
  66 class     IfOp;
  67 class   Convert;
  68 class   NullCheck;
  69 class   TypeCast;
  70 class   OsrEntry;
  71 class   ExceptionObject;
  72 class   StateSplit;
  73 class     Invoke;
  74 class     NewInstance;

  75 class     NewArray;
  76 class       NewTypeArray;
  77 class       NewObjectArray;
  78 class       NewMultiArray;
  79 class     TypeCheck;
  80 class       CheckCast;
  81 class       InstanceOf;
  82 class     AccessMonitor;
  83 class       MonitorEnter;
  84 class       MonitorExit;
  85 class     Intrinsic;
  86 class     BlockBegin;
  87 class     BlockEnd;
  88 class       Goto;
  89 class       If;
  90 class       IfInstanceOf;
  91 class       Switch;
  92 class         TableSwitch;
  93 class         LookupSwitch;
  94 class       Return;


 160  public:
 161   virtual void do_Phi            (Phi*             x) = 0;
 162   virtual void do_Local          (Local*           x) = 0;
 163   virtual void do_Constant       (Constant*        x) = 0;
 164   virtual void do_LoadField      (LoadField*       x) = 0;
 165   virtual void do_StoreField     (StoreField*      x) = 0;
 166   virtual void do_ArrayLength    (ArrayLength*     x) = 0;
 167   virtual void do_LoadIndexed    (LoadIndexed*     x) = 0;
 168   virtual void do_StoreIndexed   (StoreIndexed*    x) = 0;
 169   virtual void do_NegateOp       (NegateOp*        x) = 0;
 170   virtual void do_ArithmeticOp   (ArithmeticOp*    x) = 0;
 171   virtual void do_ShiftOp        (ShiftOp*         x) = 0;
 172   virtual void do_LogicOp        (LogicOp*         x) = 0;
 173   virtual void do_CompareOp      (CompareOp*       x) = 0;
 174   virtual void do_IfOp           (IfOp*            x) = 0;
 175   virtual void do_Convert        (Convert*         x) = 0;
 176   virtual void do_NullCheck      (NullCheck*       x) = 0;
 177   virtual void do_TypeCast       (TypeCast*        x) = 0;
 178   virtual void do_Invoke         (Invoke*          x) = 0;
 179   virtual void do_NewInstance    (NewInstance*     x) = 0;

 180   virtual void do_NewTypeArray   (NewTypeArray*    x) = 0;
 181   virtual void do_NewObjectArray (NewObjectArray*  x) = 0;
 182   virtual void do_NewMultiArray  (NewMultiArray*   x) = 0;
 183   virtual void do_CheckCast      (CheckCast*       x) = 0;
 184   virtual void do_InstanceOf     (InstanceOf*      x) = 0;
 185   virtual void do_MonitorEnter   (MonitorEnter*    x) = 0;
 186   virtual void do_MonitorExit    (MonitorExit*     x) = 0;
 187   virtual void do_Intrinsic      (Intrinsic*       x) = 0;
 188   virtual void do_BlockBegin     (BlockBegin*      x) = 0;
 189   virtual void do_Goto           (Goto*            x) = 0;
 190   virtual void do_If             (If*              x) = 0;
 191   virtual void do_IfInstanceOf   (IfInstanceOf*    x) = 0;
 192   virtual void do_TableSwitch    (TableSwitch*     x) = 0;
 193   virtual void do_LookupSwitch   (LookupSwitch*    x) = 0;
 194   virtual void do_Return         (Return*          x) = 0;
 195   virtual void do_Throw          (Throw*           x) = 0;
 196   virtual void do_Base           (Base*            x) = 0;
 197   virtual void do_OsrEntry       (OsrEntry*        x) = 0;
 198   virtual void do_ExceptionObject(ExceptionObject* x) = 0;
 199   virtual void do_RoundFP        (RoundFP*         x) = 0;


 486 #endif
 487     return set_next(next);
 488   }
 489 
 490   // when blocks are merged
 491   void fixup_block_pointers() {
 492     Instruction *cur = next()->next(); // next()'s block is set in set_next
 493     while (cur && cur->_block != block()) {
 494       cur->_block = block();
 495       cur = cur->next();
 496     }
 497   }
 498 
 499   Instruction *insert_after(Instruction *i) {
 500     Instruction* n = _next;
 501     set_next(i);
 502     i->set_next(n);
 503     return _next;
 504   }
 505 


 506   Instruction *insert_after_same_bci(Instruction *i) {
 507 #ifndef PRODUCT
 508     i->set_printable_bci(printable_bci());
 509 #endif
 510     return insert_after(i);
 511   }
 512 
 513   void set_subst(Instruction* subst)             {
 514     assert(subst == NULL ||
 515            type()->base() == subst->type()->base() ||
 516            subst->type()->base() == illegalType, "type can't change");
 517     _subst = subst;
 518   }
 519   void set_exception_handlers(XHandlers *xhandlers) { _exception_handlers = xhandlers; }
 520   void set_exception_state(ValueStack* s)        { check_state(s); _exception_state = s; }
 521   void set_state_before(ValueStack* s)           { check_state(s); _state_before = s; }
 522 
 523   // machine-specifics
 524   void set_operand(LIR_Opr operand)              { assert(operand != LIR_OprFact::illegalOpr, "operand must exist"); _operand = operand; }
 525   void clear_operand()                           { _operand = LIR_OprFact::illegalOpr; }


 533   virtual LoadField*        as_LoadField()       { return NULL; }
 534   virtual StoreField*       as_StoreField()      { return NULL; }
 535   virtual AccessArray*      as_AccessArray()     { return NULL; }
 536   virtual ArrayLength*      as_ArrayLength()     { return NULL; }
 537   virtual AccessIndexed*    as_AccessIndexed()   { return NULL; }
 538   virtual LoadIndexed*      as_LoadIndexed()     { return NULL; }
 539   virtual StoreIndexed*     as_StoreIndexed()    { return NULL; }
 540   virtual NegateOp*         as_NegateOp()        { return NULL; }
 541   virtual Op2*              as_Op2()             { return NULL; }
 542   virtual ArithmeticOp*     as_ArithmeticOp()    { return NULL; }
 543   virtual ShiftOp*          as_ShiftOp()         { return NULL; }
 544   virtual LogicOp*          as_LogicOp()         { return NULL; }
 545   virtual CompareOp*        as_CompareOp()       { return NULL; }
 546   virtual IfOp*             as_IfOp()            { return NULL; }
 547   virtual Convert*          as_Convert()         { return NULL; }
 548   virtual NullCheck*        as_NullCheck()       { return NULL; }
 549   virtual OsrEntry*         as_OsrEntry()        { return NULL; }
 550   virtual StateSplit*       as_StateSplit()      { return NULL; }
 551   virtual Invoke*           as_Invoke()          { return NULL; }
 552   virtual NewInstance*      as_NewInstance()     { return NULL; }

 553   virtual NewArray*         as_NewArray()        { return NULL; }
 554   virtual NewTypeArray*     as_NewTypeArray()    { return NULL; }
 555   virtual NewObjectArray*   as_NewObjectArray()  { return NULL; }
 556   virtual NewMultiArray*    as_NewMultiArray()   { return NULL; }
 557   virtual TypeCheck*        as_TypeCheck()       { return NULL; }
 558   virtual CheckCast*        as_CheckCast()       { return NULL; }
 559   virtual InstanceOf*       as_InstanceOf()      { return NULL; }
 560   virtual TypeCast*         as_TypeCast()        { return NULL; }
 561   virtual AccessMonitor*    as_AccessMonitor()   { return NULL; }
 562   virtual MonitorEnter*     as_MonitorEnter()    { return NULL; }
 563   virtual MonitorExit*      as_MonitorExit()     { return NULL; }
 564   virtual Intrinsic*        as_Intrinsic()       { return NULL; }
 565   virtual BlockBegin*       as_BlockBegin()      { return NULL; }
 566   virtual BlockEnd*         as_BlockEnd()        { return NULL; }
 567   virtual Goto*             as_Goto()            { return NULL; }
 568   virtual If*               as_If()              { return NULL; }
 569   virtual IfInstanceOf*     as_IfInstanceOf()    { return NULL; }
 570   virtual TableSwitch*      as_TableSwitch()     { return NULL; }
 571   virtual LookupSwitch*     as_LookupSwitch()    { return NULL; }
 572   virtual Return*           as_Return()          { return NULL; }


 930   }
 931 
 932   // accessors
 933   Value index() const                            { return _index; }
 934   Value length() const                           { return _length; }
 935   BasicType elt_type() const                     { return _elt_type; }
 936   bool mismatched() const                        { return _mismatched; }
 937 
 938   void clear_length()                            { _length = NULL; }
 939   // perform elimination of range checks involving constants
 940   bool compute_needs_range_check();
 941 
 942   // generic
 943   virtual void input_values_do(ValueVisitor* f)   { AccessArray::input_values_do(f); f->visit(&_index); if (_length != NULL) f->visit(&_length); }
 944 };
 945 
 946 
 947 LEAF(LoadIndexed, AccessIndexed)
 948  private:
 949   NullCheck*  _explicit_null_check;              // For explicit null check elimination

 950 
 951  public:
 952   // creation
 953   LoadIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* state_before, bool mismatched = false)
 954   : AccessIndexed(array, index, length, elt_type, state_before, mismatched)
 955   , _explicit_null_check(NULL) {}
 956 
 957   // accessors
 958   NullCheck* explicit_null_check() const         { return _explicit_null_check; }
 959 
 960   // setters
 961   // See LoadField::set_explicit_null_check for documentation
 962   void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
 963 
 964   ciType* exact_type() const;
 965   ciType* declared_type() const;
 966 



 967   // generic
 968   HASHING2(LoadIndexed, true, array()->subst(), index()->subst())
 969 };
 970 
 971 
 972 LEAF(StoreIndexed, AccessIndexed)
 973  private:
 974   Value       _value;
 975 
 976   ciMethod* _profiled_method;
 977   int       _profiled_bci;
 978   bool      _check_boolean;
 979 
 980  public:
 981   // creation
 982   StoreIndexed(Value array, Value index, Value length, BasicType elt_type, Value value, ValueStack* state_before,
 983                bool check_boolean, bool mismatched = false)
 984   : AccessIndexed(array, index, length, elt_type, state_before, mismatched)
 985   , _value(value), _profiled_method(NULL), _profiled_bci(0), _check_boolean(check_boolean)
 986   {


1298 
1299  public:
1300   // creation
1301   NewInstance(ciInstanceKlass* klass, ValueStack* state_before, bool is_unresolved)
1302   : StateSplit(instanceType, state_before)
1303   , _klass(klass), _is_unresolved(is_unresolved)
1304   {}
1305 
1306   // accessors
1307   ciInstanceKlass* klass() const                 { return _klass; }
1308   bool is_unresolved() const                     { return _is_unresolved; }
1309 
1310   virtual bool needs_exception_state() const     { return false; }
1311 
1312   // generic
1313   virtual bool can_trap() const                  { return true; }
1314   ciType* exact_type() const;
1315   ciType* declared_type() const;
1316 };
1317 




































1318 
1319 BASE(NewArray, StateSplit)
1320  private:
1321   Value       _length;
1322 
1323  public:
1324   // creation
1325   NewArray(Value length, ValueStack* state_before)
1326   : StateSplit(objectType, state_before)
1327   , _length(length)
1328   {
1329     // Do not ASSERT_VALUES since length is NULL for NewMultiArray
1330   }
1331 
1332   // accessors
1333   Value length() const                           { return _length; }
1334 
1335   virtual bool needs_exception_state() const     { return false; }
1336 
1337   ciType* exact_type() const                     { return NULL; }




  55 class   AccessArray;
  56 class     ArrayLength;
  57 class     AccessIndexed;
  58 class       LoadIndexed;
  59 class       StoreIndexed;
  60 class   NegateOp;
  61 class   Op2;
  62 class     ArithmeticOp;
  63 class     ShiftOp;
  64 class     LogicOp;
  65 class     CompareOp;
  66 class     IfOp;
  67 class   Convert;
  68 class   NullCheck;
  69 class   TypeCast;
  70 class   OsrEntry;
  71 class   ExceptionObject;
  72 class   StateSplit;
  73 class     Invoke;
  74 class     NewInstance;
  75 class     NewValueTypeInstance;
  76 class     NewArray;
  77 class       NewTypeArray;
  78 class       NewObjectArray;
  79 class       NewMultiArray;
  80 class     TypeCheck;
  81 class       CheckCast;
  82 class       InstanceOf;
  83 class     AccessMonitor;
  84 class       MonitorEnter;
  85 class       MonitorExit;
  86 class     Intrinsic;
  87 class     BlockBegin;
  88 class     BlockEnd;
  89 class       Goto;
  90 class       If;
  91 class       IfInstanceOf;
  92 class       Switch;
  93 class         TableSwitch;
  94 class         LookupSwitch;
  95 class       Return;


 161  public:
 162   virtual void do_Phi            (Phi*             x) = 0;
 163   virtual void do_Local          (Local*           x) = 0;
 164   virtual void do_Constant       (Constant*        x) = 0;
 165   virtual void do_LoadField      (LoadField*       x) = 0;
 166   virtual void do_StoreField     (StoreField*      x) = 0;
 167   virtual void do_ArrayLength    (ArrayLength*     x) = 0;
 168   virtual void do_LoadIndexed    (LoadIndexed*     x) = 0;
 169   virtual void do_StoreIndexed   (StoreIndexed*    x) = 0;
 170   virtual void do_NegateOp       (NegateOp*        x) = 0;
 171   virtual void do_ArithmeticOp   (ArithmeticOp*    x) = 0;
 172   virtual void do_ShiftOp        (ShiftOp*         x) = 0;
 173   virtual void do_LogicOp        (LogicOp*         x) = 0;
 174   virtual void do_CompareOp      (CompareOp*       x) = 0;
 175   virtual void do_IfOp           (IfOp*            x) = 0;
 176   virtual void do_Convert        (Convert*         x) = 0;
 177   virtual void do_NullCheck      (NullCheck*       x) = 0;
 178   virtual void do_TypeCast       (TypeCast*        x) = 0;
 179   virtual void do_Invoke         (Invoke*          x) = 0;
 180   virtual void do_NewInstance    (NewInstance*     x) = 0;
 181   virtual void do_NewValueTypeInstance(NewValueTypeInstance* x) = 0;
 182   virtual void do_NewTypeArray   (NewTypeArray*    x) = 0;
 183   virtual void do_NewObjectArray (NewObjectArray*  x) = 0;
 184   virtual void do_NewMultiArray  (NewMultiArray*   x) = 0;
 185   virtual void do_CheckCast      (CheckCast*       x) = 0;
 186   virtual void do_InstanceOf     (InstanceOf*      x) = 0;
 187   virtual void do_MonitorEnter   (MonitorEnter*    x) = 0;
 188   virtual void do_MonitorExit    (MonitorExit*     x) = 0;
 189   virtual void do_Intrinsic      (Intrinsic*       x) = 0;
 190   virtual void do_BlockBegin     (BlockBegin*      x) = 0;
 191   virtual void do_Goto           (Goto*            x) = 0;
 192   virtual void do_If             (If*              x) = 0;
 193   virtual void do_IfInstanceOf   (IfInstanceOf*    x) = 0;
 194   virtual void do_TableSwitch    (TableSwitch*     x) = 0;
 195   virtual void do_LookupSwitch   (LookupSwitch*    x) = 0;
 196   virtual void do_Return         (Return*          x) = 0;
 197   virtual void do_Throw          (Throw*           x) = 0;
 198   virtual void do_Base           (Base*            x) = 0;
 199   virtual void do_OsrEntry       (OsrEntry*        x) = 0;
 200   virtual void do_ExceptionObject(ExceptionObject* x) = 0;
 201   virtual void do_RoundFP        (RoundFP*         x) = 0;


 488 #endif
 489     return set_next(next);
 490   }
 491 
 492   // when blocks are merged
 493   void fixup_block_pointers() {
 494     Instruction *cur = next()->next(); // next()'s block is set in set_next
 495     while (cur && cur->_block != block()) {
 496       cur->_block = block();
 497       cur = cur->next();
 498     }
 499   }
 500 
 501   Instruction *insert_after(Instruction *i) {
 502     Instruction* n = _next;
 503     set_next(i);
 504     i->set_next(n);
 505     return _next;
 506   }
 507 
 508   bool is_flattened_array() const;
 509 
 510   Instruction *insert_after_same_bci(Instruction *i) {
 511 #ifndef PRODUCT
 512     i->set_printable_bci(printable_bci());
 513 #endif
 514     return insert_after(i);
 515   }
 516 
 517   void set_subst(Instruction* subst)             {
 518     assert(subst == NULL ||
 519            type()->base() == subst->type()->base() ||
 520            subst->type()->base() == illegalType, "type can't change");
 521     _subst = subst;
 522   }
 523   void set_exception_handlers(XHandlers *xhandlers) { _exception_handlers = xhandlers; }
 524   void set_exception_state(ValueStack* s)        { check_state(s); _exception_state = s; }
 525   void set_state_before(ValueStack* s)           { check_state(s); _state_before = s; }
 526 
 527   // machine-specifics
 528   void set_operand(LIR_Opr operand)              { assert(operand != LIR_OprFact::illegalOpr, "operand must exist"); _operand = operand; }
 529   void clear_operand()                           { _operand = LIR_OprFact::illegalOpr; }


 537   virtual LoadField*        as_LoadField()       { return NULL; }
 538   virtual StoreField*       as_StoreField()      { return NULL; }
 539   virtual AccessArray*      as_AccessArray()     { return NULL; }
 540   virtual ArrayLength*      as_ArrayLength()     { return NULL; }
 541   virtual AccessIndexed*    as_AccessIndexed()   { return NULL; }
 542   virtual LoadIndexed*      as_LoadIndexed()     { return NULL; }
 543   virtual StoreIndexed*     as_StoreIndexed()    { return NULL; }
 544   virtual NegateOp*         as_NegateOp()        { return NULL; }
 545   virtual Op2*              as_Op2()             { return NULL; }
 546   virtual ArithmeticOp*     as_ArithmeticOp()    { return NULL; }
 547   virtual ShiftOp*          as_ShiftOp()         { return NULL; }
 548   virtual LogicOp*          as_LogicOp()         { return NULL; }
 549   virtual CompareOp*        as_CompareOp()       { return NULL; }
 550   virtual IfOp*             as_IfOp()            { return NULL; }
 551   virtual Convert*          as_Convert()         { return NULL; }
 552   virtual NullCheck*        as_NullCheck()       { return NULL; }
 553   virtual OsrEntry*         as_OsrEntry()        { return NULL; }
 554   virtual StateSplit*       as_StateSplit()      { return NULL; }
 555   virtual Invoke*           as_Invoke()          { return NULL; }
 556   virtual NewInstance*      as_NewInstance()     { return NULL; }
 557   virtual NewValueTypeInstance* as_NewValueTypeInstance() { return NULL; }
 558   virtual NewArray*         as_NewArray()        { return NULL; }
 559   virtual NewTypeArray*     as_NewTypeArray()    { return NULL; }
 560   virtual NewObjectArray*   as_NewObjectArray()  { return NULL; }
 561   virtual NewMultiArray*    as_NewMultiArray()   { return NULL; }
 562   virtual TypeCheck*        as_TypeCheck()       { return NULL; }
 563   virtual CheckCast*        as_CheckCast()       { return NULL; }
 564   virtual InstanceOf*       as_InstanceOf()      { return NULL; }
 565   virtual TypeCast*         as_TypeCast()        { return NULL; }
 566   virtual AccessMonitor*    as_AccessMonitor()   { return NULL; }
 567   virtual MonitorEnter*     as_MonitorEnter()    { return NULL; }
 568   virtual MonitorExit*      as_MonitorExit()     { return NULL; }
 569   virtual Intrinsic*        as_Intrinsic()       { return NULL; }
 570   virtual BlockBegin*       as_BlockBegin()      { return NULL; }
 571   virtual BlockEnd*         as_BlockEnd()        { return NULL; }
 572   virtual Goto*             as_Goto()            { return NULL; }
 573   virtual If*               as_If()              { return NULL; }
 574   virtual IfInstanceOf*     as_IfInstanceOf()    { return NULL; }
 575   virtual TableSwitch*      as_TableSwitch()     { return NULL; }
 576   virtual LookupSwitch*     as_LookupSwitch()    { return NULL; }
 577   virtual Return*           as_Return()          { return NULL; }


 935   }
 936 
 937   // accessors
 938   Value index() const                            { return _index; }
 939   Value length() const                           { return _length; }
 940   BasicType elt_type() const                     { return _elt_type; }
 941   bool mismatched() const                        { return _mismatched; }
 942 
 943   void clear_length()                            { _length = NULL; }
 944   // perform elimination of range checks involving constants
 945   bool compute_needs_range_check();
 946 
 947   // generic
 948   virtual void input_values_do(ValueVisitor* f)   { AccessArray::input_values_do(f); f->visit(&_index); if (_length != NULL) f->visit(&_length); }
 949 };
 950 
 951 
 952 LEAF(LoadIndexed, AccessIndexed)
 953  private:
 954   NullCheck*  _explicit_null_check;              // For explicit null check elimination
 955   NewValueTypeInstance* _vt;
 956 
 957  public:
 958   // creation
 959   LoadIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* state_before, bool mismatched = false)
 960   : AccessIndexed(array, index, length, elt_type, state_before, mismatched)
 961   , _explicit_null_check(NULL) {}
 962 
 963   // accessors
 964   NullCheck* explicit_null_check() const         { return _explicit_null_check; }
 965 
 966   // setters
 967   // See LoadField::set_explicit_null_check for documentation
 968   void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
 969 
 970   ciType* exact_type() const;
 971   ciType* declared_type() const;
 972 
 973   NewValueTypeInstance* vt() { return _vt; }
 974   void set_vt(NewValueTypeInstance* vt) { _vt = vt; }
 975 
 976   // generic
 977   HASHING2(LoadIndexed, true, array()->subst(), index()->subst())
 978 };
 979 
 980 
 981 LEAF(StoreIndexed, AccessIndexed)
 982  private:
 983   Value       _value;
 984 
 985   ciMethod* _profiled_method;
 986   int       _profiled_bci;
 987   bool      _check_boolean;
 988 
 989  public:
 990   // creation
 991   StoreIndexed(Value array, Value index, Value length, BasicType elt_type, Value value, ValueStack* state_before,
 992                bool check_boolean, bool mismatched = false)
 993   : AccessIndexed(array, index, length, elt_type, state_before, mismatched)
 994   , _value(value), _profiled_method(NULL), _profiled_bci(0), _check_boolean(check_boolean)
 995   {


1307 
1308  public:
1309   // creation
1310   NewInstance(ciInstanceKlass* klass, ValueStack* state_before, bool is_unresolved)
1311   : StateSplit(instanceType, state_before)
1312   , _klass(klass), _is_unresolved(is_unresolved)
1313   {}
1314 
1315   // accessors
1316   ciInstanceKlass* klass() const                 { return _klass; }
1317   bool is_unresolved() const                     { return _is_unresolved; }
1318 
1319   virtual bool needs_exception_state() const     { return false; }
1320 
1321   // generic
1322   virtual bool can_trap() const                  { return true; }
1323   ciType* exact_type() const;
1324   ciType* declared_type() const;
1325 };
1326 
1327 LEAF(NewValueTypeInstance, StateSplit)
1328   bool _is_unresolved;
1329   ciValueKlass* _klass;
1330   Value _depends_on;      // Link to instance on with withfield was called on
1331 
1332 public:
1333 
1334   // Default creation, always allocated for now
1335   NewValueTypeInstance(ciValueKlass* klass, ValueStack* state_before, bool is_unresolved, Value depends_on = NULL)
1336   : StateSplit(instanceType, state_before)
1337    , _is_unresolved(is_unresolved)
1338    , _klass(klass)
1339   {
1340     if (depends_on == NULL) {
1341       _depends_on = this;
1342     } else {
1343       _depends_on = depends_on;
1344     }
1345   }
1346 
1347   // accessors
1348   bool is_unresolved() const                     { return _is_unresolved; }
1349   Value depends_on();
1350 
1351   ciValueKlass* klass() const { return _klass; }
1352 
1353   virtual bool needs_exception_state() const     { return false; }
1354 
1355   // generic
1356   virtual bool can_trap() const                  { return true; }
1357   ciType* exact_type() const;
1358   ciType* declared_type() const;
1359 
1360   // Only done in LIR Generator -> map everything to object
1361   void set_to_object_type() { set_type(instanceType); }
1362 };
1363 
1364 BASE(NewArray, StateSplit)
1365  private:
1366   Value       _length;
1367 
1368  public:
1369   // creation
1370   NewArray(Value length, ValueStack* state_before)
1371   : StateSplit(objectType, state_before)
1372   , _length(length)
1373   {
1374     // Do not ASSERT_VALUES since length is NULL for NewMultiArray
1375   }
1376 
1377   // accessors
1378   Value length() const                           { return _length; }
1379 
1380   virtual bool needs_exception_state() const     { return false; }
1381 
1382   ciType* exact_type() const                     { return NULL; }


< prev index next >