src/hotspot/share/c1/c1_Instruction.hpp

*** 462,471 ****
--- 462,472 ----
    bool has_uses() const                          { return use_count() > 0; }
    ValueStack* state_before() const               { return _state_before; }
    ValueStack* exception_state() const            { return _exception_state; }
    virtual bool needs_exception_state() const     { return true; }
    XHandlers* exception_handlers() const          { return _exception_handlers; }
+   ciKlass* as_loaded_klass_or_null() const;
  
    // manipulation
    void pin(PinReason reason)                     { _pin_state |= reason; }
    void pin()                                     { _pin_state |= PinUnknown; }
    // DANGEROUS: only used by EliminateStores
*** 1143,1171 ****
  
  LEAF(IfOp, Op2)
   private:
    Value _tval;
    Value _fval;
  
   public:
    // creation
!   IfOp(Value x, Condition cond, Value y, Value tval, Value fval)
    : Op2(tval->type()->meet(fval->type()), (Bytecodes::Code)cond, x, y)
    , _tval(tval)
    , _fval(fval)
    {
      ASSERT_VALUES
      assert(tval->type()->tag() == fval->type()->tag(), "types must match");
    }
  
    // accessors
    virtual bool is_commutative() const;
    Bytecodes::Code op() const                     { ShouldNotCallThis(); return Bytecodes::_illegal; }
    Condition cond() const                         { return (Condition)Op2::op(); }
    Value tval() const                             { return _tval; }
    Value fval() const                             { return _fval; }
! 
    // generic
    virtual void input_values_do(ValueVisitor* f)   { Op2::input_values_do(f); f->visit(&_tval); f->visit(&_fval); }
  };
  
  
--- 1144,1175 ----
  
  LEAF(IfOp, Op2)
   private:
    Value _tval;
    Value _fval;
+   bool _substituability_check;
  
   public:
    // creation
!   IfOp(Value x, Condition cond, Value y, Value tval, Value fval, ValueStack* state_before, bool substituability_check)
    : Op2(tval->type()->meet(fval->type()), (Bytecodes::Code)cond, x, y)
    , _tval(tval)
    , _fval(fval)
+   , _substituability_check(substituability_check)
    {
      ASSERT_VALUES
      assert(tval->type()->tag() == fval->type()->tag(), "types must match");
+     set_state_before(state_before);
    }
  
    // accessors
    virtual bool is_commutative() const;
    Bytecodes::Code op() const                     { ShouldNotCallThis(); return Bytecodes::_illegal; }
    Condition cond() const                         { return (Condition)Op2::op(); }
    Value tval() const                             { return _tval; }
    Value fval() const                             { return _fval; }
!   bool substituability_check() const             { return _substituability_check; }
    // generic
    virtual void input_values_do(ValueVisitor* f)   { Op2::input_values_do(f); f->visit(&_tval); f->visit(&_fval); }
  };
  
  
*** 2052,2072 ****
    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);
--- 2056,2078 ----
    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?
+   bool        _substituability_check;
   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, bool substituability_check=false)
      : BlockEnd(illegalType, state_before, is_safepoint)
    , _x(x)
    , _cond(cond)
    , _y(y)
    , _profiled_method(NULL)
    , _profiled_bci(0)
    , _swapped(false)
+   , _substituability_check(substituability_check)
    {
      ASSERT_VALUES
      set_flag(UnorderedIsTrueFlag, unordered_is_true);
      assert(x->type()->tag() == y->type()->tag(), "types must match");
      BlockList* s = new BlockList(2);
*** 2105,2114 ****
--- 2111,2121 ----
  
    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;         }
+   bool substituability_check() const              { return _substituability_check; }
    // generic
    virtual void input_values_do(ValueVisitor* f)   { BlockEnd::input_values_do(f); f->visit(&_x); f->visit(&_y); }
  };