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 %{
|