archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-28 07:14:30 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge

Browse source
This commit is contained in:
Jesper Wilhelmsson 2020-07-03 19:05:00 +02:00
commit 4922a35c6a
4 changed files with 19 additions and 8 deletions
Download patch file Download diff file Expand all files Collapse all files

5
src/hotspot/share/gc/shenandoah/shenandoahRootVerifier.cpp
View file

@ -46,6 +46,7 @@
STATIC_ASSERT((static_cast<uint>(ShenandoahRootVerifier::AllRoots) + 1) > static_cast<uint>(ShenandoahRootVerifier::AllRoots)); STATIC_ASSERT((static_cast<uint>(ShenandoahRootVerifier::AllRoots) + 1) > static_cast<uint>(ShenandoahRootVerifier::AllRoots));
ShenandoahRootVerifier::ShenandoahRootVerifier(RootTypes types) : _types(types) { ShenandoahRootVerifier::ShenandoahRootVerifier(RootTypes types) : _types(types) {
Threads::change_thread_claim_token();
} }
void ShenandoahRootVerifier::excludes(RootTypes types) { void ShenandoahRootVerifier::excludes(RootTypes types) {
@ -138,7 +139,7 @@ void ShenandoahRootVerifier::roots_do(OopClosure* oops) {
// Do thread roots the last. This allows verification code to find // Do thread roots the last. This allows verification code to find
// any broken objects from those special roots first, not the accidental // any broken objects from those special roots first, not the accidental
// dangling reference from the thread root. // dangling reference from the thread root.
Threads::possibly_parallel_oops_do(false, oops, &blobs); Threads::possibly_parallel_oops_do(true, oops, &blobs);
} }
void ShenandoahRootVerifier::strong_roots_do(OopClosure* oops) { void ShenandoahRootVerifier::strong_roots_do(OopClosure* oops) {
@ -159,7 +160,7 @@ void ShenandoahRootVerifier::strong_roots_do(OopClosure* oops) {
// Do thread roots the last. This allows verification code to find // Do thread roots the last. This allows verification code to find
// any broken objects from those special roots first, not the accidental // any broken objects from those special roots first, not the accidental
// dangling reference from the thread root. // dangling reference from the thread root.
Threads::possibly_parallel_oops_do(false, oops, &blobs); Threads::possibly_parallel_oops_do(true, oops, &blobs);
} }
void ShenandoahRootVerifier::serial_weak_roots_do(OopClosure* cl) { void ShenandoahRootVerifier::serial_weak_roots_do(OopClosure* cl) {

5
src/hotspot/share/opto/arraycopynode.hpp
View file

@ -112,8 +112,9 @@ private:
bool finish_transform(PhaseGVN *phase, bool can_reshape, bool finish_transform(PhaseGVN *phase, bool can_reshape,
Node* ctl, Node *mem); Node* ctl, Node *mem);
static bool may_modify_helper(const TypeOopPtr *t_oop, Node* n, PhaseTransform *phase, CallNode*& call); static bool may_modify_helper(const TypeOopPtr *t_oop, Node* n, PhaseTransform *phase, CallNode*& call);
public:
static Node* load(BarrierSetC2* bs, PhaseGVN *phase, Node*& ctl, MergeMemNode* mem, Node* addr, const TypePtr* adr_type, const Type *type, BasicType bt); static Node* load(BarrierSetC2* bs, PhaseGVN *phase, Node*& ctl, MergeMemNode* mem, Node* addr, const TypePtr* adr_type, const Type *type, BasicType bt);
private:
void store(BarrierSetC2* bs, PhaseGVN *phase, Node*& ctl, MergeMemNode* mem, Node* addr, const TypePtr* adr_type, Node* val, const Type *type, BasicType bt); void store(BarrierSetC2* bs, PhaseGVN *phase, Node*& ctl, MergeMemNode* mem, Node* addr, const TypePtr* adr_type, Node* val, const Type *type, BasicType bt);
public: public:
@ -153,7 +154,7 @@ public:
bool is_clone_array() const { assert(_kind != None, "should bet set"); return _kind == CloneArray; } bool is_clone_array() const { assert(_kind != None, "should bet set"); return _kind == CloneArray; }
// is_clone_oop_array is used when oop arrays need GC barriers // is_clone_oop_array is used when oop arrays need GC barriers
bool is_clone_oop_array() const { assert(_kind != None, "should bet set"); return _kind == CloneOopArray; } bool is_clone_oop_array() const { assert(_kind != None, "should bet set"); return _kind == CloneOopArray; }
// is_clonebasic - is true for any type of clone that doesn't need a barrier. // is_clonebasic - is true for any type of clone that doesn't need a writebarrier.
bool is_clonebasic() const { assert(_kind != None, "should bet set"); return _kind == CloneInst || _kind == CloneArray; } bool is_clonebasic() const { assert(_kind != None, "should bet set"); return _kind == CloneInst || _kind == CloneArray; }
bool is_copyof() const { assert(_kind != None, "should bet set"); return _kind == CopyOf; } bool is_copyof() const { assert(_kind != None, "should bet set"); return _kind == CopyOf; }
bool is_copyof_validated() const { assert(_kind != None, "should bet set"); return _kind == CopyOf && _arguments_validated; } bool is_copyof_validated() const { assert(_kind != None, "should bet set"); return _kind == CopyOf && _arguments_validated; }

9
src/hotspot/share/opto/macro.cpp
View file

@ -367,7 +367,9 @@ Node* PhaseMacroExpand::make_arraycopy_load(ArrayCopyNode* ac, intptr_t offset,
Node* base = ac->in(ArrayCopyNode::Src); Node* base = ac->in(ArrayCopyNode::Src);
Node* adr = _igvn.transform(new AddPNode(base, base, MakeConX(offset))); Node* adr = _igvn.transform(new AddPNode(base, base, MakeConX(offset)));
const TypePtr* adr_type = _igvn.type(base)->is_ptr()->add_offset(offset); const TypePtr* adr_type = _igvn.type(base)->is_ptr()->add_offset(offset);
res = LoadNode::make(_igvn, ctl, mem, adr, adr_type, type, bt, MemNode::unordered, LoadNode::UnknownControl); MergeMemNode* mergemen = MergeMemNode::make(mem);
BarrierSetC2* bs = BarrierSet::barrier_set()->barrier_set_c2();
res = ArrayCopyNode::load(bs, &_igvn, ctl, mergemen, adr, adr_type, type, bt);
} else { } else {
if (ac->modifies(offset, offset, &_igvn, true)) { if (ac->modifies(offset, offset, &_igvn, true)) {
assert(ac->in(ArrayCopyNode::Dest) == alloc->result_cast(), "arraycopy destination should be allocation's result"); assert(ac->in(ArrayCopyNode::Dest) == alloc->result_cast(), "arraycopy destination should be allocation's result");
@ -405,11 +407,12 @@ Node* PhaseMacroExpand::make_arraycopy_load(ArrayCopyNode* ac, intptr_t offset,
return NULL; return NULL;
} }
} }
res = LoadNode::make(_igvn, ctl, mem, adr, adr_type, type, bt, MemNode::unordered, LoadNode::UnknownControl); MergeMemNode* mergemen = MergeMemNode::make(mem);
BarrierSetC2* bs = BarrierSet::barrier_set()->barrier_set_c2();
res = ArrayCopyNode::load(bs, &_igvn, ctl, mergemen, adr, adr_type, type, bt);
} }
} }
if (res != NULL) { if (res != NULL) {
res = _igvn.transform(res);
if (ftype->isa_narrowoop()) { if (ftype->isa_narrowoop()) {
// PhaseMacroExpand::scalar_replacement adds DecodeN nodes // PhaseMacroExpand::scalar_replacement adds DecodeN nodes
res = _igvn.transform(new EncodePNode(res, ftype)); res = _igvn.transform(new EncodePNode(res, ftype));

8
src/java.base/share/classes/java/net/NetworkInterface.java
View file

@ -576,7 +576,13 @@ public final class NetworkInterface {
* as this object. * as this object.
* <p> * <p>
* Two instances of {@code NetworkInterface} represent the same * Two instances of {@code NetworkInterface} represent the same
* NetworkInterface if both name and addrs are the same for both. * NetworkInterface if both the name and the set of {@code InetAddress}es
* bound to the interfaces are equal.
*
* @apiNote two {@code NetworkInterface} objects referring to the same
* underlying interface may not compare equal if the addresses
* of the underlying interface are being dynamically updated by
* the system.
* *
* @param obj the object to compare against. * @param obj the object to compare against.
* @return {@code true} if the objects are the same; * @return {@code true} if the objects are the same;