< prev index next >

src/hotspot/share/c1/c1_LIRGenerator.hpp

BarrierSetC1_v3

BarrierSetC1_v2

7  *                                                                                                                                   
8  * This code is distributed in the hope that it will be useful, but WITHOUT                                                          
9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or                                                             
10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License                                                             
11  * version 2 for more details (a copy is included in the LICENSE file that                                                           
12  * accompanied this code).                                                                                                           
13  *                                                                                                                                   
14  * You should have received a copy of the GNU General Public License version                                                         
15  * 2 along with this work; if not, write to the Free Software Foundation,                                                            
16  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.                                                                     
17  *                                                                                                                                   
18  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA                                                           
19  * or visit www.oracle.com if you need additional information or have any                                                            
20  * questions.                                                                                                                        
21  *                                                                                                                                   
22  */                                                                                                                                  
23 
24 #ifndef SHARE_VM_C1_C1_LIRGENERATOR_HPP                                                                                              
25 #define SHARE_VM_C1_C1_LIRGENERATOR_HPP                                                                                              
26 
27 #include "gc/shared/c1/barrierSetC1.hpp"                                                                                             
28 #include "c1/c1_Decorators.hpp"                                                                                                      
29 #include "c1/c1_Instruction.hpp"                                                                                                     
30 #include "c1/c1_LIR.hpp"                                                                                                             
31 #include "ci/ciMethodData.hpp"                                                                                                       
                                                                                                                                     
32 #include "utilities/macros.hpp"                                                                                                      
33 #include "utilities/sizes.hpp"                                                                                                       
34 
                                                                                                                                     
                                                                                                                                     
35 // The classes responsible for code emission and register allocation                                                                 
36 
37 
38 class LIRGenerator;                                                                                                                  
39 class LIREmitter;                                                                                                                    
40 class Invoke;                                                                                                                        
41 class SwitchRange;                                                                                                                   
42 class LIRItem;                                                                                                                       
43 
44 typedef GrowableArray<LIRItem*> LIRItemList;                                                                                         
45 
46 class SwitchRange: public CompilationResourceObj {                                                                                   
47  private:                                                                                                                            
48   int _low_key;                                                                                                                      
49   int _high_key;                                                                                                                     
50   BlockBegin* _sux;                                                                                                                  
51  public:                                                                                                                             
52   SwitchRange(int start_key, BlockBegin* sux): _low_key(start_key), _high_key(start_key), _sux(sux) {}                               
53   void set_high_key(int key) { _high_key = key; }                                                                                    

7  *
8  * This code is distributed in the hope that it will be useful, but WITHOUT
9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
11  * version 2 for more details (a copy is included in the LICENSE file that
12  * accompanied this code).
13  *
14  * You should have received a copy of the GNU General Public License version
15  * 2 along with this work; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
17  *
18  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
19  * or visit www.oracle.com if you need additional information or have any
20  * questions.
21  *
22  */
23 
24 #ifndef SHARE_VM_C1_C1_LIRGENERATOR_HPP
25 #define SHARE_VM_C1_C1_LIRGENERATOR_HPP
26 

27 #include "c1/c1_Decorators.hpp"
28 #include "c1/c1_Instruction.hpp"
29 #include "c1/c1_LIR.hpp"
30 #include "ci/ciMethodData.hpp"
31 #include "gc/shared/barrierSet.hpp"
32 #include "utilities/macros.hpp"
33 #include "utilities/sizes.hpp"
34 
35 class BarrierSetC1;
36 
37 // The classes responsible for code emission and register allocation
38 
39 
40 class LIRGenerator;
41 class LIREmitter;
42 class Invoke;
43 class SwitchRange;
44 class LIRItem;
45 
46 typedef GrowableArray<LIRItem*> LIRItemList;
47 
48 class SwitchRange: public CompilationResourceObj {
49  private:
50   int _low_key;
51   int _high_key;
52   BlockBegin* _sux;
53  public:
54   SwitchRange(int start_key, BlockBegin* sux): _low_key(start_key), _high_key(start_key), _sux(sux) {}
55   void set_high_key(int key) { _high_key = key; }

134 
135   void emit_move(LIR_Opr src, LIR_Opr dest);                                                                                         
136   void move_to_temp(LIR_Opr src);                                                                                                    
137   void move_temp_to(LIR_Opr dest);                                                                                                   
138   void move(ResolveNode* src, ResolveNode* dest);                                                                                    
139 
140   LIRGenerator* gen() {                                                                                                              
141     return _gen;                                                                                                                     
142   }                                                                                                                                  
143 
144  public:                                                                                                                             
145   PhiResolver(LIRGenerator* _lir_gen, int max_vregs);                                                                                
146   ~PhiResolver();                                                                                                                    
147 
148   void move(LIR_Opr src, LIR_Opr dest);                                                                                              
149 };                                                                                                                                   
150 
151 
152 // only the classes below belong in the same file                                                                                    
153 class LIRGenerator: public InstructionVisitor, public BlockClosure {                                                                 
154   friend class BarrierSetC1;                                                                                                         
155   friend class ModRefBarrierSetC1;                                                                                                   
156   friend class CardTableBarrierSetC1;                                                                                                
157   friend class G1BarrierSetC1;                                                                                                       
158  // LIRGenerator should never get instatiated on the heap.                                                                           
159  private:                                                                                                                            
160   void* operator new(size_t size) throw();                                                                                           
161   void* operator new[](size_t size) throw();                                                                                         
162   void operator delete(void* p) { ShouldNotReachHere(); }                                                                            
163   void operator delete[](void* p) { ShouldNotReachHere(); }                                                                          
164 
165   Compilation*  _compilation;                                                                                                        
166   ciMethod*     _method;    // method that we are compiling                                                                          
167   PhiResolverState  _resolver_state;                                                                                                 
168   BlockBegin*   _block;                                                                                                              
169   int           _virtual_register_number;                                                                                            
170   Values        _instruction_for_operand;                                                                                            
171   BitMap2D      _vreg_flags; // flags which can be set on a per-vreg basis                                                           
172   LIR_List*     _lir;                                                                                                                
173 
174   LIRGenerator* gen() {                                                                                                              
175     return this;                                                                                                                     
176   }                                                                                                                                  
177 
178   void print_if_not_loaded(const NewInstance* new_instance) PRODUCT_RETURN;                                                          
179 
                                                                                                                                     
180 #ifdef ASSERT                                                                                                                        
181   LIR_List* lir(const char * file, int line) const {                                                                                 
182     _lir->set_file_and_line(file, line);                                                                                             
183     return _lir;                                                                                                                     
184   }                                                                                                                                  
185 #endif                                                                                                                               
186   LIR_List* lir() const {                                                                                                            
187     return _lir;                                                                                                                     
188   }                                                                                                                                  
189 
                                                                                                                                     
190   // a simple cache of constants used within a block                                                                                 
191   GrowableArray<LIR_Const*>       _constants;                                                                                        
192   LIR_OprList                     _reg_for_constants;                                                                                
193   Values                          _unpinned_constants;                                                                               
194 
195   friend class PhiResolver;                                                                                                          
196 
                                                                                                                                     
197   // unified bailout support                                                                                                         
198   void bailout(const char* msg) const            { compilation()->bailout(msg); }                                                    
199   bool bailed_out() const                        { return compilation()->bailed_out(); }                                             
200 
201   void block_do_prolog(BlockBegin* block);                                                                                           
202   void block_do_epilog(BlockBegin* block);                                                                                           
203 
204   // register allocation                                                                                                             
205   LIR_Opr rlock(Value instr);                      // lock a free register                                                           
206   LIR_Opr rlock_result(Value instr);                                                                                                 
207   LIR_Opr rlock_result(Value instr, BasicType type);                                                                                 
208   LIR_Opr rlock_byte(BasicType type);                                                                                                
209   LIR_Opr rlock_callee_saved(BasicType type);                                                                                        
210 
211   // get a constant into a register and get track of what register was used                                                          
212   LIR_Opr load_constant(Constant* x);                                                                                                
213   LIR_Opr load_constant(LIR_Const* constant);                                                                                        
214 
215   // Given an immediate value, return an operand usable in logical ops.                                                              

136 
137   void emit_move(LIR_Opr src, LIR_Opr dest);
138   void move_to_temp(LIR_Opr src);
139   void move_temp_to(LIR_Opr dest);
140   void move(ResolveNode* src, ResolveNode* dest);
141 
142   LIRGenerator* gen() {
143     return _gen;
144   }
145 
146  public:
147   PhiResolver(LIRGenerator* _lir_gen, int max_vregs);
148   ~PhiResolver();
149 
150   void move(LIR_Opr src, LIR_Opr dest);
151 };
152 
153 
154 // only the classes below belong in the same file
155 class LIRGenerator: public InstructionVisitor, public BlockClosure {




156  // LIRGenerator should never get instatiated on the heap.
157  private:
158   void* operator new(size_t size) throw();
159   void* operator new[](size_t size) throw();
160   void operator delete(void* p) { ShouldNotReachHere(); }
161   void operator delete[](void* p) { ShouldNotReachHere(); }
162 
163   Compilation*  _compilation;
164   ciMethod*     _method;    // method that we are compiling
165   PhiResolverState  _resolver_state;
166   BlockBegin*   _block;
167   int           _virtual_register_number;
168   Values        _instruction_for_operand;
169   BitMap2D      _vreg_flags; // flags which can be set on a per-vreg basis
170   LIR_List*     _lir;
171 
172   LIRGenerator* gen() {
173     return this;
174   }
175 
176   void print_if_not_loaded(const NewInstance* new_instance) PRODUCT_RETURN;
177 
178  public:
179 #ifdef ASSERT
180   LIR_List* lir(const char * file, int line) const {
181     _lir->set_file_and_line(file, line);
182     return _lir;
183   }
184 #endif
185   LIR_List* lir() const {
186     return _lir;
187   }
188 
189  private:
190   // a simple cache of constants used within a block
191   GrowableArray<LIR_Const*>       _constants;
192   LIR_OprList                     _reg_for_constants;
193   Values                          _unpinned_constants;
194 
195   friend class PhiResolver;
196 
197  public:
198   // unified bailout support
199   void bailout(const char* msg) const            { compilation()->bailout(msg); }
200   bool bailed_out() const                        { return compilation()->bailed_out(); }
201 
202   void block_do_prolog(BlockBegin* block);
203   void block_do_epilog(BlockBegin* block);
204 
205   // register allocation
206   LIR_Opr rlock(Value instr);                      // lock a free register
207   LIR_Opr rlock_result(Value instr);
208   LIR_Opr rlock_result(Value instr, BasicType type);
209   LIR_Opr rlock_byte(BasicType type);
210   LIR_Opr rlock_callee_saved(BasicType type);
211 
212   // get a constant into a register and get track of what register was used
213   LIR_Opr load_constant(Constant* x);
214   LIR_Opr load_constant(LIR_Const* constant);
215 
216   // Given an immediate value, return an operand usable in logical ops.

220     assert(x->operand()->is_illegal(), "operand should never change");                                                               
221     assert(!opr->is_register() || opr->is_virtual(), "should never set result to a physical register");                              
222     x->set_operand(opr);                                                                                                             
223     assert(opr == x->operand(), "must be");                                                                                          
224     if (opr->is_virtual()) {                                                                                                         
225       _instruction_for_operand.at_put_grow(opr->vreg_number(), x, NULL);                                                             
226     }                                                                                                                                
227   }                                                                                                                                  
228   void  set_no_result(Value x)                     { assert(!x->has_uses(), "can't have use"); x->clear_operand(); }                 
229 
230   friend class LIRItem;                                                                                                              
231 
232   LIR_Opr round_item(LIR_Opr opr);                                                                                                   
233   LIR_Opr force_to_spill(LIR_Opr value, BasicType t);                                                                                
234 
235   PhiResolverState& resolver_state() { return _resolver_state; }                                                                     
236 
237   void  move_to_phi(PhiResolver* resolver, Value cur_val, Value sux_val);                                                            
238   void  move_to_phi(ValueStack* cur_state);                                                                                          
239 
240   // code emission                                                                                                                   
241   void do_ArithmeticOp_Long   (ArithmeticOp*    x);                                                                                  
242   void do_ArithmeticOp_Int    (ArithmeticOp*    x);                                                                                  
243   void do_ArithmeticOp_FPU    (ArithmeticOp*    x);                                                                                  
244                                                                                                                                      
245   // platform dependent                                                                                                              
246   LIR_Opr getThreadPointer();                                                                                                        
247 
                                                                                                                                     
                                                                                                                                     
                                                                                                                                     
                                                                                                                                     
                                                                                                                                     
                                                                                                                                     
248   void do_RegisterFinalizer(Intrinsic* x);                                                                                           
249   void do_isInstance(Intrinsic* x);                                                                                                  
250   void do_isPrimitive(Intrinsic* x);                                                                                                 
251   void do_getClass(Intrinsic* x);                                                                                                    
252   void do_currentThread(Intrinsic* x);                                                                                               
253   void do_FmaIntrinsic(Intrinsic* x);                                                                                                
254   void do_MathIntrinsic(Intrinsic* x);                                                                                               
255   void do_LibmIntrinsic(Intrinsic* x);                                                                                               
256   void do_ArrayCopy(Intrinsic* x);                                                                                                   
257   void do_CompareAndSwap(Intrinsic* x, ValueType* type);                                                                             
258   void do_NIOCheckIndex(Intrinsic* x);                                                                                               
259   void do_FPIntrinsics(Intrinsic* x);                                                                                                
260   void do_Reference_get(Intrinsic* x);                                                                                               
261   void do_update_CRC32(Intrinsic* x);                                                                                                
262   void do_update_CRC32C(Intrinsic* x);                                                                                               
263   void do_vectorizedMismatch(Intrinsic* x);                                                                                          
264 
                                                                                                                                     
265   LIR_Opr call_runtime(BasicTypeArray* signature, LIRItemList* args, address entry, ValueType* result_type, CodeEmitInfo* info);     
266   LIR_Opr call_runtime(BasicTypeArray* signature, LIR_OprList* args, address entry, ValueType* result_type, CodeEmitInfo* info);     
267 
268   // convenience functions                                                                                                           
269   LIR_Opr call_runtime(Value arg1, address entry, ValueType* result_type, CodeEmitInfo* info);                                       
270   LIR_Opr call_runtime(Value arg1, Value arg2, address entry, ValueType* result_type, CodeEmitInfo* info);                           
271 
272   // GC Barriers                                                                                                                     
273 
274   // generic interface                                                                                                               
                                                                                                                                     
275 
                                                                                                                                     
276   void access_store_at(DecoratorSet decorators, BasicType type,                                                                      
277                        LIRItem& base, LIR_Opr offset, LIR_Opr value,                                                                 
278                        CodeEmitInfo* patch_info, CodeEmitInfo* store_emit_info);                                                     
279 
280   void access_load_at(DecoratorSet decorators, BasicType type,                                                                       
281                       LIRItem& base, LIR_Opr offset, LIR_Opr result,                                                                 
282                       CodeEmitInfo* patch_info, CodeEmitInfo* load_emit_info);                                                       
283 
284   LIR_Opr access_atomic_cmpxchg_at(DecoratorSet decorators, BasicType type,                                                          
285                                    LIRItem& base, LIRItem& offset, LIRItem& cmp_value, LIRItem& new_value);                          
286 
287   LIR_Opr access_atomic_xchg_at(DecoratorSet decorators, BasicType type,                                                             
288                                 LIRItem& base, LIRItem& offset, LIRItem& value);                                                     
289 
290   LIR_Opr access_atomic_add_at(DecoratorSet decorators, BasicType type,                                                              
291                                LIRItem& base, LIRItem& offset, LIRItem& value);                                                      
292 
293   // These need to guarantee JMM volatile semantics are preserved on each platform                                                   
294   // and requires one implementation per architecture.                                                                               
295   LIR_Opr atomic_cmpxchg(BasicType type, LIR_Opr addr, LIRItem& cmp_value, LIRItem& new_value);                                      
296   LIR_Opr atomic_xchg(BasicType type, LIR_Opr addr, LIRItem& new_value);                                                             
297   LIR_Opr atomic_add(BasicType type, LIR_Opr addr, LIRItem& new_value);                                                              
298 
299   // specific implementations                                                                                                        
300   void array_store_check(LIR_Opr value, LIR_Opr array, CodeEmitInfo* store_check_info, ciMethod* profiled_method, int profiled_bci); 
301 

221     assert(x->operand()->is_illegal(), "operand should never change");
222     assert(!opr->is_register() || opr->is_virtual(), "should never set result to a physical register");
223     x->set_operand(opr);
224     assert(opr == x->operand(), "must be");
225     if (opr->is_virtual()) {
226       _instruction_for_operand.at_put_grow(opr->vreg_number(), x, NULL);
227     }
228   }
229   void  set_no_result(Value x)                     { assert(!x->has_uses(), "can't have use"); x->clear_operand(); }
230 
231   friend class LIRItem;
232 
233   LIR_Opr round_item(LIR_Opr opr);
234   LIR_Opr force_to_spill(LIR_Opr value, BasicType t);
235 
236   PhiResolverState& resolver_state() { return _resolver_state; }
237 
238   void  move_to_phi(PhiResolver* resolver, Value cur_val, Value sux_val);
239   void  move_to_phi(ValueStack* cur_state);
240 





241   // platform dependent
242   LIR_Opr getThreadPointer();
243 
244  private:
245   // code emission
246   void do_ArithmeticOp_Long(ArithmeticOp* x);
247   void do_ArithmeticOp_Int (ArithmeticOp* x);
248   void do_ArithmeticOp_FPU (ArithmeticOp* x);
249 
250   void do_RegisterFinalizer(Intrinsic* x);
251   void do_isInstance(Intrinsic* x);
252   void do_isPrimitive(Intrinsic* x);
253   void do_getClass(Intrinsic* x);
254   void do_currentThread(Intrinsic* x);
255   void do_FmaIntrinsic(Intrinsic* x);
256   void do_MathIntrinsic(Intrinsic* x);
257   void do_LibmIntrinsic(Intrinsic* x);
258   void do_ArrayCopy(Intrinsic* x);
259   void do_CompareAndSwap(Intrinsic* x, ValueType* type);
260   void do_NIOCheckIndex(Intrinsic* x);
261   void do_FPIntrinsics(Intrinsic* x);
262   void do_Reference_get(Intrinsic* x);
263   void do_update_CRC32(Intrinsic* x);
264   void do_update_CRC32C(Intrinsic* x);
265   void do_vectorizedMismatch(Intrinsic* x);
266 
267  public:
268   LIR_Opr call_runtime(BasicTypeArray* signature, LIRItemList* args, address entry, ValueType* result_type, CodeEmitInfo* info);
269   LIR_Opr call_runtime(BasicTypeArray* signature, LIR_OprList* args, address entry, ValueType* result_type, CodeEmitInfo* info);
270 
271   // convenience functions
272   LIR_Opr call_runtime(Value arg1, address entry, ValueType* result_type, CodeEmitInfo* info);
273   LIR_Opr call_runtime(Value arg1, Value arg2, address entry, ValueType* result_type, CodeEmitInfo* info);
274 
275   // Access API
276 
277  private:
278   BarrierSetC1 *_barrier_set;
279 
280  public:
281   void access_store_at(DecoratorSet decorators, BasicType type,
282                        LIRItem& base, LIR_Opr offset, LIR_Opr value,
283                        CodeEmitInfo* patch_info = NULL, CodeEmitInfo* store_emit_info = NULL);
284 
285   void access_load_at(DecoratorSet decorators, BasicType type,
286                       LIRItem& base, LIR_Opr offset, LIR_Opr result,
287                       CodeEmitInfo* patch_info = NULL, CodeEmitInfo* load_emit_info = NULL);
288 
289   LIR_Opr access_atomic_cmpxchg_at(DecoratorSet decorators, BasicType type,
290                                    LIRItem& base, LIRItem& offset, LIRItem& cmp_value, LIRItem& new_value);
291 
292   LIR_Opr access_atomic_xchg_at(DecoratorSet decorators, BasicType type,
293                                 LIRItem& base, LIRItem& offset, LIRItem& value);
294 
295   LIR_Opr access_atomic_add_at(DecoratorSet decorators, BasicType type,
296                                LIRItem& base, LIRItem& offset, LIRItem& value);
297 
298   // These need to guarantee JMM volatile semantics are preserved on each platform
299   // and requires one implementation per architecture.
300   LIR_Opr atomic_cmpxchg(BasicType type, LIR_Opr addr, LIRItem& cmp_value, LIRItem& new_value);
301   LIR_Opr atomic_xchg(BasicType type, LIR_Opr addr, LIRItem& new_value);
302   LIR_Opr atomic_add(BasicType type, LIR_Opr addr, LIRItem& new_value);
303 
304   // specific implementations
305   void array_store_check(LIR_Opr value, LIR_Opr array, CodeEmitInfo* store_check_info, ciMethod* profiled_method, int profiled_bci);
306 

472   BlockBegin*   block() const                    { return _block; }                                                                  
473   IRScope*      scope() const                    { return block()->scope(); }                                                        
474 
475   int max_virtual_register_number() const        { return _virtual_register_number; }                                                
476 
477   void block_do(BlockBegin* block);                                                                                                  
478 
479   // Flags that can be set on vregs                                                                                                  
480   enum VregFlag {                                                                                                                    
481       must_start_in_memory = 0  // needs to be assigned a memory location at beginning, but may then be loaded in a register         
482     , callee_saved     = 1    // must be in a callee saved register                                                                  
483     , byte_reg         = 2    // must be in a byte register                                                                          
484     , num_vreg_flags                                                                                                                 
485 
486   };                                                                                                                                 
487 
488   LIRGenerator(Compilation* compilation, ciMethod* method)                                                                           
489     : _compilation(compilation)                                                                                                      
490     , _method(method)                                                                                                                
491     , _virtual_register_number(LIR_OprDesc::vreg_base)                                                                               
492     , _vreg_flags(num_vreg_flags) {                                                                                                  
                                                                                                                                     
493   }                                                                                                                                  
494 
495   // for virtual registers, maps them back to Phi's or Local's                                                                       
496   Instruction* instruction_for_opr(LIR_Opr opr);                                                                                     
497   Instruction* instruction_for_vreg(int reg_num);                                                                                    
498 
499   void set_vreg_flag   (int vreg_num, VregFlag f);                                                                                   
500   bool is_vreg_flag_set(int vreg_num, VregFlag f);                                                                                   
501   void set_vreg_flag   (LIR_Opr opr,  VregFlag f) { set_vreg_flag(opr->vreg_number(), f); }                                          
502   bool is_vreg_flag_set(LIR_Opr opr,  VregFlag f) { return is_vreg_flag_set(opr->vreg_number(), f); }                                
503 
504   // statics                                                                                                                         
505   static LIR_Opr exceptionOopOpr();                                                                                                  
506   static LIR_Opr exceptionPcOpr();                                                                                                   
507   static LIR_Opr divInOpr();                                                                                                         
508   static LIR_Opr divOutOpr();                                                                                                        
509   static LIR_Opr remOutOpr();                                                                                                        
510 #ifdef S390                                                                                                                          
511   // On S390 we can do ldiv, lrem without RT call.                                                                                   

477   BlockBegin*   block() const                    { return _block; }
478   IRScope*      scope() const                    { return block()->scope(); }
479 
480   int max_virtual_register_number() const        { return _virtual_register_number; }
481 
482   void block_do(BlockBegin* block);
483 
484   // Flags that can be set on vregs
485   enum VregFlag {
486       must_start_in_memory = 0  // needs to be assigned a memory location at beginning, but may then be loaded in a register
487     , callee_saved     = 1    // must be in a callee saved register
488     , byte_reg         = 2    // must be in a byte register
489     , num_vreg_flags
490 
491   };
492 
493   LIRGenerator(Compilation* compilation, ciMethod* method)
494     : _compilation(compilation)
495     , _method(method)
496     , _virtual_register_number(LIR_OprDesc::vreg_base)
497     , _vreg_flags(num_vreg_flags)
498     , _barrier_set(BarrierSet::barrier_set()->barrier_set_c1()) {
499   }
500 
501   // for virtual registers, maps them back to Phi's or Local's
502   Instruction* instruction_for_opr(LIR_Opr opr);
503   Instruction* instruction_for_vreg(int reg_num);
504 
505   void set_vreg_flag   (int vreg_num, VregFlag f);
506   bool is_vreg_flag_set(int vreg_num, VregFlag f);
507   void set_vreg_flag   (LIR_Opr opr,  VregFlag f) { set_vreg_flag(opr->vreg_number(), f); }
508   bool is_vreg_flag_set(LIR_Opr opr,  VregFlag f) { return is_vreg_flag_set(opr->vreg_number(), f); }
509 
510   // statics
511   static LIR_Opr exceptionOopOpr();
512   static LIR_Opr exceptionPcOpr();
513   static LIR_Opr divInOpr();
514   static LIR_Opr divOutOpr();
515   static LIR_Opr remOutOpr();
516 #ifdef S390
517   // On S390 we can do ldiv, lrem without RT call.
< prev index next >