--- a/hotspot/src/share/vm/opto/memnode.cpp Tue Jan 12 11:31:04 2016 +0100
+++ b/hotspot/src/share/vm/opto/memnode.cpp Tue Jan 12 12:55:09 2016 +0100
@@ -1069,7 +1069,7 @@
//------------------------------Identity---------------------------------------
// Loads are identity if previous store is to same address
-Node *LoadNode::Identity( PhaseTransform *phase ) {
+Node* LoadNode::Identity(PhaseGVN* phase) {
// If the previous store-maker is the right kind of Store, and the store is
// to the same address, then we are equal to the value stored.
Node* mem = in(Memory);
@@ -1615,7 +1615,7 @@
}
//------------------------------Value-----------------------------------------
-const Type *LoadNode::Value( PhaseTransform *phase ) const {
+const Type* LoadNode::Value(PhaseGVN* phase) const {
// Either input is TOP ==> the result is TOP
Node* mem = in(MemNode::Memory);
const Type *t1 = phase->type(mem);
@@ -1901,7 +1901,7 @@
return LoadNode::Ideal(phase, can_reshape);
}
-const Type* LoadBNode::Value(PhaseTransform *phase) const {
+const Type* LoadBNode::Value(PhaseGVN* phase) const {
Node* mem = in(MemNode::Memory);
Node* value = can_see_stored_value(mem,phase);
if (value != NULL && value->is_Con() &&
@@ -1931,7 +1931,7 @@
return LoadNode::Ideal(phase, can_reshape);
}
-const Type* LoadUBNode::Value(PhaseTransform *phase) const {
+const Type* LoadUBNode::Value(PhaseGVN* phase) const {
Node* mem = in(MemNode::Memory);
Node* value = can_see_stored_value(mem,phase);
if (value != NULL && value->is_Con() &&
@@ -1961,7 +1961,7 @@
return LoadNode::Ideal(phase, can_reshape);
}
-const Type* LoadUSNode::Value(PhaseTransform *phase) const {
+const Type* LoadUSNode::Value(PhaseGVN* phase) const {
Node* mem = in(MemNode::Memory);
Node* value = can_see_stored_value(mem,phase);
if (value != NULL && value->is_Con() &&
@@ -1993,7 +1993,7 @@
return LoadNode::Ideal(phase, can_reshape);
}
-const Type* LoadSNode::Value(PhaseTransform *phase) const {
+const Type* LoadSNode::Value(PhaseGVN* phase) const {
Node* mem = in(MemNode::Memory);
Node* value = can_see_stored_value(mem,phase);
if (value != NULL && value->is_Con() &&
@@ -2026,7 +2026,7 @@
}
//------------------------------Value------------------------------------------
-const Type *LoadKlassNode::Value( PhaseTransform *phase ) const {
+const Type* LoadKlassNode::Value(PhaseGVN* phase) const {
return klass_value_common(phase);
}
@@ -2036,7 +2036,7 @@
return false;
}
-const Type *LoadNode::klass_value_common( PhaseTransform *phase ) const {
+const Type* LoadNode::klass_value_common(PhaseGVN* phase) const {
// Either input is TOP ==> the result is TOP
const Type *t1 = phase->type( in(MemNode::Memory) );
if (t1 == Type::TOP) return Type::TOP;
@@ -2172,11 +2172,11 @@
//------------------------------Identity---------------------------------------
// To clean up reflective code, simplify k.java_mirror.as_klass to plain k.
// Also feed through the klass in Allocate(...klass...)._klass.
-Node* LoadKlassNode::Identity( PhaseTransform *phase ) {
+Node* LoadKlassNode::Identity(PhaseGVN* phase) {
return klass_identity_common(phase);
}
-Node* LoadNode::klass_identity_common(PhaseTransform *phase ) {
+Node* LoadNode::klass_identity_common(PhaseGVN* phase) {
Node* x = LoadNode::Identity(phase);
if (x != this) return x;
@@ -2231,7 +2231,7 @@
//------------------------------Value------------------------------------------
-const Type *LoadNKlassNode::Value( PhaseTransform *phase ) const {
+const Type* LoadNKlassNode::Value(PhaseGVN* phase) const {
const Type *t = klass_value_common(phase);
if (t == Type::TOP)
return t;
@@ -2242,7 +2242,7 @@
//------------------------------Identity---------------------------------------
// To clean up reflective code, simplify k.java_mirror.as_klass to narrow k.
// Also feed through the klass in Allocate(...klass...)._klass.
-Node* LoadNKlassNode::Identity( PhaseTransform *phase ) {
+Node* LoadNKlassNode::Identity(PhaseGVN* phase) {
Node *x = klass_identity_common(phase);
const Type *t = phase->type( x );
@@ -2254,7 +2254,7 @@
}
//------------------------------Value-----------------------------------------
-const Type *LoadRangeNode::Value( PhaseTransform *phase ) const {
+const Type* LoadRangeNode::Value(PhaseGVN* phase) const {
// Either input is TOP ==> the result is TOP
const Type *t1 = phase->type( in(MemNode::Memory) );
if( t1 == Type::TOP ) return Type::TOP;
@@ -2302,7 +2302,7 @@
//------------------------------Identity---------------------------------------
// Feed through the length in AllocateArray(...length...)._length.
-Node* LoadRangeNode::Identity( PhaseTransform *phase ) {
+Node* LoadRangeNode::Identity(PhaseGVN* phase) {
Node* x = LoadINode::Identity(phase);
if (x != this) return x;
@@ -2473,7 +2473,7 @@
}
//------------------------------Value-----------------------------------------
-const Type *StoreNode::Value( PhaseTransform *phase ) const {
+const Type* StoreNode::Value(PhaseGVN* phase) const {
// Either input is TOP ==> the result is TOP
const Type *t1 = phase->type( in(MemNode::Memory) );
if( t1 == Type::TOP ) return Type::TOP;
@@ -2488,7 +2488,7 @@
// Remove redundant stores:
// Store(m, p, Load(m, p)) changes to m.
// Store(, p, x) -> Store(m, p, x) changes to Store(m, p, x).
-Node *StoreNode::Identity( PhaseTransform *phase ) {
+Node* StoreNode::Identity(PhaseGVN* phase) {
Node* mem = in(MemNode::Memory);
Node* adr = in(MemNode::Address);
Node* val = in(MemNode::ValueIn);
@@ -2642,7 +2642,7 @@
//=============================================================================
//------------------------------Identity---------------------------------------
-Node *StoreCMNode::Identity( PhaseTransform *phase ) {
+Node* StoreCMNode::Identity(PhaseGVN* phase) {
// No need to card mark when storing a null ptr
Node* my_store = in(MemNode::OopStore);
if (my_store->is_Store()) {
@@ -2671,7 +2671,7 @@
}
//------------------------------Value-----------------------------------------
-const Type *StoreCMNode::Value( PhaseTransform *phase ) const {
+const Type* StoreCMNode::Value(PhaseGVN* phase) const {
// Either input is TOP ==> the result is TOP
const Type *t = phase->type( in(MemNode::Memory) );
if( t == Type::TOP ) return Type::TOP;
@@ -2689,7 +2689,7 @@
//=============================================================================
//----------------------------------SCMemProjNode------------------------------
-const Type * SCMemProjNode::Value( PhaseTransform *phase ) const
+const Type* SCMemProjNode::Value(PhaseGVN* phase) const
{
return bottom_type();
}
@@ -2745,7 +2745,7 @@
//------------------------------Identity---------------------------------------
// Clearing a zero length array does nothing
-Node *ClearArrayNode::Identity( PhaseTransform *phase ) {
+Node* ClearArrayNode::Identity(PhaseGVN* phase) {
return phase->type(in(2))->higher_equal(TypeX::ZERO) ? in(1) : this;
}
@@ -3001,7 +3001,7 @@
}
//------------------------------Value------------------------------------------
-const Type *MemBarNode::Value( PhaseTransform *phase ) const {
+const Type* MemBarNode::Value(PhaseGVN* phase) const {
if( !in(0) ) return Type::TOP;
if( phase->type(in(0)) == Type::TOP )
return Type::TOP;
@@ -4143,7 +4143,7 @@
}
//------------------------------Identity---------------------------------------
-Node* MergeMemNode::Identity(PhaseTransform *phase) {
+Node* MergeMemNode::Identity(PhaseGVN* phase) {
// Identity if this merge point does not record any interesting memory
// disambiguations.
Node* base_mem = base_memory();