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
84 __ clear_jweak_tag(robj);
85
86 __ movptr(robj, Address(robj, 0)); // *obj
87 __ resolve_for_read(0, robj);
88 __ mov (roffset, c_rarg2);
89 __ shrptr(roffset, 2); // offset
90
91 assert(count < LIST_CAPACITY, "LIST_CAPACITY too small");
92 speculative_load_pclist[count] = __ pc();
93 switch (type) {
94 case T_BOOLEAN: __ movzbl (rax, Address(robj, roffset, Address::times_1)); break;
95 case T_BYTE: __ movsbl (rax, Address(robj, roffset, Address::times_1)); break;
96 case T_CHAR: __ movzwl (rax, Address(robj, roffset, Address::times_1)); break;
97 case T_SHORT: __ movswl (rax, Address(robj, roffset, Address::times_1)); break;
98 case T_INT: __ movl (rax, Address(robj, roffset, Address::times_1)); break;
99 case T_LONG: __ movq (rax, Address(robj, roffset, Address::times_1)); break;
100 default: ShouldNotReachHere();
101 }
102
103 if (os::is_MP()) {
104 __ lea(rcounter_addr, counter);
105 // ca is data dependent on rax.
106 __ xorptr(rcounter_addr, rax);
107 __ xorptr(rcounter_addr, rax);
108 __ cmpl (rcounter, Address(rcounter_addr, 0));
109 } else {
110 __ cmp32 (rcounter, counter);
111 }
112 __ jcc (Assembler::notEqual, slow);
113
114 __ ret (0);
115
116 slowcase_entry_pclist[count++] = __ pc();
117 __ bind (slow);
118 address slow_case_addr = NULL;
119 switch (type) {
170 MacroAssembler* masm = new MacroAssembler(&cbuf);
171 address fast_entry = __ pc();
172
173 Label slow;
174
175 ExternalAddress counter(SafepointSynchronize::safepoint_counter_addr());
176 __ mov32 (rcounter, counter);
177 __ mov (robj, c_rarg1);
178 __ testb (rcounter, 1);
179 __ jcc (Assembler::notZero, slow);
180 if (os::is_MP()) {
181 __ xorptr(robj, rcounter);
182 __ xorptr(robj, rcounter); // obj, since
183 // robj ^ rcounter ^ rcounter == robj
184 // robj is data dependent on rcounter.
185 }
186
187 __ clear_jweak_tag(robj);
188
189 __ movptr(robj, Address(robj, 0)); // *obj
190 __ resolve_for_read(0, robj);
191 __ mov (roffset, c_rarg2);
192 __ shrptr(roffset, 2); // offset
193
194 assert(count < LIST_CAPACITY, "LIST_CAPACITY too small");
195 speculative_load_pclist[count] = __ pc();
196 switch (type) {
197 case T_FLOAT: __ movflt (xmm0, Address(robj, roffset, Address::times_1)); break;
198 case T_DOUBLE: __ movdbl (xmm0, Address(robj, roffset, Address::times_1)); break;
199 default: ShouldNotReachHere();
200 }
201
202 if (os::is_MP()) {
203 __ lea(rcounter_addr, counter);
204 __ movdq (rax, xmm0);
205 // counter address is data dependent on xmm0.
206 __ xorptr(rcounter_addr, rax);
207 __ xorptr(rcounter_addr, rax);
208 __ cmpl (rcounter, Address(rcounter_addr, 0));
209 } else {
210 __ cmp32 (rcounter, counter);
211 }
212 __ jcc (Assembler::notEqual, slow);
213
214 __ ret (0);
215
216 slowcase_entry_pclist[count++] = __ pc();
217 __ bind (slow);
218 address slow_case_addr = NULL;
219 switch (type) {
220 case T_FLOAT: slow_case_addr = jni_GetFloatField_addr(); break;
|
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
84 __ clear_jweak_tag(robj);
85
86 __ movptr(robj, Address(robj, 0)); // *obj
87 __ mov (roffset, c_rarg2);
88 __ shrptr(roffset, 2); // offset
89
90 assert(count < LIST_CAPACITY, "LIST_CAPACITY too small");
91 speculative_load_pclist[count] = __ pc();
92 switch (type) {
93 case T_BOOLEAN:
94 case T_BYTE:
95 case T_CHAR:
96 case T_SHORT:
97 case T_INT:
98 case T_LONG:
99 __ access_load_at(type, IN_HEAP, rax, Address(robj, roffset, Address::times_1), noreg, noreg);
100 break;
101 default: ShouldNotReachHere();
102 }
103
104 if (os::is_MP()) {
105 __ lea(rcounter_addr, counter);
106 // ca is data dependent on rax.
107 __ xorptr(rcounter_addr, rax);
108 __ xorptr(rcounter_addr, rax);
109 __ cmpl (rcounter, Address(rcounter_addr, 0));
110 } else {
111 __ cmp32 (rcounter, counter);
112 }
113 __ jcc (Assembler::notEqual, slow);
114
115 __ ret (0);
116
117 slowcase_entry_pclist[count++] = __ pc();
118 __ bind (slow);
119 address slow_case_addr = NULL;
120 switch (type) {
171 MacroAssembler* masm = new MacroAssembler(&cbuf);
172 address fast_entry = __ pc();
173
174 Label slow;
175
176 ExternalAddress counter(SafepointSynchronize::safepoint_counter_addr());
177 __ mov32 (rcounter, counter);
178 __ mov (robj, c_rarg1);
179 __ testb (rcounter, 1);
180 __ jcc (Assembler::notZero, slow);
181 if (os::is_MP()) {
182 __ xorptr(robj, rcounter);
183 __ xorptr(robj, rcounter); // obj, since
184 // robj ^ rcounter ^ rcounter == robj
185 // robj is data dependent on rcounter.
186 }
187
188 __ clear_jweak_tag(robj);
189
190 __ movptr(robj, Address(robj, 0)); // *obj
191 __ mov (roffset, c_rarg2);
192 __ shrptr(roffset, 2); // offset
193
194 assert(count < LIST_CAPACITY, "LIST_CAPACITY too small");
195 speculative_load_pclist[count] = __ pc();
196
197 __ access_load_at(type, IN_HEAP, noreg, Address(robj, roffset, Address::times_1), noreg, noreg);
198
199 if (os::is_MP()) {
200 __ lea(rcounter_addr, counter);
201 __ movdq (rax, xmm0);
202 // counter address is data dependent on xmm0.
203 __ xorptr(rcounter_addr, rax);
204 __ xorptr(rcounter_addr, rax);
205 __ cmpl (rcounter, Address(rcounter_addr, 0));
206 } else {
207 __ cmp32 (rcounter, counter);
208 }
209 __ jcc (Assembler::notEqual, slow);
210
211 __ ret (0);
212
213 slowcase_entry_pclist[count++] = __ pc();
214 __ bind (slow);
215 address slow_case_addr = NULL;
216 switch (type) {
217 case T_FLOAT: slow_case_addr = jni_GetFloatField_addr(); break;
|