64 ResourceMark rm;
65 BufferBlob* blob = BufferBlob::create(name, BUFFER_SIZE);
66 CodeBuffer cbuf(blob);
67 MacroAssembler* masm = new MacroAssembler(&cbuf);
68 address fast_entry = __ pc();
69
70 Label slow;
71
72 ExternalAddress counter(SafepointSynchronize::safepoint_counter_addr());
73 __ mov32 (rcounter, counter);
74 __ mov (robj, c_rarg1);
75 __ testb (rcounter, 1);
76 __ jcc (Assembler::notZero, slow);
77 if (os::is_MP()) {
78 __ xorptr(robj, rcounter);
79 __ xorptr(robj, rcounter); // obj, since
80 // robj ^ rcounter ^ rcounter == robj
81 // robj is data dependent on rcounter.
82 }
83 __ movptr(robj, Address(robj, 0)); // *obj
84 __ mov (roffset, c_rarg2);
85 __ shrptr(roffset, 2); // offset
86
87 assert(count < LIST_CAPACITY, "LIST_CAPACITY too small");
88 speculative_load_pclist[count] = __ pc();
89 switch (type) {
90 case T_BOOLEAN: __ movzbl (rax, Address(robj, roffset, Address::times_1)); break;
91 case T_BYTE: __ movsbl (rax, Address(robj, roffset, Address::times_1)); break;
92 case T_CHAR: __ movzwl (rax, Address(robj, roffset, Address::times_1)); break;
93 case T_SHORT: __ movswl (rax, Address(robj, roffset, Address::times_1)); break;
94 case T_INT: __ movl (rax, Address(robj, roffset, Address::times_1)); break;
95 case T_LONG: __ movq (rax, Address(robj, roffset, Address::times_1)); break;
96 default: ShouldNotReachHere();
97 }
98
99 if (os::is_MP()) {
100 __ lea(rcounter_addr, counter);
101 // ca is data dependent on rax.
102 __ xorptr(rcounter_addr, rax);
103 __ xorptr(rcounter_addr, rax);
162 ResourceMark rm;
163 BufferBlob* blob = BufferBlob::create(name, BUFFER_SIZE);
164 CodeBuffer cbuf(blob);
165 MacroAssembler* masm = new MacroAssembler(&cbuf);
166 address fast_entry = __ pc();
167
168 Label slow;
169
170 ExternalAddress counter(SafepointSynchronize::safepoint_counter_addr());
171 __ mov32 (rcounter, counter);
172 __ mov (robj, c_rarg1);
173 __ testb (rcounter, 1);
174 __ jcc (Assembler::notZero, slow);
175 if (os::is_MP()) {
176 __ xorptr(robj, rcounter);
177 __ xorptr(robj, rcounter); // obj, since
178 // robj ^ rcounter ^ rcounter == robj
179 // robj is data dependent on rcounter.
180 }
181 __ movptr(robj, Address(robj, 0)); // *obj
182 __ mov (roffset, c_rarg2);
183 __ shrptr(roffset, 2); // offset
184
185 assert(count < LIST_CAPACITY, "LIST_CAPACITY too small");
186 speculative_load_pclist[count] = __ pc();
187 switch (type) {
188 case T_FLOAT: __ movflt (xmm0, Address(robj, roffset, Address::times_1)); break;
189 case T_DOUBLE: __ movdbl (xmm0, Address(robj, roffset, Address::times_1)); break;
190 default: ShouldNotReachHere();
191 }
192
193 if (os::is_MP()) {
194 __ lea(rcounter_addr, counter);
195 __ movdq (rax, xmm0);
196 // counter address is data dependent on xmm0.
197 __ xorptr(rcounter_addr, rax);
198 __ xorptr(rcounter_addr, rax);
199 __ cmpl (rcounter, Address(rcounter_addr, 0));
200 } else {
201 __ cmp32 (rcounter, counter);
|
64 ResourceMark rm;
65 BufferBlob* blob = BufferBlob::create(name, BUFFER_SIZE);
66 CodeBuffer cbuf(blob);
67 MacroAssembler* masm = new MacroAssembler(&cbuf);
68 address fast_entry = __ pc();
69
70 Label slow;
71
72 ExternalAddress counter(SafepointSynchronize::safepoint_counter_addr());
73 __ mov32 (rcounter, counter);
74 __ mov (robj, c_rarg1);
75 __ testb (rcounter, 1);
76 __ jcc (Assembler::notZero, slow);
77 if (os::is_MP()) {
78 __ xorptr(robj, rcounter);
79 __ xorptr(robj, rcounter); // obj, since
80 // robj ^ rcounter ^ rcounter == robj
81 // robj is data dependent on rcounter.
82 }
83 __ movptr(robj, Address(robj, 0)); // *obj
84 oopDesc::bs()->interpreter_read_barrier(masm, robj);
85 __ mov (roffset, c_rarg2);
86 __ shrptr(roffset, 2); // offset
87
88 assert(count < LIST_CAPACITY, "LIST_CAPACITY too small");
89 speculative_load_pclist[count] = __ pc();
90 switch (type) {
91 case T_BOOLEAN: __ movzbl (rax, Address(robj, roffset, Address::times_1)); break;
92 case T_BYTE: __ movsbl (rax, Address(robj, roffset, Address::times_1)); break;
93 case T_CHAR: __ movzwl (rax, Address(robj, roffset, Address::times_1)); break;
94 case T_SHORT: __ movswl (rax, Address(robj, roffset, Address::times_1)); break;
95 case T_INT: __ movl (rax, Address(robj, roffset, Address::times_1)); break;
96 case T_LONG: __ movq (rax, Address(robj, roffset, Address::times_1)); break;
97 default: ShouldNotReachHere();
98 }
99
100 if (os::is_MP()) {
101 __ lea(rcounter_addr, counter);
102 // ca is data dependent on rax.
103 __ xorptr(rcounter_addr, rax);
104 __ xorptr(rcounter_addr, rax);
163 ResourceMark rm;
164 BufferBlob* blob = BufferBlob::create(name, BUFFER_SIZE);
165 CodeBuffer cbuf(blob);
166 MacroAssembler* masm = new MacroAssembler(&cbuf);
167 address fast_entry = __ pc();
168
169 Label slow;
170
171 ExternalAddress counter(SafepointSynchronize::safepoint_counter_addr());
172 __ mov32 (rcounter, counter);
173 __ mov (robj, c_rarg1);
174 __ testb (rcounter, 1);
175 __ jcc (Assembler::notZero, slow);
176 if (os::is_MP()) {
177 __ xorptr(robj, rcounter);
178 __ xorptr(robj, rcounter); // obj, since
179 // robj ^ rcounter ^ rcounter == robj
180 // robj is data dependent on rcounter.
181 }
182 __ movptr(robj, Address(robj, 0)); // *obj
183 oopDesc::bs()->interpreter_read_barrier(masm, robj);
184 __ mov (roffset, c_rarg2);
185 __ shrptr(roffset, 2); // offset
186
187 assert(count < LIST_CAPACITY, "LIST_CAPACITY too small");
188 speculative_load_pclist[count] = __ pc();
189 switch (type) {
190 case T_FLOAT: __ movflt (xmm0, Address(robj, roffset, Address::times_1)); break;
191 case T_DOUBLE: __ movdbl (xmm0, Address(robj, roffset, Address::times_1)); break;
192 default: ShouldNotReachHere();
193 }
194
195 if (os::is_MP()) {
196 __ lea(rcounter_addr, counter);
197 __ movdq (rax, xmm0);
198 // counter address is data dependent on xmm0.
199 __ xorptr(rcounter_addr, rax);
200 __ xorptr(rcounter_addr, rax);
201 __ cmpl (rcounter, Address(rcounter_addr, 0));
202 } else {
203 __ cmp32 (rcounter, counter);
|