*** old/src/share/vm/opto/generateOptoStub.cpp	Thu May 15 17:09:28 2014
--- new/src/share/vm/opto/generateOptoStub.cpp	Thu May 15 17:09:27 2014

*** 48,58 ****
--- 48,58 ----
  
    const TypeTuple *jdomain = C->tf()->domain();
    const TypeTuple *jrange  = C->tf()->range();
  
    // The procedure start
-   StartNode* start = new (C) StartNode(root(), jdomain);
    _gvn.set_type_bottom(start);
  
    // Make a map, with JVM state
    uint parm_cnt = jdomain->cnt();
    uint max_map = MAX2(2*parm_cnt+1, jrange->cnt());

*** 62,89 ****
--- 62,89 ----
    jvms->set_bci(InvocationEntryBci);
    jvms->set_monoff(max_map);
    jvms->set_scloff(max_map);
    jvms->set_endoff(max_map);
    {
-     SafePointNode *map = new (C) SafePointNode( max_map, jvms );
      jvms->set_map(map);
      set_jvms(jvms);
      assert(map == this->map(), "kit.map is set");
    }
  
    // Make up the parameters
    uint i;
    for( i = 0; i < parm_cnt; i++ )
-     map()->init_req(i, _gvn.transform(new (C) ParmNode(start, i)));
    for( ; i<map()->req(); i++ )
      map()->init_req(i, top());      // For nicer debugging
  
    // GraphKit requires memory to be a MergeMemNode:
    set_all_memory(map()->memory());
  
    // Get base of thread-local storage area
-   Node* thread = _gvn.transform( new (C) ThreadLocalNode() );
  
    const int NoAlias = Compile::AliasIdxBot;
  
    Node* adr_last_Java_pc = basic_plus_adr(top(),
                                              thread,

*** 164,175 ****
--- 164,174 ----
    // Final C signature
    const TypeFunc *c_sig = TypeFunc::make(domain,range);
  
    //-----------------------------
    // Make the call node
!   CallRuntimeNode *call = new (C)
      CallRuntimeNode(c_sig, C_function, name, TypePtr::BOTTOM);
!   CallRuntimeNode *call = new CallRuntimeNode(c_sig, C_function, name, TypePtr::BOTTOM);
    //-----------------------------
  
    // Fix-up the debug info for the call
    call->set_jvms( new (C) JVMState(0) );
    call->jvms()->set_bci(0);

*** 182,192 ****
--- 181,191 ----
    // A little too aggressive on the parm copy; return address is not an input
    call->set_req(TypeFunc::ReturnAdr, top());
    for (; i < parm_cnt; i++) { // Regular input arguments
      // Convert ints to longs if required.
      if (CCallingConventionRequiresIntsAsLongs && jdomain->field_at(i)->isa_int()) {
-       Node* int_as_long = _gvn.transform(new (C) ConvI2LNode(map()->in(i)));
        call->init_req(cnt++, int_as_long); // long
        call->init_req(cnt++, top());       // half
      } else {
        call->init_req(cnt++, map()->in(i));
      }

*** 198,224 ****
--- 197,223 ----
    _gvn.transform_no_reclaim(call);
  
  
    //-----------------------------
    // Now set up the return results
-   set_control( _gvn.transform( new (C) ProjNode(call,TypeFunc::Control)) );
-   set_i_o(     _gvn.transform( new (C) ProjNode(call,TypeFunc::I_O    )) );
    set_all_memory_call(call);
    if (range->cnt() > TypeFunc::Parms) {
-     Node* retnode = _gvn.transform( new (C) ProjNode(call,TypeFunc::Parms) );
      // C-land is allowed to return sub-word values.  Convert to integer type.
      assert( retval != Type::TOP, "" );
      if (retval == TypeInt::BOOL) {
-       retnode = _gvn.transform( new (C) AndINode(retnode, intcon(0xFF)) );
      } else if (retval == TypeInt::CHAR) {
-       retnode = _gvn.transform( new (C) AndINode(retnode, intcon(0xFFFF)) );
      } else if (retval == TypeInt::BYTE) {
-       retnode = _gvn.transform( new (C) LShiftINode(retnode, intcon(24)) );
-       retnode = _gvn.transform( new (C) RShiftINode(retnode, intcon(24)) );
      } else if (retval == TypeInt::SHORT) {
-       retnode = _gvn.transform( new (C) LShiftINode(retnode, intcon(16)) );
-       retnode = _gvn.transform( new (C) RShiftINode(retnode, intcon(16)) );
      }
      map()->set_req( TypeFunc::Parms, retnode );
    }
  
    //-----------------------------

*** 251,270 ****
--- 250,269 ----
    Node* adr = basic_plus_adr(top(), thread, in_bytes(Thread::pending_exception_offset()));
    Node* pending = make_load(NULL, adr, TypeOopPtr::BOTTOM, T_OBJECT, NoAlias, MemNode::unordered);
  
    Node* exit_memory = reset_memory();
  
-   Node* cmp = _gvn.transform( new (C) CmpPNode(pending, null()) );
-   Node* bo  = _gvn.transform( new (C) BoolNode(cmp, BoolTest::ne) );
    IfNode   *iff = create_and_map_if(control(), bo, PROB_MIN, COUNT_UNKNOWN);
  
-   Node* if_null     = _gvn.transform( new (C) IfFalseNode(iff) );
-   Node* if_not_null = _gvn.transform( new (C) IfTrueNode(iff)  );
  
    assert (StubRoutines::forward_exception_entry() != NULL, "must be generated before");
    Node *exc_target = makecon(TypeRawPtr::make( StubRoutines::forward_exception_entry() ));
-   Node *to_exc = new (C) TailCallNode(if_not_null,
                                    i_o(),
                                    exit_memory,
                                    frameptr(),
                                    returnadr(),
                                    exc_target, null());

*** 275,305 ****
--- 274,304 ----
    // If this is a normal subroutine return, issue the return and be done.
    Node *ret;
    switch( is_fancy_jump ) {
    case 0:                       // Make a return instruction
      // Return to caller, free any space for return address
-     ret = new (C) ReturnNode(TypeFunc::Parms, if_null,
                           i_o(),
                           exit_memory,
                           frameptr(),
                           returnadr());
      if (C->tf()->range()->cnt() > TypeFunc::Parms)
        ret->add_req( map()->in(TypeFunc::Parms) );
      break;
    case 1:    // This is a fancy tail-call jump.  Jump to computed address.
      // Jump to new callee; leave old return address alone.
-     ret = new (C) TailCallNode(if_null,
                             i_o(),
                             exit_memory,
                             frameptr(),
                             returnadr(),
                             target, map()->in(TypeFunc::Parms));
      break;
    case 2:                       // Pop return address & jump
      // Throw away old return address; jump to new computed address
      //assert(C_function == CAST_FROM_FN_PTR(address, OptoRuntime::rethrow_C), "fancy_jump==2 only for rethrow");
-     ret = new (C) TailJumpNode(if_null,
                                 i_o(),
                                 exit_memory,
                                 frameptr(),
                                 target, map()->in(TypeFunc::Parms));
      break;