Mercurial > hg > truffle

comparison src/share/vm/opto/parse3.cpp @ 14429:2113136690bc

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8024921: PPC64 (part 113): Extend Load and Store nodes to know about memory ordering Summary: Add a field to C2 LoadNode and StoreNode classes which indicates whether the load/store should do an acquire/release on platforms which support it. Reviewed-by: kvn
author goetz
date Fri, 15 Nov 2013 11:05:32 -0800
parents edb5ab0f3fe5
children c6d7e7406136
comparison
equal deleted inserted replaced
14427:eb178e97560c 14429:2113136690bc
226 } 226 }
227 } else { 227 } else {
228 type = Type::get_const_basic_type(bt); 228 type = Type::get_const_basic_type(bt);
229 } 229 }
230 // Build the load. 230 // Build the load.
231 Node* ld = make_load(NULL, adr, type, bt, adr_type, is_vol); 231 //
232 MemNode::MemOrd mo = is_vol ? MemNode::acquire : MemNode::unordered;
233 Node* ld = make_load(NULL, adr, type, bt, adr_type, mo, is_vol);
232 234
233 // Adjust Java stack 235 // Adjust Java stack
234 if (type2size[bt] == 1) 236 if (type2size[bt] == 1)
235 push(ld); 237 push(ld);
236 else 238 else
286 // Value to be stored 288 // Value to be stored
287 Node* val = type2size[bt] == 1 ? pop() : pop_pair(); 289 Node* val = type2size[bt] == 1 ? pop() : pop_pair();
288 // Round doubles before storing 290 // Round doubles before storing
289 if (bt == T_DOUBLE) val = dstore_rounding(val); 291 if (bt == T_DOUBLE) val = dstore_rounding(val);
290 292
293 // Conservatively release stores of object references.
294 const MemNode::MemOrd mo =
295 is_vol ?
296 // Volatile fields need releasing stores.
297 MemNode::release :
298 // Non-volatile fields also need releasing stores if they hold an
299 // object reference, because the object reference might point to
300 // a freshly created object.
301 StoreNode::release_if_reference(bt);
302
291 // Store the value. 303 // Store the value.
292 Node* store; 304 Node* store;
293 if (bt == T_OBJECT) { 305 if (bt == T_OBJECT) {
294 const TypeOopPtr* field_type; 306 const TypeOopPtr* field_type;
295 if (!field->type()->is_loaded()) { 307 if (!field->type()->is_loaded()) {
296 field_type = TypeInstPtr::BOTTOM; 308 field_type = TypeInstPtr::BOTTOM;
297 } else { 309 } else {
298 field_type = TypeOopPtr::make_from_klass(field->type()->as_klass()); 310 field_type = TypeOopPtr::make_from_klass(field->type()->as_klass());
299 } 311 }
300 store = store_oop_to_object( control(), obj, adr, adr_type, val, field_type, bt); 312 store = store_oop_to_object(control(), obj, adr, adr_type, val, field_type, bt, mo);
301 } else { 313 } else {
302 store = store_to_memory( control(), adr, val, bt, adr_type, is_vol ); 314 store = store_to_memory(control(), adr, val, bt, adr_type, mo, is_vol);
303 } 315 }
304 316
305 // If reference is volatile, prevent following volatiles ops from 317 // If reference is volatile, prevent following volatiles ops from
306 // floating up before the volatile write. 318 // floating up before the volatile write.
307 if (is_vol) { 319 if (is_vol) {
412 const intptr_t header = arrayOopDesc::base_offset_in_bytes(T_OBJECT); 424 const intptr_t header = arrayOopDesc::base_offset_in_bytes(T_OBJECT);
413 for (jint i = 0; i < length_con; i++) { 425 for (jint i = 0; i < length_con; i++) {
414 Node* elem = expand_multianewarray(array_klass_1, &lengths[1], ndimensions-1, nargs); 426 Node* elem = expand_multianewarray(array_klass_1, &lengths[1], ndimensions-1, nargs);
415 intptr_t offset = header + ((intptr_t)i << LogBytesPerHeapOop); 427 intptr_t offset = header + ((intptr_t)i << LogBytesPerHeapOop);
416 Node* eaddr = basic_plus_adr(array, offset); 428 Node* eaddr = basic_plus_adr(array, offset);
417 store_oop_to_array(control(), array, eaddr, adr_type, elem, elemtype, T_OBJECT); 429 store_oop_to_array(control(), array, eaddr, adr_type, elem, elemtype, T_OBJECT, MemNode::unordered);
418 } 430 }
419 } 431 }
420 return array; 432 return array;
421 } 433 }
422 434
501 dims = new_array(dims_array_klass, intcon(ndimensions), 0); 513 dims = new_array(dims_array_klass, intcon(ndimensions), 0);
502 514
503 // Fill-in it with values 515 // Fill-in it with values
504 for (j = 0; j < ndimensions; j++) { 516 for (j = 0; j < ndimensions; j++) {
505 Node *dims_elem = array_element_address(dims, intcon(j), T_INT); 517 Node *dims_elem = array_element_address(dims, intcon(j), T_INT);
506 store_to_memory(control(), dims_elem, length[j], T_INT, TypeAryPtr::INTS); 518 store_to_memory(control(), dims_elem, length[j], T_INT, TypeAryPtr::INTS, MemNode::unordered);
507 } 519 }
508 } 520 }
509 521
510 c = make_runtime_call(RC_NO_LEAF | RC_NO_IO, 522 c = make_runtime_call(RC_NO_LEAF | RC_NO_IO,
511 OptoRuntime::multianewarrayN_Type(), 523 OptoRuntime::multianewarrayN_Type(),