< prev index next >
src/hotspot/share/opto/library_call.cpp
Print this page
rev 51739 : 8210752: Remaining explicit barriers for C2
@@ -242,11 +242,11 @@
bool inline_min_max(vmIntrinsics::ID id);
bool inline_notify(vmIntrinsics::ID id);
Node* generate_min_max(vmIntrinsics::ID id, Node* x, Node* y);
// This returns Type::AnyPtr, RawPtr, or OopPtr.
int classify_unsafe_addr(Node* &base, Node* &offset, BasicType type);
- Node* make_unsafe_address(Node*& base, Node* offset, BasicType type = T_ILLEGAL, bool can_cast = false);
+ Node* make_unsafe_address(Node*& base, Node* offset, DecoratorSet decorators, BasicType type = T_ILLEGAL, bool can_cast = false);
typedef enum { Relaxed, Opaque, Volatile, Acquire, Release } AccessKind;
DecoratorSet mo_decorator_for_access_kind(AccessKind kind);
bool inline_unsafe_access(bool is_store, BasicType type, AccessKind kind, bool is_unaligned);
static bool klass_needs_init_guard(Node* kls);
@@ -1682,11 +1682,11 @@
return true;
}
if (!stopped()) {
src = access_resolve(src, ACCESS_READ);
- dst = access_resolve(dst, ACCESS_READ);
+ dst = access_resolve(dst, ACCESS_WRITE);
// Calculate starting addresses.
Node* src_start = array_element_address(src, src_begin, T_BYTE);
Node* dst_start = array_element_address(dst, dst_begin, T_CHAR);
@@ -2191,11 +2191,11 @@
// No information:
return Type::AnyPtr;
}
}
-inline Node* LibraryCallKit::make_unsafe_address(Node*& base, Node* offset, BasicType type, bool can_cast) {
+inline Node* LibraryCallKit::make_unsafe_address(Node*& base, Node* offset, DecoratorSet decorators, BasicType type, bool can_cast) {
Node* uncasted_base = base;
int kind = classify_unsafe_addr(uncasted_base, offset, type);
if (kind == Type::RawPtr) {
return basic_plus_adr(top(), uncasted_base, offset);
} else if (kind == Type::AnyPtr) {
@@ -2220,10 +2220,11 @@
return basic_plus_adr(top(), raw_base, offset);
}
}
// We don't know if it's an on heap or off heap access. Fall back
// to raw memory access.
+ base = access_resolve(base, decorators);
Node* raw = _gvn.transform(new CheckCastPPNode(control(), base, TypeRawPtr::BOTTOM));
return basic_plus_adr(top(), raw, offset);
} else {
assert(base == uncasted_base, "unexpected base change");
// We know it's an on heap access so base can't be null
@@ -2386,11 +2387,11 @@
// by oopDesc::field_addr.
assert(Unsafe_field_offset_to_byte_offset(11) == 11,
"fieldOffset must be byte-scaled");
// 32-bit machines ignore the high half!
offset = ConvL2X(offset);
- adr = make_unsafe_address(base, offset, type, kind == Relaxed);
+ adr = make_unsafe_address(base, offset, is_store ? ACCESS_WRITE : ACCESS_READ, type, kind == Relaxed);
if (_gvn.type(base)->isa_ptr() != TypePtr::NULL_PTR) {
heap_base_oop = base;
} else if (type == T_OBJECT) {
return false; // off-heap oop accesses are not supported
@@ -2670,11 +2671,11 @@
// to be plain byte offsets, which are also the same as those accepted
// by oopDesc::field_addr.
assert(Unsafe_field_offset_to_byte_offset(11) == 11, "fieldOffset must be byte-scaled");
// 32-bit machines ignore the high half of long offsets
offset = ConvL2X(offset);
- Node* adr = make_unsafe_address(base, offset, type, false);
+ Node* adr = make_unsafe_address(base, offset, ACCESS_WRITE | ACCESS_READ, type, false);
const TypePtr *adr_type = _gvn.type(adr)->isa_ptr();
Compile::AliasType* alias_type = C->alias_type(adr_type);
BasicType bt = alias_type->basic_type();
if (bt != T_ILLEGAL &&
@@ -2965,10 +2966,15 @@
// (a) Receiving thread must be the current thread.
Node* rec_thr = argument(0);
Node* tls_ptr = NULL;
Node* cur_thr = generate_current_thread(tls_ptr);
+
+ // Resolve oops to stable for CmpP below.
+ cur_thr = access_resolve(cur_thr, 0);
+ rec_thr = access_resolve(rec_thr, 0);
+
Node* cmp_thr = _gvn.transform(new CmpPNode(cur_thr, rec_thr));
Node* bol_thr = _gvn.transform(new BoolNode(cmp_thr, BoolTest::ne));
generate_slow_guard(bol_thr, slow_region);
@@ -3399,10 +3405,14 @@
Node* p = basic_plus_adr(arg, class_klass_offset);
Node* kls = LoadKlassNode::make(_gvn, NULL, immutable_memory(), p, adr_type, kls_type);
klasses[which_arg] = _gvn.transform(kls);
}
+ // Resolve oops to stable for CmpP below.
+ args[0] = access_resolve(args[0], 0);
+ args[1] = access_resolve(args[1], 0);
+
// Having loaded both klasses, test each for null.
bool never_see_null = !too_many_traps(Deoptimization::Reason_null_check);
for (which_arg = 0; which_arg <= 1; which_arg++) {
Node* kls = klasses[which_arg];
Node* null_ctl = top();
@@ -4176,12 +4186,14 @@
Node* size = ConvL2X(argument(7)); // type: long
assert(Unsafe_field_offset_to_byte_offset(11) == 11,
"fieldOffset must be byte-scaled");
- Node* src = make_unsafe_address(src_ptr, src_off);
- Node* dst = make_unsafe_address(dst_ptr, dst_off);
+ src_ptr = access_resolve(src_ptr, ACCESS_READ);
+ dst_ptr = access_resolve(dst_ptr, ACCESS_WRITE);
+ Node* src = make_unsafe_address(src_ptr, src_off, ACCESS_READ);
+ Node* dst = make_unsafe_address(dst_ptr, dst_off, ACCESS_WRITE);
// Conservatively insert a memory barrier on all memory slices.
// Do not let writes of the copy source or destination float below the copy.
insert_mem_bar(Op_MemBarCPUOrder);
@@ -5332,12 +5344,14 @@
}
Node* call;
jvms()->set_should_reexecute(true);
- Node* obja_adr = make_unsafe_address(obja, aoffset);
- Node* objb_adr = make_unsafe_address(objb, boffset);
+ obja = access_resolve(obja, ACCESS_READ);
+ objb = access_resolve(objb, ACCESS_READ);
+ Node* obja_adr = make_unsafe_address(obja, aoffset, ACCESS_READ);
+ Node* objb_adr = make_unsafe_address(objb, boffset, ACCESS_READ);
call = make_runtime_call(RC_LEAF,
OptoRuntime::vectorizedMismatch_Type(),
stubAddr, stubName, TypePtr::BOTTOM,
obja_adr, objb_adr, length, scale);
@@ -6115,10 +6129,14 @@
}
src = must_be_not_null(src, true);
dest = must_be_not_null(dest, true);
+ // Resolve oops to stable for CmpP below.
+ src = access_resolve(src, 0);
+ dest = access_resolve(dest, 0);
+
ciInstanceKlass* instklass_AESCrypt = klass_AESCrypt->as_instance_klass();
Node* instof = gen_instanceof(embeddedCipherObj, makecon(TypeKlassPtr::make(instklass_AESCrypt)));
Node* cmp_instof = _gvn.transform(new CmpINode(instof, intcon(1)));
Node* bool_instof = _gvn.transform(new BoolNode(cmp_instof, BoolTest::ne));
< prev index next >