145 }
146
147
148 void Parse::do_get_xxx(Node* obj, ciField* field, bool is_field) {
149 // Does this field have a constant value? If so, just push the value.
150 if (field->is_constant()) {
151 // final or stable field
152 const Type* con_type = Type::make_constant(field, obj);
153 if (con_type != NULL) {
154 push_node(con_type->basic_type(), makecon(con_type));
155 return;
156 }
157 }
158
159 ciType* field_klass = field->type();
160 bool is_vol = field->is_volatile();
161
162 // Compute address and memory type.
163 int offset = field->offset_in_bytes();
164 const TypePtr* adr_type = C->alias_type(field)->adr_type();
165 Node *adr = basic_plus_adr(obj, obj, offset);
166 BasicType bt = field->layout_type();
167
168 // Build the resultant type of the load
169 const Type *type;
170
171 bool must_assert_null = false;
172
173 if( bt == T_OBJECT ) {
174 if (!field->type()->is_loaded()) {
175 type = TypeInstPtr::BOTTOM;
176 must_assert_null = true;
177 } else if (field->is_constant() && field->is_static()) {
178 // This can happen if the constant oop is non-perm.
179 ciObject* con = field->constant_value().as_object();
180 // Do not "join" in the previous type; it doesn't add value,
181 // and may yield a vacuous result if the field is of interface type.
182 type = TypeOopPtr::make_from_constant(con)->isa_oopptr();
183 assert(type != NULL, "field singleton type must be consistent");
184 } else {
227 null_assert(peek());
228 set_bci(iter().cur_bci()); // put it back
229 }
230
231 // If reference is volatile, prevent following memory ops from
232 // floating up past the volatile read. Also prevents commoning
233 // another volatile read.
234 if (field->is_volatile()) {
235 // Memory barrier includes bogus read of value to force load BEFORE membar
236 insert_mem_bar(Op_MemBarAcquire, ld);
237 }
238 }
239
240 void Parse::do_put_xxx(Node* obj, ciField* field, bool is_field) {
241 bool is_vol = field->is_volatile();
242 // If reference is volatile, prevent following memory ops from
243 // floating down past the volatile write. Also prevents commoning
244 // another volatile read.
245 if (is_vol) insert_mem_bar(Op_MemBarRelease);
246
247 // Compute address and memory type.
248 int offset = field->offset_in_bytes();
249 const TypePtr* adr_type = C->alias_type(field)->adr_type();
250 Node* adr = basic_plus_adr(obj, obj, offset);
251 BasicType bt = field->layout_type();
252 // Value to be stored
253 Node* val = type2size[bt] == 1 ? pop() : pop_pair();
254 // Round doubles before storing
255 if (bt == T_DOUBLE) val = dstore_rounding(val);
256
257 // Conservatively release stores of object references.
258 const MemNode::MemOrd mo =
259 is_vol ?
260 // Volatile fields need releasing stores.
261 MemNode::release :
262 // Non-volatile fields also need releasing stores if they hold an
263 // object reference, because the object reference might point to
264 // a freshly created object.
265 StoreNode::release_if_reference(bt);
266
267 // Store the value.
268 Node* store;
269 if (bt == T_OBJECT) {
270 const TypeOopPtr* field_type;
271 if (!field->type()->is_loaded()) {
272 field_type = TypeInstPtr::BOTTOM;
273 } else {
274 field_type = TypeOopPtr::make_from_klass(field->type()->as_klass());
275 }
276 store = store_oop_to_object(control(), obj, adr, adr_type, val, field_type, bt, mo);
277 } else {
278 bool needs_atomic_access = is_vol || AlwaysAtomicAccesses;
279 store = store_to_memory(control(), adr, val, bt, adr_type, mo, needs_atomic_access);
280 }
281
282 // If reference is volatile, prevent following volatiles ops from
283 // floating up before the volatile write.
284 if (is_vol) {
285 // If not multiple copy atomic, we do the MemBarVolatile before the load.
286 if (!support_IRIW_for_not_multiple_copy_atomic_cpu) {
287 insert_mem_bar(Op_MemBarVolatile); // Use fat membar
288 }
289 // Remember we wrote a volatile field.
290 // For not multiple copy atomic cpu (ppc64) a barrier should be issued
291 // in constructors which have such stores. See do_exits() in parse1.cpp.
292 if (is_field) {
293 set_wrote_volatile(true);
294 }
295 }
|
145 }
146
147
148 void Parse::do_get_xxx(Node* obj, ciField* field, bool is_field) {
149 // Does this field have a constant value? If so, just push the value.
150 if (field->is_constant()) {
151 // final or stable field
152 const Type* con_type = Type::make_constant(field, obj);
153 if (con_type != NULL) {
154 push_node(con_type->basic_type(), makecon(con_type));
155 return;
156 }
157 }
158
159 ciType* field_klass = field->type();
160 bool is_vol = field->is_volatile();
161
162 // Compute address and memory type.
163 int offset = field->offset_in_bytes();
164 const TypePtr* adr_type = C->alias_type(field)->adr_type();
165
166 // Insert read barrier for Shenandoah.
167 obj = shenandoah_read_barrier(obj);
168
169 Node *adr = basic_plus_adr(obj, obj, offset);
170 BasicType bt = field->layout_type();
171
172 // Build the resultant type of the load
173 const Type *type;
174
175 bool must_assert_null = false;
176
177 if( bt == T_OBJECT ) {
178 if (!field->type()->is_loaded()) {
179 type = TypeInstPtr::BOTTOM;
180 must_assert_null = true;
181 } else if (field->is_constant() && field->is_static()) {
182 // This can happen if the constant oop is non-perm.
183 ciObject* con = field->constant_value().as_object();
184 // Do not "join" in the previous type; it doesn't add value,
185 // and may yield a vacuous result if the field is of interface type.
186 type = TypeOopPtr::make_from_constant(con)->isa_oopptr();
187 assert(type != NULL, "field singleton type must be consistent");
188 } else {
231 null_assert(peek());
232 set_bci(iter().cur_bci()); // put it back
233 }
234
235 // If reference is volatile, prevent following memory ops from
236 // floating up past the volatile read. Also prevents commoning
237 // another volatile read.
238 if (field->is_volatile()) {
239 // Memory barrier includes bogus read of value to force load BEFORE membar
240 insert_mem_bar(Op_MemBarAcquire, ld);
241 }
242 }
243
244 void Parse::do_put_xxx(Node* obj, ciField* field, bool is_field) {
245 bool is_vol = field->is_volatile();
246 // If reference is volatile, prevent following memory ops from
247 // floating down past the volatile write. Also prevents commoning
248 // another volatile read.
249 if (is_vol) insert_mem_bar(Op_MemBarRelease);
250
251 // Insert write barrier for Shenandoah.
252 obj = shenandoah_write_barrier(obj);
253
254 // Compute address and memory type.
255 int offset = field->offset_in_bytes();
256 const TypePtr* adr_type = C->alias_type(field)->adr_type();
257 Node* adr = basic_plus_adr(obj, obj, offset);
258 BasicType bt = field->layout_type();
259 // Value to be stored
260 Node* val = type2size[bt] == 1 ? pop() : pop_pair();
261 // Round doubles before storing
262 if (bt == T_DOUBLE) val = dstore_rounding(val);
263
264 // Conservatively release stores of object references.
265 const MemNode::MemOrd mo =
266 is_vol ?
267 // Volatile fields need releasing stores.
268 MemNode::release :
269 // Non-volatile fields also need releasing stores if they hold an
270 // object reference, because the object reference might point to
271 // a freshly created object.
272 StoreNode::release_if_reference(bt);
273
274 // Store the value.
275 Node* store;
276 if (bt == T_OBJECT) {
277 const TypeOopPtr* field_type;
278 if (!field->type()->is_loaded()) {
279 field_type = TypeInstPtr::BOTTOM;
280 } else {
281 field_type = TypeOopPtr::make_from_klass(field->type()->as_klass());
282 }
283
284 val = shenandoah_read_barrier_nomem(val);
285
286 store = store_oop_to_object(control(), obj, adr, adr_type, val, field_type, bt, mo);
287 } else {
288 bool needs_atomic_access = is_vol || AlwaysAtomicAccesses;
289 store = store_to_memory(control(), adr, val, bt, adr_type, mo, needs_atomic_access);
290 }
291
292 // If reference is volatile, prevent following volatiles ops from
293 // floating up before the volatile write.
294 if (is_vol) {
295 // If not multiple copy atomic, we do the MemBarVolatile before the load.
296 if (!support_IRIW_for_not_multiple_copy_atomic_cpu) {
297 insert_mem_bar(Op_MemBarVolatile); // Use fat membar
298 }
299 // Remember we wrote a volatile field.
300 // For not multiple copy atomic cpu (ppc64) a barrier should be issued
301 // in constructors which have such stores. See do_exits() in parse1.cpp.
302 if (is_field) {
303 set_wrote_volatile(true);
304 }
305 }
|