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

*** 1,7 ****
--- 1,7 ----
  /*
!  * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
!  * Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.

*** 589,599 ****
--- 589,599 ----
        // Cheat with a preallocated exception object.
        if (C->log() != NULL)
          C->log()->elem("hot_throw preallocated='1' reason='%s'",
                         Deoptimization::trap_reason_name(reason));
        const TypeInstPtr* ex_con  = TypeInstPtr::make(ex_obj);
-       Node*              ex_node = _gvn.transform( ConNode::make(C, ex_con) );
  
        // Clear the detail message of the preallocated exception object.
        // Weblogic sometimes mutates the detail message of exceptions
        // using reflection.
        int offset = java_lang_Throwable::get_detailMessage_offset();

*** 704,714 ****
--- 704,714 ----
  
  SafePointNode* GraphKit::clone_map() {
    if (map() == NULL)  return NULL;
  
    // Clone the memory edge first
-   Node* mem = MergeMemNode::make(C, map()->memory());
    gvn().set_type_bottom(mem);
  
    SafePointNode *clonemap = (SafePointNode*)map()->clone();
    JVMState* jvms = this->jvms();
    JVMState* clonejvms = jvms->clone_shallow(C);

*** 1133,1143 ****
--- 1133,1143 ----
    juint offset_con = (juint) find_int_con(offset, Type::OffsetBot);
    if (offset_con != (juint) Type::OffsetBot) {
      return longcon((julong) offset_con);
    }
    Node* conv = _gvn.transform( new ConvI2LNode(offset));
!   Node* mask = _gvn.transform( ConLNode::make(C, (julong) max_juint) );
!   Node* mask = _gvn.transform(ConLNode::make((julong) max_juint));
    return _gvn.transform( new AndLNode(conv, mask) );
  }
  
  Node* GraphKit::ConvL2I(Node* offset) {
    // short-circuit a common case

*** 1433,1443 ****
--- 1433,1443 ----
    return _gvn.transform( mem );
  }
  
  //------------------------------set_all_memory---------------------------------
  void GraphKit::set_all_memory(Node* newmem) {
-   Node* mergemem = MergeMemNode::make(C, newmem);
    gvn().set_type_bottom(mergemem);
    map()->set_memory(mergemem);
  }
  
  //------------------------------set_all_memory_call----------------------------

*** 1462,1474 ****
--- 1462,1474 ----
    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(C, ctl, mem, adr, adr_type, t, mo);
    } else if (require_atomic_access && bt == T_DOUBLE) {
-     ld = LoadDNode::make_atomic(C, ctl, mem, adr, adr_type, t, mo);
    } else {
      ld = LoadNode::make(_gvn, ctl, mem, adr, adr_type, t, bt, mo);
    }
    ld = _gvn.transform(ld);
    if ((bt == T_OBJECT) && C->do_escape_analysis() || C->eliminate_boxing()) {

*** 1486,1498 ****
--- 1486,1498 ----
    const TypePtr* adr_type = NULL;
    debug_only(adr_type = C->get_adr_type(adr_idx));
    Node *mem = memory(adr_idx);
    Node* st;
    if (require_atomic_access && bt == T_LONG) {
-     st = StoreLNode::make_atomic(C, ctl, mem, adr, adr_type, val, mo);
    } else if (require_atomic_access && bt == T_DOUBLE) {
-     st = StoreDNode::make_atomic(C, ctl, mem, adr, adr_type, val, mo);
    } else {
      st = StoreNode::make(_gvn, ctl, mem, adr, adr_type, val, bt, mo);
    }
    st = _gvn.transform(st);
    set_memory(st, adr_idx);

*** 3362,3372 ****
--- 3362,3372 ----
      // Extract memory strands which may participate in the new object's
      // initialization, and source them from the new InitializeNode.
      // This will allow us to observe initializations when they occur,
      // and link them properly (as a group) to the InitializeNode.
      assert(init->in(InitializeNode::Memory) == malloc, "");
-     MergeMemNode* minit_in = MergeMemNode::make(C, malloc);
      init->set_req(InitializeNode::Memory, minit_in);
      record_for_igvn(minit_in); // fold it up later, if possible
      Node* minit_out = memory(rawidx);
      assert(minit_out->is_Proj() && minit_out->in(0) == init, "");
      if (oop_type->isa_aryptr()) {