< prev index next >

src/hotspot/cpu/x86/x86_64.ad

Print this page

  981       emit_d8(cbuf, framesize);
  982     } else {
  983       emit_opcode(cbuf, 0x81); // addq rsp, #framesize
  984       emit_rm(cbuf, 0x3, 0x00, RSP_enc);
  985       emit_d32(cbuf, framesize);
  986     }
  987   }
  988 
  989   // popq rbp
  990   emit_opcode(cbuf, 0x58 | RBP_enc);
  991 
  992   if (StackReservedPages > 0 && C->has_reserved_stack_access()) {
  993     __ reserved_stack_check();
  994   }
  995 
  996   if (do_polling() && C->is_method_compilation()) {
  997     MacroAssembler _masm(&cbuf);
  998     Label dummy_label;
  999     Label* code_stub = &dummy_label;
 1000     if (!C->output()->in_scratch_emit_size()) {
 1001       code_stub = &C->output()->safepoint_poll_table()->add_safepoint(__ offset());


 1002     }
 1003     __ relocate(relocInfo::poll_return_type);
 1004     __ safepoint_poll(*code_stub, r15_thread, true /* at_return */, true /* in_nmethod */);
 1005   }
 1006 }
 1007 
 1008 uint MachEpilogNode::size(PhaseRegAlloc* ra_) const
 1009 {
 1010   return MachNode::size(ra_); // too many variables; just compute it
 1011                               // the hard way
 1012 }
 1013 
 1014 int MachEpilogNode::reloc() const
 1015 {
 1016   return 2; // a large enough number
 1017 }
 1018 
 1019 const Pipeline* MachEpilogNode::pipeline() const
 1020 {
 1021   return MachNode::pipeline_class();

 5173    ins_pipe(ialu_reg_mem); // XXX
 5174 %}
 5175 
 5176 
 5177 // Load Klass Pointer
 5178 instruct loadKlass(rRegP dst, memory mem)
 5179 %{
 5180   match(Set dst (LoadKlass mem));
 5181 
 5182   ins_cost(125); // XXX
 5183   format %{ "movq    $dst, $mem\t# class" %}
 5184   ins_encode %{
 5185     __ movq($dst$$Register, $mem$$Address);
 5186   %}
 5187   ins_pipe(ialu_reg_mem); // XXX
 5188 %}
 5189 
 5190 // Load narrow Klass Pointer
 5191 instruct loadNKlass(rRegN dst, memory mem)
 5192 %{

 5193   match(Set dst (LoadNKlass mem));
 5194 
 5195   ins_cost(125); // XXX
 5196   format %{ "movl    $dst, $mem\t# compressed klass ptr" %}
 5197   ins_encode %{
 5198     __ movl($dst$$Register, $mem$$Address);
 5199   %}
 5200   ins_pipe(ialu_reg_mem); // XXX
 5201 %}
 5202 























 5203 // Load Float
 5204 instruct loadF(regF dst, memory mem)
 5205 %{
 5206   match(Set dst (LoadF mem));
 5207 
 5208   ins_cost(145); // XXX
 5209   format %{ "movss   $dst, $mem\t# float" %}
 5210   ins_encode %{
 5211     __ movflt($dst$$XMMRegister, $mem$$Address);
 5212   %}
 5213   ins_pipe(pipe_slow); // XXX
 5214 %}
 5215 
 5216 // Load Float
 5217 instruct MoveF2VL(vlRegF dst, regF src) %{
 5218   match(Set dst src);
 5219   format %{ "movss $dst,$src\t! load float (4 bytes)" %}
 5220   ins_encode %{
 5221     __ movflt($dst$$XMMRegister, $src$$XMMRegister);
 5222   %}

12208 
12209   format %{ "cmpl    $mem, $src\t# compressed ptr" %}
12210   ins_encode %{
12211     __ cmp_narrow_oop($mem$$Address, (jobject)$src$$constant);
12212   %}
12213   ins_pipe(ialu_cr_reg_mem);
12214 %}
12215 
12216 instruct compN_rReg_imm_klass(rFlagsRegU cr, rRegN op1, immNKlass op2) %{
12217   match(Set cr (CmpN op1 op2));
12218 
12219   format %{ "cmpl    $op1, $op2\t# compressed klass ptr" %}
12220   ins_encode %{
12221     __ cmp_narrow_klass($op1$$Register, (Klass*)$op2$$constant);
12222   %}
12223   ins_pipe(ialu_cr_reg_imm);
12224 %}
12225 
12226 instruct compN_mem_imm_klass(rFlagsRegU cr, memory mem, immNKlass src)
12227 %{

12228   match(Set cr (CmpN src (LoadNKlass mem)));
12229 
12230   format %{ "cmpl    $mem, $src\t# compressed klass ptr" %}
12231   ins_encode %{
12232     __ cmp_narrow_klass($mem$$Address, (Klass*)$src$$constant);
12233   %}
12234   ins_pipe(ialu_cr_reg_mem);
12235 %}
12236 
12237 instruct testN_reg(rFlagsReg cr, rRegN src, immN0 zero) %{
12238   match(Set cr (CmpN src zero));
12239 
12240   format %{ "testl   $src, $src\t# compressed ptr" %}
12241   ins_encode %{ __ testl($src$$Register, $src$$Register); %}
12242   ins_pipe(ialu_cr_reg_imm);
12243 %}
12244 
12245 instruct testN_mem(rFlagsReg cr, memory mem, immN0 zero)
12246 %{
12247   predicate(CompressedOops::base() != NULL);

12906       __ bind(done);
12907     } else {
12908        ShouldNotReachHere();
12909     }
12910   %}
12911   ins_pipe(pipe_jcc);
12912   ins_short_branch(1);
12913 %}
12914 
12915 // ============================================================================
12916 // inlined locking and unlocking
12917 
12918 instruct cmpFastLockRTM(rFlagsReg cr, rRegP object, rbx_RegP box, rax_RegI tmp, rdx_RegI scr, rRegI cx1, rRegI cx2) %{
12919   predicate(Compile::current()->use_rtm());
12920   match(Set cr (FastLock object box));
12921   effect(TEMP tmp, TEMP scr, TEMP cx1, TEMP cx2, USE_KILL box);
12922   ins_cost(300);
12923   format %{ "fastlock $object,$box\t! kills $box,$tmp,$scr,$cx1,$cx2" %}
12924   ins_encode %{
12925     __ fast_lock($object$$Register, $box$$Register, $tmp$$Register,
12926                  $scr$$Register, $cx1$$Register, $cx2$$Register,
12927                  _counters, _rtm_counters, _stack_rtm_counters,
12928                  ((Method*)(ra_->C->method()->constant_encoding()))->method_data(),
12929                  true, ra_->C->profile_rtm());
12930   %}
12931   ins_pipe(pipe_slow);
12932 %}
12933 
12934 instruct cmpFastLock(rFlagsReg cr, rRegP object, rbx_RegP box, rax_RegI tmp, rRegP scr, rRegP cx1) %{
12935   predicate(!Compile::current()->use_rtm());
12936   match(Set cr (FastLock object box));
12937   effect(TEMP tmp, TEMP scr, TEMP cx1, USE_KILL box);
12938   ins_cost(300);
12939   format %{ "fastlock $object,$box\t! kills $box,$tmp,$scr" %}
12940   ins_encode %{
12941     __ fast_lock($object$$Register, $box$$Register, $tmp$$Register,
12942                  $scr$$Register, $cx1$$Register, noreg, _counters, NULL, NULL, NULL, false, false);
12943   %}
12944   ins_pipe(pipe_slow);
12945 %}
12946 
12947 instruct cmpFastUnlock(rFlagsReg cr, rRegP object, rax_RegP box, rRegP tmp) %{
12948   match(Set cr (FastUnlock object box));
12949   effect(TEMP tmp, USE_KILL box);
12950   ins_cost(300);
12951   format %{ "fastunlock $object,$box\t! kills $box,$tmp" %}
12952   ins_encode %{
12953     __ fast_unlock($object$$Register, $box$$Register, $tmp$$Register, ra_->C->use_rtm());
12954   %}
12955   ins_pipe(pipe_slow);
12956 %}
12957 
12958 
12959 // ============================================================================
12960 // Safepoint Instructions
12961 instruct safePoint_poll_tls(rFlagsReg cr, rRegP poll)
12962 %{

  981       emit_d8(cbuf, framesize);
  982     } else {
  983       emit_opcode(cbuf, 0x81); // addq rsp, #framesize
  984       emit_rm(cbuf, 0x3, 0x00, RSP_enc);
  985       emit_d32(cbuf, framesize);
  986     }
  987   }
  988 
  989   // popq rbp
  990   emit_opcode(cbuf, 0x58 | RBP_enc);
  991 
  992   if (StackReservedPages > 0 && C->has_reserved_stack_access()) {
  993     __ reserved_stack_check();
  994   }
  995 
  996   if (do_polling() && C->is_method_compilation()) {
  997     MacroAssembler _masm(&cbuf);
  998     Label dummy_label;
  999     Label* code_stub = &dummy_label;
 1000     if (!C->output()->in_scratch_emit_size()) {
 1001       C2SafepointPollStub* stub = new (C->comp_arena()) C2SafepointPollStub(__ offset());
 1002       C->output()->add_stub(stub);
 1003       code_stub = &stub->entry();
 1004     }
 1005     __ relocate(relocInfo::poll_return_type);
 1006     __ safepoint_poll(*code_stub, r15_thread, true /* at_return */, true /* in_nmethod */);
 1007   }
 1008 }
 1009 
 1010 uint MachEpilogNode::size(PhaseRegAlloc* ra_) const
 1011 {
 1012   return MachNode::size(ra_); // too many variables; just compute it
 1013                               // the hard way
 1014 }
 1015 
 1016 int MachEpilogNode::reloc() const
 1017 {
 1018   return 2; // a large enough number
 1019 }
 1020 
 1021 const Pipeline* MachEpilogNode::pipeline() const
 1022 {
 1023   return MachNode::pipeline_class();

 5175    ins_pipe(ialu_reg_mem); // XXX
 5176 %}
 5177 
 5178 
 5179 // Load Klass Pointer
 5180 instruct loadKlass(rRegP dst, memory mem)
 5181 %{
 5182   match(Set dst (LoadKlass mem));
 5183 
 5184   ins_cost(125); // XXX
 5185   format %{ "movq    $dst, $mem\t# class" %}
 5186   ins_encode %{
 5187     __ movq($dst$$Register, $mem$$Address);
 5188   %}
 5189   ins_pipe(ialu_reg_mem); // XXX
 5190 %}
 5191 
 5192 // Load narrow Klass Pointer
 5193 instruct loadNKlass(rRegN dst, memory mem)
 5194 %{
 5195   predicate(!UseCompactObjectHeaders);
 5196   match(Set dst (LoadNKlass mem));
 5197 
 5198   ins_cost(125); // XXX
 5199   format %{ "movl    $dst, $mem\t# compressed klass ptr" %}
 5200   ins_encode %{
 5201     __ movl($dst$$Register, $mem$$Address);
 5202   %}
 5203   ins_pipe(ialu_reg_mem); // XXX
 5204 %}
 5205 
 5206 instruct loadNKlassLilliput(rRegN dst, indOffset8 mem, rFlagsReg cr)
 5207 %{
 5208   predicate(UseCompactObjectHeaders);
 5209   match(Set dst (LoadNKlass mem));
 5210   effect(KILL cr);
 5211   ins_cost(125); // XXX
 5212   format %{ "movl    $dst, $mem\t# compressed klass ptr" %}
 5213   ins_encode %{
 5214     assert($mem$$disp == oopDesc::klass_offset_in_bytes(), "expect correct offset 4, but got: %d", $mem$$disp);
 5215     assert($mem$$index == 4, "expect no index register: %d", $mem$$index);
 5216     Register dst = $dst$$Register;
 5217     Register obj = $mem$$base$$Register;
 5218     C2LoadNKlassStub* stub = new (Compile::current()->comp_arena()) C2LoadNKlassStub(dst);
 5219     Compile::current()->output()->add_stub(stub);
 5220     __ movq(dst, Address(obj, oopDesc::mark_offset_in_bytes()));
 5221     __ testb(dst, markWord::monitor_value);
 5222     __ jcc(Assembler::notZero, stub->entry());
 5223     __ bind(stub->continuation());
 5224     __ shrq(dst, markWord::klass_shift);
 5225   %}
 5226   ins_pipe(pipe_slow); // XXX
 5227 %}
 5228 
 5229 // Load Float
 5230 instruct loadF(regF dst, memory mem)
 5231 %{
 5232   match(Set dst (LoadF mem));
 5233 
 5234   ins_cost(145); // XXX
 5235   format %{ "movss   $dst, $mem\t# float" %}
 5236   ins_encode %{
 5237     __ movflt($dst$$XMMRegister, $mem$$Address);
 5238   %}
 5239   ins_pipe(pipe_slow); // XXX
 5240 %}
 5241 
 5242 // Load Float
 5243 instruct MoveF2VL(vlRegF dst, regF src) %{
 5244   match(Set dst src);
 5245   format %{ "movss $dst,$src\t! load float (4 bytes)" %}
 5246   ins_encode %{
 5247     __ movflt($dst$$XMMRegister, $src$$XMMRegister);
 5248   %}

12234 
12235   format %{ "cmpl    $mem, $src\t# compressed ptr" %}
12236   ins_encode %{
12237     __ cmp_narrow_oop($mem$$Address, (jobject)$src$$constant);
12238   %}
12239   ins_pipe(ialu_cr_reg_mem);
12240 %}
12241 
12242 instruct compN_rReg_imm_klass(rFlagsRegU cr, rRegN op1, immNKlass op2) %{
12243   match(Set cr (CmpN op1 op2));
12244 
12245   format %{ "cmpl    $op1, $op2\t# compressed klass ptr" %}
12246   ins_encode %{
12247     __ cmp_narrow_klass($op1$$Register, (Klass*)$op2$$constant);
12248   %}
12249   ins_pipe(ialu_cr_reg_imm);
12250 %}
12251 
12252 instruct compN_mem_imm_klass(rFlagsRegU cr, memory mem, immNKlass src)
12253 %{
12254   predicate(!UseCompactObjectHeaders);
12255   match(Set cr (CmpN src (LoadNKlass mem)));
12256 
12257   format %{ "cmpl    $mem, $src\t# compressed klass ptr" %}
12258   ins_encode %{
12259     __ cmp_narrow_klass($mem$$Address, (Klass*)$src$$constant);
12260   %}
12261   ins_pipe(ialu_cr_reg_mem);
12262 %}
12263 
12264 instruct testN_reg(rFlagsReg cr, rRegN src, immN0 zero) %{
12265   match(Set cr (CmpN src zero));
12266 
12267   format %{ "testl   $src, $src\t# compressed ptr" %}
12268   ins_encode %{ __ testl($src$$Register, $src$$Register); %}
12269   ins_pipe(ialu_cr_reg_imm);
12270 %}
12271 
12272 instruct testN_mem(rFlagsReg cr, memory mem, immN0 zero)
12273 %{
12274   predicate(CompressedOops::base() != NULL);

12933       __ bind(done);
12934     } else {
12935        ShouldNotReachHere();
12936     }
12937   %}
12938   ins_pipe(pipe_jcc);
12939   ins_short_branch(1);
12940 %}
12941 
12942 // ============================================================================
12943 // inlined locking and unlocking
12944 
12945 instruct cmpFastLockRTM(rFlagsReg cr, rRegP object, rbx_RegP box, rax_RegI tmp, rdx_RegI scr, rRegI cx1, rRegI cx2) %{
12946   predicate(Compile::current()->use_rtm());
12947   match(Set cr (FastLock object box));
12948   effect(TEMP tmp, TEMP scr, TEMP cx1, TEMP cx2, USE_KILL box);
12949   ins_cost(300);
12950   format %{ "fastlock $object,$box\t! kills $box,$tmp,$scr,$cx1,$cx2" %}
12951   ins_encode %{
12952     __ fast_lock($object$$Register, $box$$Register, $tmp$$Register,
12953                  $scr$$Register, $cx1$$Register, $cx2$$Register, r15_thread,
12954                  _counters, _rtm_counters, _stack_rtm_counters,
12955                  ((Method*)(ra_->C->method()->constant_encoding()))->method_data(),
12956                  true, ra_->C->profile_rtm());
12957   %}
12958   ins_pipe(pipe_slow);
12959 %}
12960 
12961 instruct cmpFastLock(rFlagsReg cr, rRegP object, rbx_RegP box, rax_RegI tmp, rRegP scr, rRegP cx1) %{
12962   predicate(!Compile::current()->use_rtm());
12963   match(Set cr (FastLock object box));
12964   effect(TEMP tmp, TEMP scr, TEMP cx1, USE_KILL box);
12965   ins_cost(300);
12966   format %{ "fastlock $object,$box\t! kills $box,$tmp,$scr" %}
12967   ins_encode %{
12968     __ fast_lock($object$$Register, $box$$Register, $tmp$$Register,
12969                  $scr$$Register, $cx1$$Register, noreg, r15_thread, _counters, NULL, NULL, NULL, false, false);
12970   %}
12971   ins_pipe(pipe_slow);
12972 %}
12973 
12974 instruct cmpFastUnlock(rFlagsReg cr, rRegP object, rax_RegP box, rRegP tmp) %{
12975   match(Set cr (FastUnlock object box));
12976   effect(TEMP tmp, USE_KILL box);
12977   ins_cost(300);
12978   format %{ "fastunlock $object,$box\t! kills $box,$tmp" %}
12979   ins_encode %{
12980     __ fast_unlock($object$$Register, $box$$Register, $tmp$$Register, ra_->C->use_rtm());
12981   %}
12982   ins_pipe(pipe_slow);
12983 %}
12984 
12985 
12986 // ============================================================================
12987 // Safepoint Instructions
12988 instruct safePoint_poll_tls(rFlagsReg cr, rRegP poll)
12989 %{
< prev index next >