src/share/vm/opto/matcher.hpp
Index Unified diffs Context diffs Sdiffs Wdiffs Patch New Old Previous File Next File 6829187 Sdiff src/share/vm/opto

src/share/vm/opto/matcher.hpp

Print this page
rev 1082 : [mq]: indy.compiler.patch


 100   void    set_new_node(const Node* n, Node *nn) {
 101     assert(!has_new_node(n), "set only once");
 102     _nodes.map(n->_idx, nn);
 103   }
 104 
 105 #ifdef ASSERT
 106   // Make sure only new nodes are reachable from this node
 107   void verify_new_nodes_only(Node* root);
 108 
 109   Node* _mem_node;   // Ideal memory node consumed by mach node
 110 #endif
 111 
 112   // Mach node for ConP #NULL
 113   MachNode* _mach_null;
 114 
 115 public:
 116   int LabelRootDepth;
 117   static const int base2reg[];        // Map Types to machine register types
 118   // Convert ideal machine register to a register mask for spill-loads
 119   static const RegMask *idealreg2regmask[];
 120   RegMask *idealreg2spillmask[_last_machine_leaf];
 121   RegMask *idealreg2debugmask[_last_machine_leaf];

 122   void init_spill_mask( Node *ret );
 123   // Convert machine register number to register mask
 124   static uint mreg2regmask_max;
 125   static RegMask mreg2regmask[];
 126   static RegMask STACK_ONLY_mask;
 127 
 128   MachNode* mach_null() const { return _mach_null; }
 129 
 130   bool    is_shared( Node *n ) { return _shared.test(n->_idx) != 0; }
 131   void   set_shared( Node *n ) {  _shared.set(n->_idx); }
 132   bool   is_visited( Node *n ) { return _visited.test(n->_idx) != 0; }
 133   void  set_visited( Node *n ) { _visited.set(n->_idx); }
 134   bool  is_dontcare( Node *n ) { return _dontcare.test(n->_idx) != 0; }
 135   void set_dontcare( Node *n ) {  _dontcare.set(n->_idx); }
 136 
 137   // Mode bit to tell DFA and expand rules whether we are running after
 138   // (or during) register selection.  Usually, the matcher runs before,
 139   // but it will also get called to generate post-allocation spill code.
 140   // In this situation, it is a deadly error to attempt to allocate more
 141   // temporary registers.


 280   RegMask              _return_addr_mask;
 281   // Return value register.  On Intel it is EAX.  On Sparc i0/o0.
 282   static OptoRegPair   return_value(int ideal_reg, bool is_outgoing);
 283   static OptoRegPair c_return_value(int ideal_reg, bool is_outgoing);
 284   RegMask                     _return_value_mask;
 285   // Inline Cache Register
 286   static OptoReg::Name  inline_cache_reg();
 287   static const RegMask &inline_cache_reg_mask();
 288   static int            inline_cache_reg_encode();
 289 
 290   // Register for DIVI projection of divmodI
 291   static RegMask divI_proj_mask();
 292   // Register for MODI projection of divmodI
 293   static RegMask modI_proj_mask();
 294 
 295   // Register for DIVL projection of divmodL
 296   static RegMask divL_proj_mask();
 297   // Register for MODL projection of divmodL
 298   static RegMask modL_proj_mask();
 299 


 300   // Java-Interpreter calling convention
 301   // (what you use when calling between compiled-Java and Interpreted-Java
 302 
 303   // Number of callee-save + always-save registers
 304   // Ignores frame pointer and "special" registers
 305   static int  number_of_saved_registers();
 306 
 307   // The Method-klass-holder may be passed in the inline_cache_reg
 308   // and then expanded into the inline_cache_reg and a method_oop register
 309 
 310   static OptoReg::Name  interpreter_method_oop_reg();
 311   static const RegMask &interpreter_method_oop_reg_mask();
 312   static int            interpreter_method_oop_reg_encode();
 313 
 314   static OptoReg::Name  compiler_method_oop_reg();
 315   static const RegMask &compiler_method_oop_reg_mask();
 316   static int            compiler_method_oop_reg_encode();
 317 
 318   // Interpreter's Frame Pointer Register
 319   static OptoReg::Name  interpreter_frame_pointer_reg();




 100   void    set_new_node(const Node* n, Node *nn) {
 101     assert(!has_new_node(n), "set only once");
 102     _nodes.map(n->_idx, nn);
 103   }
 104 
 105 #ifdef ASSERT
 106   // Make sure only new nodes are reachable from this node
 107   void verify_new_nodes_only(Node* root);
 108 
 109   Node* _mem_node;   // Ideal memory node consumed by mach node
 110 #endif
 111 
 112   // Mach node for ConP #NULL
 113   MachNode* _mach_null;
 114 
 115 public:
 116   int LabelRootDepth;
 117   static const int base2reg[];        // Map Types to machine register types
 118   // Convert ideal machine register to a register mask for spill-loads
 119   static const RegMask *idealreg2regmask[];
 120   RegMask *idealreg2spillmask  [_last_machine_leaf];
 121   RegMask *idealreg2debugmask  [_last_machine_leaf];
 122   RegMask *idealreg2mhdebugmask[_last_machine_leaf];
 123   void init_spill_mask( Node *ret );
 124   // Convert machine register number to register mask
 125   static uint mreg2regmask_max;
 126   static RegMask mreg2regmask[];
 127   static RegMask STACK_ONLY_mask;
 128 
 129   MachNode* mach_null() const { return _mach_null; }
 130 
 131   bool    is_shared( Node *n ) { return _shared.test(n->_idx) != 0; }
 132   void   set_shared( Node *n ) {  _shared.set(n->_idx); }
 133   bool   is_visited( Node *n ) { return _visited.test(n->_idx) != 0; }
 134   void  set_visited( Node *n ) { _visited.set(n->_idx); }
 135   bool  is_dontcare( Node *n ) { return _dontcare.test(n->_idx) != 0; }
 136   void set_dontcare( Node *n ) {  _dontcare.set(n->_idx); }
 137 
 138   // Mode bit to tell DFA and expand rules whether we are running after
 139   // (or during) register selection.  Usually, the matcher runs before,
 140   // but it will also get called to generate post-allocation spill code.
 141   // In this situation, it is a deadly error to attempt to allocate more
 142   // temporary registers.


 281   RegMask              _return_addr_mask;
 282   // Return value register.  On Intel it is EAX.  On Sparc i0/o0.
 283   static OptoRegPair   return_value(int ideal_reg, bool is_outgoing);
 284   static OptoRegPair c_return_value(int ideal_reg, bool is_outgoing);
 285   RegMask                     _return_value_mask;
 286   // Inline Cache Register
 287   static OptoReg::Name  inline_cache_reg();
 288   static const RegMask &inline_cache_reg_mask();
 289   static int            inline_cache_reg_encode();
 290 
 291   // Register for DIVI projection of divmodI
 292   static RegMask divI_proj_mask();
 293   // Register for MODI projection of divmodI
 294   static RegMask modI_proj_mask();
 295 
 296   // Register for DIVL projection of divmodL
 297   static RegMask divL_proj_mask();
 298   // Register for MODL projection of divmodL
 299   static RegMask modL_proj_mask();
 300 
 301   static const RegMask method_handle_invoke_SP_save_mask();
 302 
 303   // Java-Interpreter calling convention
 304   // (what you use when calling between compiled-Java and Interpreted-Java
 305 
 306   // Number of callee-save + always-save registers
 307   // Ignores frame pointer and "special" registers
 308   static int  number_of_saved_registers();
 309 
 310   // The Method-klass-holder may be passed in the inline_cache_reg
 311   // and then expanded into the inline_cache_reg and a method_oop register
 312 
 313   static OptoReg::Name  interpreter_method_oop_reg();
 314   static const RegMask &interpreter_method_oop_reg_mask();
 315   static int            interpreter_method_oop_reg_encode();
 316 
 317   static OptoReg::Name  compiler_method_oop_reg();
 318   static const RegMask &compiler_method_oop_reg_mask();
 319   static int            compiler_method_oop_reg_encode();
 320 
 321   // Interpreter's Frame Pointer Register
 322   static OptoReg::Name  interpreter_frame_pointer_reg();


src/share/vm/opto/matcher.hpp
Index Unified diffs Context diffs Sdiffs Wdiffs Patch New Old Previous File Next File