16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "gc/shared/barrierSetAssembler.hpp"
27 #include "interpreter/interp_masm.hpp"
28
29 #define __ masm->
30
31 void BarrierSetAssembler::load_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type,
32 Register dst, Address src, Register tmp1, Register tmp_thread) {
33 bool on_heap = (decorators & IN_HEAP) != 0;
34 bool on_root = (decorators & IN_ROOT) != 0;
35 bool oop_not_null = (decorators & OOP_NOT_NULL) != 0;
36
37 switch (type) {
38 case T_OBJECT:
39 case T_ARRAY: {
40 if (on_heap) {
41 #ifdef _LP64
42 if (UseCompressedOops) {
43 __ movl(dst, src);
44 if (oop_not_null) {
45 __ decode_heap_oop_not_null(dst);
46 } else {
47 __ decode_heap_oop(dst);
48 }
49 } else
50 #endif
51 {
52 __ movptr(dst, src);
53 }
54 } else {
55 assert(on_root, "why else?");
56 __ movptr(dst, src);
57 }
58 break;
59 }
60 default: Unimplemented();
61 }
62 }
63
64 void BarrierSetAssembler::store_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type,
65 Address dst, Register val, Register tmp1, Register tmp2) {
66 bool on_heap = (decorators & IN_HEAP) != 0;
67 bool on_root = (decorators & IN_ROOT) != 0;
68 bool oop_not_null = (decorators & OOP_NOT_NULL) != 0;
69
70 switch (type) {
71 case T_OBJECT:
72 case T_ARRAY: {
73 if (on_heap) {
74 if (val == noreg) {
75 assert(!oop_not_null, "inconsistent access");
76 #ifdef _LP64
77 if (UseCompressedOops) {
78 __ movl(dst, (int32_t)NULL_WORD);
79 } else {
80 __ movslq(dst, (int32_t)NULL_WORD);
81 }
82 #else
83 __ movl(dst, (int32_t)NULL_WORD);
84 #endif
85 } else {
86 #ifdef _LP64
87 if (UseCompressedOops) {
88 assert(!dst.uses(val), "not enough registers");
89 if (oop_not_null) {
90 __ encode_heap_oop_not_null(val);
91 } else {
92 __ encode_heap_oop(val);
93 }
94 __ movl(dst, val);
95 } else
96 #endif
97 {
98 __ movptr(dst, val);
99 }
100 }
101 } else {
102 assert(on_root, "why else?");
103 assert(val != noreg, "not supported");
104 __ movptr(dst, val);
105 }
106 break;
107 }
108 default: Unimplemented();
109 }
110 }
111
112 void BarrierSetAssembler::obj_equals(MacroAssembler* masm, DecoratorSet decorators, Register src1, Register src2) {
113 __ cmpptr(src1, src2);
114 }
115
116 void BarrierSetAssembler::obj_equals_addr(MacroAssembler* masm, DecoratorSet decorators, Register src1, Address src2) {
117 __ cmpptr(src1, src2);
118 }
119
120 void BarrierSetAssembler::resolve_for_read(MacroAssembler* masm, DecoratorSet decorators, Register obj) {
121 // Default to no-op
122 }
123
124 void BarrierSetAssembler::resolve_for_write(MacroAssembler* masm, DecoratorSet decorators, Register obj) {
125 // Default to no-op
126 }
|
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "gc/shared/barrierSetAssembler.hpp"
27 #include "interpreter/interp_masm.hpp"
28
29 #define __ masm->
30
31 void BarrierSetAssembler::load_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type,
32 Register dst, Address src, Register tmp1, Register tmp_thread) {
33 bool on_heap = (decorators & IN_HEAP) != 0;
34 bool on_root = (decorators & IN_ROOT) != 0;
35 bool oop_not_null = (decorators & OOP_NOT_NULL) != 0;
36 bool atomic = (decorators & MO_RELAXED) != 0;
37
38 switch (type) {
39 case T_OBJECT:
40 case T_ARRAY: {
41 if (on_heap) {
42 #ifdef _LP64
43 if (UseCompressedOops) {
44 __ movl(dst, src);
45 if (oop_not_null) {
46 __ decode_heap_oop_not_null(dst);
47 } else {
48 __ decode_heap_oop(dst);
49 }
50 } else
51 #endif
52 {
53 __ movptr(dst, src);
54 }
55 } else {
56 assert(on_root, "why else?");
57 __ movptr(dst, src);
58 }
59 break;
60 }
61 case T_BOOLEAN: __ load_unsigned_byte(dst, src); break;
62 case T_BYTE: __ load_signed_byte(dst, src); break;
63 case T_CHAR: __ load_unsigned_short(dst, src); break;
64 case T_SHORT: __ load_signed_short(dst, src); break;
65 case T_INT: __ movl (dst, src); break;
66 case T_ADDRESS: __ movptr(dst, src); break;
67 case T_FLOAT:
68 assert(dst == noreg, "only to ftos");
69 __ load_float(src);
70 break;
71 case T_DOUBLE:
72 assert(dst == noreg, "only to dtos");
73 __ load_double(src);
74 break;
75 case T_LONG:
76 assert(dst == noreg, "only to ltos");
77 #ifdef _LP64
78 __ movq(rax, src);
79 #else
80 if (atomic) {
81 __ fild_d(src); // Must load atomically
82 __ subptr(rsp,2*wordSize); // Make space for store
83 __ fistp_d(Address(rsp,0));
84 __ pop(rax);
85 __ pop(rdx);
86 } else {
87 __ movl(rax, src);
88 __ movl(rdx, src.plus_disp(wordSize));
89 }
90 #endif
91 break;
92 default: Unimplemented();
93 }
94 }
95
96 void BarrierSetAssembler::store_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type,
97 Address dst, Register val, Register tmp1, Register tmp2) {
98 bool on_heap = (decorators & IN_HEAP) != 0;
99 bool on_root = (decorators & IN_ROOT) != 0;
100 bool oop_not_null = (decorators & OOP_NOT_NULL) != 0;
101 bool atomic = (decorators & MO_RELAXED) != 0;
102
103 switch (type) {
104 case T_OBJECT:
105 case T_ARRAY: {
106 if (on_heap) {
107 if (val == noreg) {
108 assert(!oop_not_null, "inconsistent access");
109 #ifdef _LP64
110 if (UseCompressedOops) {
111 __ movl(dst, (int32_t)NULL_WORD);
112 } else {
113 __ movslq(dst, (int32_t)NULL_WORD);
114 }
115 #else
116 __ movl(dst, (int32_t)NULL_WORD);
117 #endif
118 } else {
119 #ifdef _LP64
120 if (UseCompressedOops) {
121 assert(!dst.uses(val), "not enough registers");
122 if (oop_not_null) {
123 __ encode_heap_oop_not_null(val);
124 } else {
125 __ encode_heap_oop(val);
126 }
127 __ movl(dst, val);
128 } else
129 #endif
130 {
131 __ movptr(dst, val);
132 }
133 }
134 } else {
135 assert(on_root, "why else?");
136 assert(val != noreg, "not supported");
137 __ movptr(dst, val);
138 }
139 break;
140 }
141 case T_BOOLEAN:
142 __ andl(val, 0x1); // boolean is true if LSB is 1
143 __ movb(dst, val);
144 break;
145 case T_BYTE:
146 __ movb(dst, val);
147 break;
148 case T_SHORT:
149 __ movw(dst, val);
150 break;
151 case T_CHAR:
152 __ movw(dst, val);
153 break;
154 case T_INT:
155 __ movl(dst, val);
156 break;
157 case T_LONG:
158 assert(val == noreg, "only tos");
159 #ifdef _LP64
160 __ movq(dst, rax);
161 #else
162 if (atomic) {
163 __ push(rdx);
164 __ push(rax); // Must update atomically with FIST
165 __ fild_d(Address(rsp,0)); // So load into FPU register
166 __ fistp_d(dst); // and put into memory atomically
167 __ addptr(rsp, 2*wordSize);
168 } else {
169 __ movptr(dst, rax);
170 __ movptr(dst.plus_disp(wordSize), rdx);
171 }
172 #endif
173 break;
174 case T_FLOAT:
175 assert(val == noreg, "only tos");
176 __ store_float(dst);
177 break;
178 case T_DOUBLE:
179 assert(val == noreg, "only tos");
180 __ store_double(dst);
181 break;
182 default: Unimplemented();
183 }
184 }
185
186 void BarrierSetAssembler::obj_equals(MacroAssembler* masm, DecoratorSet decorators, Register src1, Register src2) {
187 __ cmpptr(src1, src2);
188 }
189
190 void BarrierSetAssembler::obj_equals_addr(MacroAssembler* masm, DecoratorSet decorators, Register src1, Address src2) {
191 __ cmpptr(src1, src2);
192 }
193
194 void BarrierSetAssembler::resolve_for_read(MacroAssembler* masm, DecoratorSet decorators, Register obj) {
195 // Default to no-op
196 }
197
198 void BarrierSetAssembler::resolve_for_write(MacroAssembler* masm, DecoratorSet decorators, Register obj) {
199 // Default to no-op
200 }
|