8218879: Keep track of memory accesses originated from Unsafe
Reviewed-by: thartmann
--- a/src/hotspot/share/c1/c1_Decorators.hpp Thu Feb 14 15:27:12 2019 -0800
+++ b/src/hotspot/share/c1/c1_Decorators.hpp Thu Feb 14 15:27:12 2019 -0800
@@ -34,5 +34,7 @@
// Use the C1_MASK_BOOLEAN decorator for boolean accesses where the value
// needs to be masked.
const DecoratorSet C1_MASK_BOOLEAN = DECORATOR_LAST << 2;
+// Use the C1_UNSAFE_ACCESS decorator to mark unsafe accesses.
+const DecoratorSet C1_UNSAFE_ACCESS = DECORATOR_LAST << 3;
#endif // SHARE_C1_C1_DECORATORS_HPP
--- a/src/hotspot/share/c1/c1_LIRGenerator.cpp Thu Feb 14 15:27:12 2019 -0800
+++ b/src/hotspot/share/c1/c1_LIRGenerator.cpp Thu Feb 14 15:27:12 2019 -0800
@@ -2161,7 +2161,7 @@
off.load_item();
src.load_item();
- DecoratorSet decorators = IN_HEAP;
+ DecoratorSet decorators = IN_HEAP | C1_UNSAFE_ACCESS;
if (x->is_volatile()) {
decorators |= MO_SEQ_CST;
@@ -2195,7 +2195,7 @@
set_no_result(x);
- DecoratorSet decorators = IN_HEAP;
+ DecoratorSet decorators = IN_HEAP | C1_UNSAFE_ACCESS;
if (type == T_ARRAY || type == T_OBJECT) {
decorators |= ON_UNKNOWN_OOP_REF;
}
@@ -2211,7 +2211,7 @@
LIRItem off(x->offset(), this);
LIRItem value(x->value(), this);
- DecoratorSet decorators = IN_HEAP | MO_SEQ_CST;
+ DecoratorSet decorators = IN_HEAP | C1_UNSAFE_ACCESS | MO_SEQ_CST;
if (type == T_ARRAY || type == T_OBJECT) {
decorators |= ON_UNKNOWN_OOP_REF;
--- a/src/hotspot/share/gc/shared/c2/barrierSetC2.cpp Thu Feb 14 15:27:12 2019 -0800
+++ b/src/hotspot/share/gc/shared/c2/barrierSetC2.cpp Thu Feb 14 15:27:12 2019 -0800
@@ -75,6 +75,7 @@
bool mismatched = (decorators & C2_MISMATCHED) != 0;
bool unaligned = (decorators & C2_UNALIGNED) != 0;
+ bool unsafe = (decorators & C2_UNSAFE_ACCESS) != 0;
bool requires_atomic_access = (decorators & MO_UNORDERED) == 0;
bool in_native = (decorators & IN_NATIVE) != 0;
@@ -93,7 +94,7 @@
}
store = kit->store_to_memory(kit->control(), access.addr().node(), val.node(), access.type(),
- access.addr().type(), mo, requires_atomic_access, unaligned, mismatched);
+ access.addr().type(), mo, requires_atomic_access, unaligned, mismatched, unsafe);
access.set_raw_access(store);
} else {
assert(!requires_atomic_access, "not yet supported");
@@ -132,6 +133,7 @@
bool unaligned = (decorators & C2_UNALIGNED) != 0;
bool control_dependent = (decorators & C2_CONTROL_DEPENDENT_LOAD) != 0;
bool pinned = (decorators & C2_PINNED_LOAD) != 0;
+ bool unsafe = (decorators & C2_UNSAFE_ACCESS) != 0;
bool in_native = (decorators & IN_NATIVE) != 0;
@@ -148,7 +150,7 @@
load = kit->make_load(control, adr, val_type, access.type(), mo);
} else {
load = kit->make_load(control, adr, val_type, access.type(), adr_type, mo,
- dep, requires_atomic_access, unaligned, mismatched);
+ dep, requires_atomic_access, unaligned, mismatched, unsafe);
}
access.set_raw_access(load);
} else {
--- a/src/hotspot/share/opto/graphKit.cpp Thu Feb 14 15:27:12 2019 -0800
+++ b/src/hotspot/share/opto/graphKit.cpp Thu Feb 14 15:27:12 2019 -0800
@@ -1489,18 +1489,19 @@
LoadNode::ControlDependency control_dependency,
bool require_atomic_access,
bool unaligned,
- bool mismatched) {
+ bool mismatched,
+ bool unsafe) {
assert(adr_idx != Compile::AliasIdxTop, "use other make_load factory" );
const TypePtr* adr_type = NULL; // debug-mode-only argument
debug_only(adr_type = C->get_adr_type(adr_idx));
Node* mem = memory(adr_idx);
Node* ld;
if (require_atomic_access && bt == T_LONG) {
- ld = LoadLNode::make_atomic(ctl, mem, adr, adr_type, t, mo, control_dependency, unaligned, mismatched);
+ ld = LoadLNode::make_atomic(ctl, mem, adr, adr_type, t, mo, control_dependency, unaligned, mismatched, unsafe);
} else if (require_atomic_access && bt == T_DOUBLE) {
- ld = LoadDNode::make_atomic(ctl, mem, adr, adr_type, t, mo, control_dependency, unaligned, mismatched);
+ ld = LoadDNode::make_atomic(ctl, mem, adr, adr_type, t, mo, control_dependency, unaligned, mismatched, unsafe);
} else {
- ld = LoadNode::make(_gvn, ctl, mem, adr, adr_type, t, bt, mo, control_dependency, unaligned, mismatched);
+ ld = LoadNode::make(_gvn, ctl, mem, adr, adr_type, t, bt, mo, control_dependency, unaligned, mismatched, unsafe);
}
ld = _gvn.transform(ld);
if (((bt == T_OBJECT) && C->do_escape_analysis()) || C->eliminate_boxing()) {
@@ -1515,7 +1516,8 @@
MemNode::MemOrd mo,
bool require_atomic_access,
bool unaligned,
- bool mismatched) {
+ bool mismatched,
+ bool unsafe) {
assert(adr_idx != Compile::AliasIdxTop, "use other store_to_memory factory" );
const TypePtr* adr_type = NULL;
debug_only(adr_type = C->get_adr_type(adr_idx));
@@ -1534,6 +1536,9 @@
if (mismatched) {
st->as_Store()->set_mismatched_access();
}
+ if (unsafe) {
+ st->as_Store()->set_unsafe_access();
+ }
st = _gvn.transform(st);
set_memory(st, adr_idx);
// Back-to-back stores can only remove intermediate store with DU info
--- a/src/hotspot/share/opto/graphKit.hpp Thu Feb 14 15:27:12 2019 -0800
+++ b/src/hotspot/share/opto/graphKit.hpp Thu Feb 14 15:27:12 2019 -0800
@@ -518,27 +518,27 @@
Node* make_load(Node* ctl, Node* adr, const Type* t, BasicType bt,
MemNode::MemOrd mo, LoadNode::ControlDependency control_dependency = LoadNode::DependsOnlyOnTest,
bool require_atomic_access = false, bool unaligned = false,
- bool mismatched = false) {
+ bool mismatched = false, bool unsafe = false) {
// This version computes alias_index from bottom_type
return make_load(ctl, adr, t, bt, adr->bottom_type()->is_ptr(),
mo, control_dependency, require_atomic_access,
- unaligned, mismatched);
+ unaligned, mismatched, unsafe);
}
Node* make_load(Node* ctl, Node* adr, const Type* t, BasicType bt, const TypePtr* adr_type,
MemNode::MemOrd mo, LoadNode::ControlDependency control_dependency = LoadNode::DependsOnlyOnTest,
bool require_atomic_access = false, bool unaligned = false,
- bool mismatched = false) {
+ bool mismatched = false, bool unsafe = false) {
// This version computes alias_index from an address type
assert(adr_type != NULL, "use other make_load factory");
return make_load(ctl, adr, t, bt, C->get_alias_index(adr_type),
mo, control_dependency, require_atomic_access,
- unaligned, mismatched);
+ unaligned, mismatched, unsafe);
}
// This is the base version which is given an alias index.
Node* make_load(Node* ctl, Node* adr, const Type* t, BasicType bt, int adr_idx,
MemNode::MemOrd mo, LoadNode::ControlDependency control_dependency = LoadNode::DependsOnlyOnTest,
bool require_atomic_access = false, bool unaligned = false,
- bool mismatched = false);
+ bool mismatched = false, bool unsafe = false);
// Create & transform a StoreNode and store the effect into the
// parser's memory state.
@@ -553,7 +553,8 @@
MemNode::MemOrd mo,
bool require_atomic_access = false,
bool unaligned = false,
- bool mismatched = false) {
+ bool mismatched = false,
+ bool unsafe = false) {
// This version computes alias_index from an address type
assert(adr_type != NULL, "use other store_to_memory factory");
return store_to_memory(ctl, adr, val, bt,
@@ -568,7 +569,8 @@
MemNode::MemOrd,
bool require_atomic_access = false,
bool unaligned = false,
- bool mismatched = false);
+ bool mismatched = false,
+ bool unsafe = false);
// Perform decorated accesses
--- a/src/hotspot/share/opto/memnode.cpp Thu Feb 14 15:27:12 2019 -0800
+++ b/src/hotspot/share/opto/memnode.cpp Thu Feb 14 15:27:12 2019 -0800
@@ -99,6 +99,9 @@
if (_mismatched_access) {
st->print(" mismatched");
}
+ if (_unsafe_access) {
+ st->print(" unsafe");
+ }
}
void MemNode::dump_adr_type(const Node* mem, const TypePtr* adr_type, outputStream *st) {
@@ -789,7 +792,7 @@
//----------------------------LoadNode::make-----------------------------------
// Polymorphic factory method:
Node *LoadNode::make(PhaseGVN& gvn, Node *ctl, Node *mem, Node *adr, const TypePtr* adr_type, const Type *rt, BasicType bt, MemOrd mo,
- ControlDependency control_dependency, bool unaligned, bool mismatched) {
+ ControlDependency control_dependency, bool unaligned, bool mismatched, bool unsafe) {
Compile* C = gvn.C;
// sanity check the alias category against the created node type
@@ -837,6 +840,9 @@
if (mismatched) {
load->set_mismatched_access();
}
+ if (unsafe) {
+ load->set_unsafe_access();
+ }
if (load->Opcode() == Op_LoadN) {
Node* ld = gvn.transform(load);
return new DecodeNNode(ld, ld->bottom_type()->make_ptr());
@@ -846,7 +852,7 @@
}
LoadLNode* LoadLNode::make_atomic(Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, const Type* rt, MemOrd mo,
- ControlDependency control_dependency, bool unaligned, bool mismatched) {
+ ControlDependency control_dependency, bool unaligned, bool mismatched, bool unsafe) {
bool require_atomic = true;
LoadLNode* load = new LoadLNode(ctl, mem, adr, adr_type, rt->is_long(), mo, control_dependency, require_atomic);
if (unaligned) {
@@ -855,11 +861,14 @@
if (mismatched) {
load->set_mismatched_access();
}
+ if (unsafe) {
+ load->set_unsafe_access();
+ }
return load;
}
LoadDNode* LoadDNode::make_atomic(Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, const Type* rt, MemOrd mo,
- ControlDependency control_dependency, bool unaligned, bool mismatched) {
+ ControlDependency control_dependency, bool unaligned, bool mismatched, bool unsafe) {
bool require_atomic = true;
LoadDNode* load = new LoadDNode(ctl, mem, adr, adr_type, rt, mo, control_dependency, require_atomic);
if (unaligned) {
@@ -868,6 +877,9 @@
if (mismatched) {
load->set_mismatched_access();
}
+ if (unsafe) {
+ load->set_unsafe_access();
+ }
return load;
}
--- a/src/hotspot/share/opto/memnode.hpp Thu Feb 14 15:27:12 2019 -0800
+++ b/src/hotspot/share/opto/memnode.hpp Thu Feb 14 15:27:12 2019 -0800
@@ -42,6 +42,7 @@
private:
bool _unaligned_access; // Unaligned access from unsafe
bool _mismatched_access; // Mismatched access from unsafe: byte read in integer array for instance
+ bool _unsafe_access; // Access of unsafe origin.
protected:
#ifdef ASSERT
const TypePtr* _adr_type; // What kind of memory is being addressed?
@@ -62,17 +63,17 @@
} MemOrd;
protected:
MemNode( Node *c0, Node *c1, Node *c2, const TypePtr* at )
- : Node(c0,c1,c2 ), _unaligned_access(false), _mismatched_access(false) {
+ : Node(c0,c1,c2 ), _unaligned_access(false), _mismatched_access(false), _unsafe_access(false) {
init_class_id(Class_Mem);
debug_only(_adr_type=at; adr_type();)
}
MemNode( Node *c0, Node *c1, Node *c2, const TypePtr* at, Node *c3 )
- : Node(c0,c1,c2,c3), _unaligned_access(false), _mismatched_access(false) {
+ : Node(c0,c1,c2,c3), _unaligned_access(false), _mismatched_access(false), _unsafe_access(false) {
init_class_id(Class_Mem);
debug_only(_adr_type=at; adr_type();)
}
MemNode( Node *c0, Node *c1, Node *c2, const TypePtr* at, Node *c3, Node *c4)
- : Node(c0,c1,c2,c3,c4), _unaligned_access(false), _mismatched_access(false) {
+ : Node(c0,c1,c2,c3,c4), _unaligned_access(false), _mismatched_access(false), _unsafe_access(false) {
init_class_id(Class_Mem);
debug_only(_adr_type=at; adr_type();)
}
@@ -137,6 +138,8 @@
bool is_unaligned_access() const { return _unaligned_access; }
void set_mismatched_access() { _mismatched_access = true; }
bool is_mismatched_access() const { return _mismatched_access; }
+ void set_unsafe_access() { _unsafe_access = true; }
+ bool is_unsafe_access() const { return _unsafe_access; }
#ifndef PRODUCT
static void dump_adr_type(const Node* mem, const TypePtr* adr_type, outputStream *st);
@@ -207,7 +210,7 @@
static Node* make(PhaseGVN& gvn, Node *c, Node *mem, Node *adr,
const TypePtr* at, const Type *rt, BasicType bt,
MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest,
- bool unaligned = false, bool mismatched = false);
+ bool unaligned = false, bool mismatched = false, bool unsafe = false);
virtual uint hash() const; // Check the type
@@ -388,7 +391,7 @@
bool require_atomic_access() const { return _require_atomic_access; }
static LoadLNode* make_atomic(Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type,
const Type* rt, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest,
- bool unaligned = false, bool mismatched = false);
+ bool unaligned = false, bool mismatched = false, bool unsafe = false);
#ifndef PRODUCT
virtual void dump_spec(outputStream *st) const {
LoadNode::dump_spec(st);
@@ -440,7 +443,7 @@
bool require_atomic_access() const { return _require_atomic_access; }
static LoadDNode* make_atomic(Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type,
const Type* rt, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest,
- bool unaligned = false, bool mismatched = false);
+ bool unaligned = false, bool mismatched = false, bool unsafe = false);
#ifndef PRODUCT
virtual void dump_spec(outputStream *st) const {
LoadNode::dump_spec(st);