< prev index next >

src/hotspot/share/c1/c1_LIRAssembler.hpp

Print this page

 29 #include "ci/ciMethodData.hpp"
 30 #include "oops/methodData.hpp"
 31 #include "utilities/macros.hpp"
 32 
 33 class Compilation;
 34 class ScopeValue;
 35 class BarrierSet;
 36 
 37 class LIR_Assembler: public CompilationResourceObj {
 38  private:
 39   C1_MacroAssembler* _masm;
 40   CodeStubList*      _slow_case_stubs;
 41   BarrierSet*        _bs;
 42 
 43   Compilation*       _compilation;
 44   FrameMap*          _frame_map;
 45   BlockBegin*        _current_block;
 46 
 47   Instruction*       _pending_non_safepoint;
 48   int                _pending_non_safepoint_offset;

 49 
 50   Label              _unwind_handler_entry;
 51 
 52 #ifdef ASSERT
 53   BlockList          _branch_target_blocks;
 54   void check_no_unbound_labels();
 55 #endif
 56 
 57   FrameMap* frame_map() const { return _frame_map; }
 58 
 59   void set_current_block(BlockBegin* b) { _current_block = b; }
 60   BlockBegin* current_block() const { return _current_block; }
 61 
 62   // non-safepoint debug info management
 63   void flush_debug_info(int before_pc_offset) {
 64     if (_pending_non_safepoint != NULL) {
 65       if (_pending_non_safepoint_offset < before_pc_offset)
 66         record_non_safepoint_debug_info();
 67       _pending_non_safepoint = NULL;
 68     }

240 
241   void rt_call(LIR_Opr result, address dest, const LIR_OprList* args, LIR_Opr tmp, CodeEmitInfo* info);
242 
243   void membar();
244   void membar_acquire();
245   void membar_release();
246   void membar_loadload();
247   void membar_storestore();
248   void membar_loadstore();
249   void membar_storeload();
250   void on_spin_wait();
251   void get_thread(LIR_Opr result);
252 
253   void verify_oop_map(CodeEmitInfo* info);
254 
255   void atomic_op(LIR_Code code, LIR_Opr src, LIR_Opr data, LIR_Opr dest, LIR_Opr tmp);
256 
257 #include CPU_HEADER(c1_LIRAssembler)
258 
259  public:

260 
261   static int call_stub_size() {
262     return _call_stub_size;
263   }
264 
265   static int exception_handler_size() {
266     return _exception_handler_size;
267   }
268 
269   static int deopt_handler_size() {
270     return _deopt_handler_size;
271   }
272 };
273 
274 #endif // SHARE_C1_C1_LIRASSEMBLER_HPP

 29 #include "ci/ciMethodData.hpp"
 30 #include "oops/methodData.hpp"
 31 #include "utilities/macros.hpp"
 32 
 33 class Compilation;
 34 class ScopeValue;
 35 class BarrierSet;
 36 
 37 class LIR_Assembler: public CompilationResourceObj {
 38  private:
 39   C1_MacroAssembler* _masm;
 40   CodeStubList*      _slow_case_stubs;
 41   BarrierSet*        _bs;
 42 
 43   Compilation*       _compilation;
 44   FrameMap*          _frame_map;
 45   BlockBegin*        _current_block;
 46 
 47   Instruction*       _pending_non_safepoint;
 48   int                _pending_non_safepoint_offset;
 49   int                _immediate_oops_patched;
 50 
 51   Label              _unwind_handler_entry;
 52 
 53 #ifdef ASSERT
 54   BlockList          _branch_target_blocks;
 55   void check_no_unbound_labels();
 56 #endif
 57 
 58   FrameMap* frame_map() const { return _frame_map; }
 59 
 60   void set_current_block(BlockBegin* b) { _current_block = b; }
 61   BlockBegin* current_block() const { return _current_block; }
 62 
 63   // non-safepoint debug info management
 64   void flush_debug_info(int before_pc_offset) {
 65     if (_pending_non_safepoint != NULL) {
 66       if (_pending_non_safepoint_offset < before_pc_offset)
 67         record_non_safepoint_debug_info();
 68       _pending_non_safepoint = NULL;
 69     }

241 
242   void rt_call(LIR_Opr result, address dest, const LIR_OprList* args, LIR_Opr tmp, CodeEmitInfo* info);
243 
244   void membar();
245   void membar_acquire();
246   void membar_release();
247   void membar_loadload();
248   void membar_storestore();
249   void membar_loadstore();
250   void membar_storeload();
251   void on_spin_wait();
252   void get_thread(LIR_Opr result);
253 
254   void verify_oop_map(CodeEmitInfo* info);
255 
256   void atomic_op(LIR_Code code, LIR_Opr src, LIR_Opr data, LIR_Opr dest, LIR_Opr tmp);
257 
258 #include CPU_HEADER(c1_LIRAssembler)
259 
260  public:
261   int nr_immediate_oops_patched() const { return _immediate_oops_patched; }
262 
263   static int call_stub_size() {
264     return _call_stub_size;
265   }
266 
267   static int exception_handler_size() {
268     return _exception_handler_size;
269   }
270 
271   static int deopt_handler_size() {
272     return _deopt_handler_size;
273   }
274 };
275 
276 #endif // SHARE_C1_C1_LIRASSEMBLER_HPP
< prev index next >