src/share/vm/c1/c1_LIRAssembler.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File c1-coops Sdiff src/share/vm/c1

src/share/vm/c1/c1_LIRAssembler.hpp

Print this page




 148   void emit_exception_entries(ExceptionInfoList* info_list);
 149   int  emit_deopt_handler();
 150 
 151   void emit_code(BlockList* hir);
 152   void emit_block(BlockBegin* block);
 153   void emit_lir_list(LIR_List* list);
 154 
 155   // any last minute peephole optimizations are performed here.  In
 156   // particular sparc uses this for delay slot filling.
 157   void peephole(LIR_List* list);
 158 
 159   void emit_string_compare(LIR_Opr left, LIR_Opr right, LIR_Opr dst, CodeEmitInfo* info);
 160 
 161   void return_op(LIR_Opr result);
 162 
 163   // returns offset of poll instruction
 164   int safepoint_poll(LIR_Opr result, CodeEmitInfo* info);
 165 
 166   void const2reg  (LIR_Opr src, LIR_Opr dest, LIR_PatchCode patch_code, CodeEmitInfo* info);
 167   void const2stack(LIR_Opr src, LIR_Opr dest);
 168   void const2mem  (LIR_Opr src, LIR_Opr dest, BasicType type, CodeEmitInfo* info);
 169   void reg2stack  (LIR_Opr src, LIR_Opr dest, BasicType type, bool pop_fpu_stack);
 170   void reg2reg    (LIR_Opr src, LIR_Opr dest);
 171   void reg2mem    (LIR_Opr src, LIR_Opr dest, BasicType type, LIR_PatchCode patch_code, CodeEmitInfo* info, bool pop_fpu_stack, bool unaligned);


 172   void stack2reg  (LIR_Opr src, LIR_Opr dest, BasicType type);
 173   void stack2stack(LIR_Opr src, LIR_Opr dest, BasicType type);
 174   void mem2reg    (LIR_Opr src, LIR_Opr dest, BasicType type,
 175                    LIR_PatchCode patch_code = lir_patch_none,
 176                    CodeEmitInfo* info = NULL, bool unaligned = false);
 177 
 178   void prefetchr  (LIR_Opr src);
 179   void prefetchw  (LIR_Opr src);
 180 
 181   void shift_op(LIR_Code code, LIR_Opr left, LIR_Opr count, LIR_Opr dest, LIR_Opr tmp);
 182   void shift_op(LIR_Code code, LIR_Opr left, jint  count, LIR_Opr dest);
 183 
 184   void move_regs(Register from_reg, Register to_reg);
 185   void swap_reg(Register a, Register b);
 186 
 187   void emit_op0(LIR_Op0* op);
 188   void emit_op1(LIR_Op1* op);
 189   void emit_op2(LIR_Op2* op);
 190   void emit_op3(LIR_Op3* op);
 191   void emit_opBranch(LIR_OpBranch* op);
 192   void emit_opLabel(LIR_OpLabel* op);
 193   void emit_arraycopy(LIR_OpArrayCopy* op);
 194   void emit_opConvert(LIR_OpConvert* op);
 195   void emit_alloc_obj(LIR_OpAllocObj* op);
 196   void emit_alloc_array(LIR_OpAllocArray* op);
 197   void emit_opTypeCheck(LIR_OpTypeCheck* op);
 198   void emit_typecheck_helper(LIR_OpTypeCheck *op, Label* success, Label* failure, Label* obj_is_null);
 199   void emit_compare_and_swap(LIR_OpCompareAndSwap* op);
 200   void emit_lock(LIR_OpLock* op);
 201   void emit_call(LIR_OpJavaCall* op);
 202   void emit_rtcall(LIR_OpRTCall* op);
 203   void emit_profile_call(LIR_OpProfileCall* op);
 204   void emit_delay(LIR_OpDelay* op);
 205 
 206   void arith_op(LIR_Code code, LIR_Opr left, LIR_Opr right, LIR_Opr dest, CodeEmitInfo* info, bool pop_fpu_stack);
 207   void arithmetic_idiv(LIR_Code code, LIR_Opr left, LIR_Opr right, LIR_Opr temp, LIR_Opr result, CodeEmitInfo* info);
 208   void intrinsic_op(LIR_Code code, LIR_Opr value, LIR_Opr unused, LIR_Opr dest, LIR_Op* op);
 209 
 210   void logic_op(LIR_Code code, LIR_Opr left, LIR_Opr right, LIR_Opr dest);
 211 
 212   void roundfp_op(LIR_Opr src, LIR_Opr tmp, LIR_Opr dest, bool pop_fpu_stack);
 213   void move_op(LIR_Opr src, LIR_Opr result, BasicType type,
 214                LIR_PatchCode patch_code, CodeEmitInfo* info, bool pop_fpu_stack, bool unaligned);
 215   void volatile_move_op(LIR_Opr src, LIR_Opr result, BasicType type, CodeEmitInfo* info);
 216   void comp_mem_op(LIR_Opr src, LIR_Opr result, BasicType type, CodeEmitInfo* info);  // info set for null exceptions
 217   void comp_fl2i(LIR_Code code, LIR_Opr left, LIR_Opr right, LIR_Opr result, LIR_Op2* op);
 218   void cmove(LIR_Condition code, LIR_Opr left, LIR_Opr right, LIR_Opr result);
 219 
 220   void call(        LIR_OpJavaCall* op, relocInfo::relocType rtype);
 221   void ic_call(     LIR_OpJavaCall* op);
 222   void vtable_call( LIR_OpJavaCall* op);
 223 
 224   void osr_entry();
 225 
 226   void build_frame();
 227 
 228   void throw_op(LIR_Opr exceptionPC, LIR_Opr exceptionOop, CodeEmitInfo* info);
 229   void unwind_op(LIR_Opr exceptionOop);
 230   void monitor_address(int monitor_ix, LIR_Opr dst);
 231 
 232   void align_backward_branch_target();
 233   void align_call(LIR_Code code);
 234 




 148   void emit_exception_entries(ExceptionInfoList* info_list);
 149   int  emit_deopt_handler();
 150 
 151   void emit_code(BlockList* hir);
 152   void emit_block(BlockBegin* block);
 153   void emit_lir_list(LIR_List* list);
 154 
 155   // any last minute peephole optimizations are performed here.  In
 156   // particular sparc uses this for delay slot filling.
 157   void peephole(LIR_List* list);
 158 
 159   void emit_string_compare(LIR_Opr left, LIR_Opr right, LIR_Opr dst, CodeEmitInfo* info);
 160 
 161   void return_op(LIR_Opr result);
 162 
 163   // returns offset of poll instruction
 164   int safepoint_poll(LIR_Opr result, CodeEmitInfo* info);
 165 
 166   void const2reg  (LIR_Opr src, LIR_Opr dest, LIR_PatchCode patch_code, CodeEmitInfo* info);
 167   void const2stack(LIR_Opr src, LIR_Opr dest);
 168   void const2mem  (LIR_Opr src, LIR_Opr dest, BasicType type, CodeEmitInfo* info, bool wide);
 169   void reg2stack  (LIR_Opr src, LIR_Opr dest, BasicType type, bool pop_fpu_stack);
 170   void reg2reg    (LIR_Opr src, LIR_Opr dest);
 171   void reg2mem    (LIR_Opr src, LIR_Opr dest, BasicType type,
 172                    LIR_PatchCode patch_code, CodeEmitInfo* info,
 173                    bool pop_fpu_stack, bool wide, bool unaligned);
 174   void stack2reg  (LIR_Opr src, LIR_Opr dest, BasicType type);
 175   void stack2stack(LIR_Opr src, LIR_Opr dest, BasicType type);
 176   void mem2reg    (LIR_Opr src, LIR_Opr dest, BasicType type,
 177                    LIR_PatchCode patch_code,
 178                    CodeEmitInfo* info, bool wide, bool unaligned);
 179 
 180   void prefetchr  (LIR_Opr src);
 181   void prefetchw  (LIR_Opr src);
 182 
 183   void shift_op(LIR_Code code, LIR_Opr left, LIR_Opr count, LIR_Opr dest, LIR_Opr tmp);
 184   void shift_op(LIR_Code code, LIR_Opr left, jint  count, LIR_Opr dest);
 185 
 186   void move_regs(Register from_reg, Register to_reg);
 187   void swap_reg(Register a, Register b);
 188 
 189   void emit_op0(LIR_Op0* op);
 190   void emit_op1(LIR_Op1* op);
 191   void emit_op2(LIR_Op2* op);
 192   void emit_op3(LIR_Op3* op);
 193   void emit_opBranch(LIR_OpBranch* op);
 194   void emit_opLabel(LIR_OpLabel* op);
 195   void emit_arraycopy(LIR_OpArrayCopy* op);
 196   void emit_opConvert(LIR_OpConvert* op);
 197   void emit_alloc_obj(LIR_OpAllocObj* op);
 198   void emit_alloc_array(LIR_OpAllocArray* op);
 199   void emit_opTypeCheck(LIR_OpTypeCheck* op);
 200   void emit_typecheck_helper(LIR_OpTypeCheck *op, Label* success, Label* failure, Label* obj_is_null);
 201   void emit_compare_and_swap(LIR_OpCompareAndSwap* op);
 202   void emit_lock(LIR_OpLock* op);
 203   void emit_call(LIR_OpJavaCall* op);
 204   void emit_rtcall(LIR_OpRTCall* op);
 205   void emit_profile_call(LIR_OpProfileCall* op);
 206   void emit_delay(LIR_OpDelay* op);
 207 
 208   void arith_op(LIR_Code code, LIR_Opr left, LIR_Opr right, LIR_Opr dest, CodeEmitInfo* info, bool pop_fpu_stack);
 209   void arithmetic_idiv(LIR_Code code, LIR_Opr left, LIR_Opr right, LIR_Opr temp, LIR_Opr result, CodeEmitInfo* info);
 210   void intrinsic_op(LIR_Code code, LIR_Opr value, LIR_Opr unused, LIR_Opr dest, LIR_Op* op);
 211 
 212   void logic_op(LIR_Code code, LIR_Opr left, LIR_Opr right, LIR_Opr dest);
 213 
 214   void roundfp_op(LIR_Opr src, LIR_Opr tmp, LIR_Opr dest, bool pop_fpu_stack);
 215   void move_op(LIR_Opr src, LIR_Opr result, BasicType type,
 216                LIR_PatchCode patch_code, CodeEmitInfo* info, bool pop_fpu_stack, bool unaligned, bool wide);
 217   void volatile_move_op(LIR_Opr src, LIR_Opr result, BasicType type, CodeEmitInfo* info);
 218   void comp_mem_op(LIR_Opr src, LIR_Opr result, BasicType type, CodeEmitInfo* info);  // info set for null exceptions
 219   void comp_fl2i(LIR_Code code, LIR_Opr left, LIR_Opr right, LIR_Opr result, LIR_Op2* op);
 220   void cmove(LIR_Condition code, LIR_Opr left, LIR_Opr right, LIR_Opr result);
 221 
 222   void call(        LIR_OpJavaCall* op, relocInfo::relocType rtype);
 223   void ic_call(     LIR_OpJavaCall* op);
 224   void vtable_call( LIR_OpJavaCall* op);
 225 
 226   void osr_entry();
 227 
 228   void build_frame();
 229 
 230   void throw_op(LIR_Opr exceptionPC, LIR_Opr exceptionOop, CodeEmitInfo* info);
 231   void unwind_op(LIR_Opr exceptionOop);
 232   void monitor_address(int monitor_ix, LIR_Opr dst);
 233 
 234   void align_backward_branch_target();
 235   void align_call(LIR_Code code);
 236 


src/share/vm/c1/c1_LIRAssembler.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File