*** old/src/share/vm/opto/memnode.cpp	Mon Aug  4 14:31:49 2014
--- new/src/share/vm/opto/memnode.cpp	Mon Aug  4 14:31:49 2014

*** 931,946 ****
--- 931,946 ----
    }
    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) {
    bool require_atomic = true;
    return new LoadLNode(ctl, mem, adr, adr_type, rt->is_long(), mo, require_atomic);
  }
  
- LoadDNode* LoadDNode::make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, const Type* rt, MemOrd mo) {
    bool require_atomic = true;
    return new LoadDNode(ctl, mem, adr, adr_type, rt, mo, require_atomic);
  }
  
  

*** 2015,2025 ****
--- 2015,2024 ----
  
  //=============================================================================
  //----------------------------LoadKlassNode::make------------------------------
  // Polymorphic factory method:
  Node *LoadKlassNode::make( PhaseGVN& gvn, Node *mem, Node *adr, const TypePtr* at, const TypeKlassPtr *tk ) {
    Compile* C = gvn.C;
    Node *ctl = NULL;
    // sanity check the alias category against the created node type
    const TypePtr *adr_type = adr->bottom_type()->isa_ptr();
    assert(adr_type != NULL, "expecting TypeKlassPtr");
  #ifdef _LP64

*** 2380,2395 ****
--- 2379,2394 ----
    }
    ShouldNotReachHere();
    return (StoreNode*)NULL;
  }
  
- StoreLNode* StoreLNode::make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val, MemOrd mo) {
    bool require_atomic = true;
    return new StoreLNode(ctl, mem, adr, adr_type, val, mo, require_atomic);
  }
  
- StoreDNode* StoreDNode::make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val, MemOrd mo) {
    bool require_atomic = true;
    return new StoreDNode(ctl, mem, adr, adr_type, val, mo, require_atomic);
  }
  
  

*** 2461,2471 ****
--- 2460,2470 ----
        Node* moved = init->capture_store(this, offset, phase, can_reshape);
        // If the InitializeNode captured me, it made a raw copy of me,
        // and I need to disappear.
        if (moved != NULL) {
          // %%% hack to ensure that Ideal returns a new node:
-         mem = MergeMemNode::make(phase->C, mem);
          return mem;             // fold me away
        }
      }
    }
  

*** 2821,2831 ****
--- 2820,2829 ----
  // Generate code to initialize object storage to zero.
  Node* ClearArrayNode::clear_memory(Node* ctl, Node* mem, Node* dest,
                                     intptr_t start_offset,
                                     Node* end_offset,
                                     PhaseGVN* phase) {
    Compile* C = phase->C;
    intptr_t offset = start_offset;
  
    int unit = BytesPerLong;
    if ((offset % unit) != 0) {
      Node* adr = new AddPNode(dest, dest, phase->MakeConX(offset));

*** 2848,2858 ****
--- 2846,2855 ----
    if (start_offset == end_offset) {
      // nothing to do
      return mem;
    }
  
    Compile* C = phase->C;
    int unit = BytesPerLong;
    Node* zbase = start_offset;
    Node* zend  = end_offset;
  
    // Scale to the unit required by the CPU:

*** 2876,2886 ****
--- 2873,2882 ----
    if (start_offset == end_offset) {
      // nothing to do
      return mem;
    }
  
    Compile* C = phase->C;
    assert((end_offset % BytesPerInt) == 0, "odd end offset");
    intptr_t done_offset = end_offset;
    if ((done_offset % BytesPerLong) != 0) {
      done_offset -= BytesPerInt;
    }

*** 4130,4140 ****
--- 4126,4136 ----
    }
  }
  
  // Make a new, untransformed MergeMem with the same base as 'mem'.
  // If mem is itself a MergeMem, populate the result with the same edges.
- MergeMemNode* MergeMemNode::make(Compile* C, Node* mem) {
    return new MergeMemNode(mem);
  }
  
  //------------------------------cmp--------------------------------------------
  uint MergeMemNode::hash() const { return NO_HASH; }