*** old/src/share/vm/opto/memnode.cpp	Wed Jun  3 18:24:01 2015
--- new/src/share/vm/opto/memnode.cpp	Wed Jun  3 18:24:01 2015

*** 876,885 ****
--- 876,888 ----
    MemNode::dump_spec(st);
    if( !Verbose && !WizardMode ) {
      // standard dump does this in Verbose and WizardMode
      st->print(" #"); _type->dump_on(st);
    }
+   if (!_depends_only_on_test) {
+     st->print(" (does not depend only on test)");
+   }
  }
  #endif
  
  #ifdef ASSERT
  //----------------------------is_immutable_value-------------------------------

*** 892,902 ****
--- 895,905 ----
  }
  #endif
  
  //----------------------------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) {
    Compile* C = gvn.C;
  
    // sanity check the alias category against the created node type
    assert(!(adr_type->isa_oopptr() &&
             adr_type->offset() == oopDesc::klass_offset_in_bytes()),

*** 908,950 ****
--- 911,953 ----
    assert( ctl != NULL || C->get_alias_index(adr_type) != Compile::AliasIdxRaw ||
            // oop will be recorded in oop map if load crosses safepoint
            rt->isa_oopptr() || is_immutable_value(adr),
            "raw memory operations should have control edge");
    switch (bt) {
!   case T_BOOLEAN: return new (C) LoadUBNode(ctl, mem, adr, adr_type, rt->is_int(),  mo, control_dependency);
!   case T_BYTE:    return new (C) LoadBNode (ctl, mem, adr, adr_type, rt->is_int(),  mo);
!   case T_INT:     return new (C) LoadINode (ctl, mem, adr, adr_type, rt->is_int(),  mo);
!   case T_CHAR:    return new (C) LoadUSNode(ctl, mem, adr, adr_type, rt->is_int(),  mo);
!   case T_SHORT:   return new (C) LoadSNode (ctl, mem, adr, adr_type, rt->is_int(),  mo);
!   case T_LONG:    return new (C) LoadLNode (ctl, mem, adr, adr_type, rt->is_long(), mo);
!   case T_FLOAT:   return new (C) LoadFNode (ctl, mem, adr, adr_type, rt,            mo);
!   case T_DOUBLE:  return new (C) LoadDNode (ctl, mem, adr, adr_type, rt,            mo);
!   case T_ADDRESS: return new (C) LoadPNode (ctl, mem, adr, adr_type, rt->is_ptr(),  mo);
!   case T_BYTE:    return new (C) LoadBNode (ctl, mem, adr, adr_type, rt->is_int(),  mo, control_dependency);
!   case T_INT:     return new (C) LoadINode (ctl, mem, adr, adr_type, rt->is_int(),  mo, control_dependency);
!   case T_CHAR:    return new (C) LoadUSNode(ctl, mem, adr, adr_type, rt->is_int(),  mo, control_dependency);
!   case T_SHORT:   return new (C) LoadSNode (ctl, mem, adr, adr_type, rt->is_int(),  mo, control_dependency);
!   case T_LONG:    return new (C) LoadLNode (ctl, mem, adr, adr_type, rt->is_long(), mo, control_dependency);
!   case T_FLOAT:   return new (C) LoadFNode (ctl, mem, adr, adr_type, rt,            mo, control_dependency);
!   case T_DOUBLE:  return new (C) LoadDNode (ctl, mem, adr, adr_type, rt,            mo, control_dependency);
!   case T_ADDRESS: return new (C) LoadPNode (ctl, mem, adr, adr_type, rt->is_ptr(),  mo, control_dependency);
    case T_OBJECT:
  #ifdef _LP64
      if (adr->bottom_type()->is_ptr_to_narrowoop()) {
!       Node* load  = gvn.transform(new (C) LoadNNode(ctl, mem, adr, adr_type, rt->make_narrowoop(), mo, control_dependency));
        return new (C) DecodeNNode(load, load->bottom_type()->make_ptr());
      } else
  #endif
      {
        assert(!adr->bottom_type()->is_ptr_to_narrowoop() && !adr->bottom_type()->is_ptr_to_narrowklass(), "should have got back a narrow oop");
!       return new (C) LoadPNode(ctl, mem, adr, adr_type, rt->is_oopptr(), mo, control_dependency);
      }
    }
    ShouldNotReachHere();
    return (LoadNode*)NULL;
  }
  
! LoadLNode* LoadLNode::make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, const Type* rt, MemOrd mo, ControlDependency control_dependency) {
    bool require_atomic = true;
!   return new (C) LoadLNode(ctl, mem, adr, adr_type, rt->is_long(), mo, control_dependency, require_atomic);
  }
  
! LoadDNode* LoadDNode::make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, const Type* rt, MemOrd mo, ControlDependency control_dependency) {
    bool require_atomic = true;
!   return new (C) LoadDNode(ctl, mem, adr, adr_type, rt, mo, control_dependency, require_atomic);
  }
  
  
  
  //------------------------------hash-------------------------------------------