hotspot/src/share/vm/opto/idealKit.hpp
changeset 9124 f60dee480d49
parent 8921 14bfe81f2a9d
parent 9100 860ba6f8b53f
child 13895 f6dfe4123709
equal deleted inserted replaced
9093:62b8e328f8c8 9124:f60dee480d49
   106   Node* _cvstate;                          // current cvstate (control, memory and variables)
   106   Node* _cvstate;                          // current cvstate (control, memory and variables)
   107   uint _var_ct;                            // number of variables
   107   uint _var_ct;                            // number of variables
   108   bool _delay_all_transforms;              // flag forcing all transforms to be delayed
   108   bool _delay_all_transforms;              // flag forcing all transforms to be delayed
   109   Node* _initial_ctrl;                     // saves initial control until variables declared
   109   Node* _initial_ctrl;                     // saves initial control until variables declared
   110   Node* _initial_memory;                   // saves initial memory  until variables declared
   110   Node* _initial_memory;                   // saves initial memory  until variables declared
       
   111   Node* _initial_i_o;                      // saves initial i_o  until variables declared
   111 
   112 
   112   PhaseGVN& gvn() const { return _gvn; }
   113   PhaseGVN& gvn() const { return _gvn; }
   113   // Create a new cvstate filled with nulls
   114   // Create a new cvstate filled with nulls
   114   Node* new_cvstate();                     // Create a new cvstate
   115   Node* new_cvstate();                     // Create a new cvstate
   115   Node* cvstate() { return _cvstate; }     // current cvstate
   116   Node* cvstate() { return _cvstate; }     // current cvstate
   140 
   141 
   141   // Users should not care about slices only MergedMem so no access for them.
   142   // Users should not care about slices only MergedMem so no access for them.
   142   Node* memory(uint alias_idx);
   143   Node* memory(uint alias_idx);
   143 
   144 
   144  public:
   145  public:
   145   IdealKit(PhaseGVN &gvn, Node* control, Node* memory, bool delay_all_transforms = false, bool has_declarations = false);
   146   IdealKit(GraphKit* gkit, bool delay_all_transforms = false, bool has_declarations = false);
   146   ~IdealKit() {
   147   ~IdealKit() {
   147     stop();
   148     stop();
   148     drain_delay_transform();
   149     drain_delay_transform();
   149   }
   150   }
       
   151   void sync_kit(GraphKit* gkit);
       
   152 
   150   // Control
   153   // Control
   151   Node* ctrl()                          { return _cvstate->in(TypeFunc::Control); }
   154   Node* ctrl()                          { return _cvstate->in(TypeFunc::Control); }
   152   void set_ctrl(Node* ctrl)             { _cvstate->set_req(TypeFunc::Control, ctrl); }
   155   void set_ctrl(Node* ctrl)             { _cvstate->set_req(TypeFunc::Control, ctrl); }
   153   Node* top()                           { return C->top(); }
   156   Node* top()                           { return C->top(); }
   154   MergeMemNode* merged_memory()         { return _cvstate->in(TypeFunc::Memory)->as_MergeMem(); }
   157   MergeMemNode* merged_memory()         { return _cvstate->in(TypeFunc::Memory)->as_MergeMem(); }
   155   void set_all_memory(Node* mem)        { _cvstate->set_req(TypeFunc::Memory, mem); }
   158   void set_all_memory(Node* mem)        { _cvstate->set_req(TypeFunc::Memory, mem); }
       
   159   Node* i_o()                           { return _cvstate->in(TypeFunc::I_O); }
       
   160   void set_i_o(Node* c)                 { _cvstate->set_req(TypeFunc::I_O, c); }
   156   void set(IdealVariable& v, Node* rhs) { _cvstate->set_req(first_var + v.id(), rhs); }
   161   void set(IdealVariable& v, Node* rhs) { _cvstate->set_req(first_var + v.id(), rhs); }
   157   Node* value(IdealVariable& v)         { return _cvstate->in(first_var + v.id()); }
   162   Node* value(IdealVariable& v)         { return _cvstate->in(first_var + v.id()); }
   158   void dead(IdealVariable& v)           { set(v, (Node*)NULL); }
   163   void dead(IdealVariable& v)           { set(v, (Node*)NULL); }
   159   void if_then(Node* left, BoolTest::mask relop, Node* right,
   164   void if_then(Node* left, BoolTest::mask relop, Node* right,
   160                float prob = PROB_FAIR, float cnt = COUNT_UNKNOWN,
   165                float prob = PROB_FAIR, float cnt = COUNT_UNKNOWN,
   237   void make_leaf_call(const TypeFunc *slow_call_type,
   242   void make_leaf_call(const TypeFunc *slow_call_type,
   238                       address slow_call,
   243                       address slow_call,
   239                       const char *leaf_name,
   244                       const char *leaf_name,
   240                       Node* parm0,
   245                       Node* parm0,
   241                       Node* parm1 = NULL,
   246                       Node* parm1 = NULL,
   242                       Node* parm2 = NULL);
   247                       Node* parm2 = NULL,
       
   248                       Node* parm3 = NULL);
       
   249 
       
   250   void make_leaf_call_no_fp(const TypeFunc *slow_call_type,
       
   251                             address slow_call,
       
   252                             const char *leaf_name,
       
   253                             const TypePtr* adr_type,
       
   254                             Node* parm0,
       
   255                             Node* parm1,
       
   256                             Node* parm2,
       
   257                             Node* parm3);
       
   258 
   243 };
   259 };
   244 
   260 
   245 #endif // SHARE_VM_OPTO_IDEALKIT_HPP
   261 #endif // SHARE_VM_OPTO_IDEALKIT_HPP