hotspot/src/share/vm/opto/graphKit.cpp
changeset 24923 9631f7d691dc
parent 24345 616bc709c0e4
child 24945 6df48e563632
--- a/hotspot/src/share/vm/opto/graphKit.cpp	Fri May 30 20:01:11 2014 +0000
+++ b/hotspot/src/share/vm/opto/graphKit.cpp	Mon Jun 02 08:07:29 2014 +0200
@@ -294,7 +294,7 @@
       JVMState* jvms = new (C) JVMState(_method, NULL);
       jvms->set_bci(_bci);
       jvms->set_sp(_sp);
-      jvms->set_map(new (C) SafePointNode(TypeFunc::Parms, jvms));
+      jvms->set_map(new SafePointNode(TypeFunc::Parms, jvms));
       set_jvms(jvms);
       for (uint i = 0; i < map()->req(); i++)  map()->init_req(i, top());
       set_all_memory(top());
@@ -347,7 +347,7 @@
   if (region->in(0) != hidden_merge_mark) {
     // The control input is not (yet) a specially-marked region in phi_map.
     // Make it so, and build some phis.
-    region = new (C) RegionNode(2);
+    region = new RegionNode(2);
     _gvn.set_type(region, Type::CONTROL);
     region->set_req(0, hidden_merge_mark);  // marks an internal ex-state
     region->init_req(1, phi_map->control());
@@ -496,13 +496,13 @@
     // take the uncommon_trap in the BuildCutout below.
 
     // first must access the should_post_on_exceptions_flag in this thread's JavaThread
-    Node* jthread = _gvn.transform(new (C) ThreadLocalNode());
+    Node* jthread = _gvn.transform(new ThreadLocalNode());
     Node* adr = basic_plus_adr(top(), jthread, in_bytes(JavaThread::should_post_on_exceptions_flag_offset()));
     Node* should_post_flag = make_load(control(), adr, TypeInt::INT, T_INT, Compile::AliasIdxRaw, MemNode::unordered);
 
     // Test the should_post_on_exceptions_flag vs. 0
-    Node* chk = _gvn.transform( new (C) CmpINode(should_post_flag, intcon(0)) );
-    Node* tst = _gvn.transform( new (C) BoolNode(chk, BoolTest::eq) );
+    Node* chk = _gvn.transform( new CmpINode(should_post_flag, intcon(0)) );
+    Node* tst = _gvn.transform( new BoolNode(chk, BoolTest::eq) );
 
     // Branch to slow_path if should_post_on_exceptions_flag was true
     { BuildCutout unless(this, tst, PROB_MAX);
@@ -675,8 +675,8 @@
   SafePointNode* outer_map = _map;   // preserved map is caller's
   SafePointNode* inner_map = kit->map();
   IfNode* iff = kit->create_and_map_if(outer_map->control(), p, prob, cnt);
-  outer_map->set_control(kit->gvn().transform( new (kit->C) IfTrueNode(iff) ));
-  inner_map->set_control(kit->gvn().transform( new (kit->C) IfFalseNode(iff) ));
+  outer_map->set_control(kit->gvn().transform( new IfTrueNode(iff) ));
+  inner_map->set_control(kit->gvn().transform( new IfFalseNode(iff) ));
 }
 BuildCutout::~BuildCutout() {
   GraphKit* kit = _kit;
@@ -1118,7 +1118,7 @@
 Node* GraphKit::basic_plus_adr(Node* base, Node* ptr, Node* offset) {
   // short-circuit a common case
   if (offset == intcon(0))  return ptr;
-  return _gvn.transform( new (C) AddPNode(base, ptr, offset) );
+  return _gvn.transform( new AddPNode(base, ptr, offset) );
 }
 
 Node* GraphKit::ConvI2L(Node* offset) {
@@ -1127,7 +1127,7 @@
   if (offset_con != Type::OffsetBot) {
     return longcon((jlong) offset_con);
   }
-  return _gvn.transform( new (C) ConvI2LNode(offset));
+  return _gvn.transform( new ConvI2LNode(offset));
 }
 
 Node* GraphKit::ConvI2UL(Node* offset) {
@@ -1135,9 +1135,9 @@
   if (offset_con != (juint) Type::OffsetBot) {
     return longcon((julong) offset_con);
   }
-  Node* conv = _gvn.transform( new (C) ConvI2LNode(offset));
+  Node* conv = _gvn.transform( new ConvI2LNode(offset));
   Node* mask = _gvn.transform( ConLNode::make(C, (julong) max_juint) );
-  return _gvn.transform( new (C) AndLNode(conv, mask) );
+  return _gvn.transform( new AndLNode(conv, mask) );
 }
 
 Node* GraphKit::ConvL2I(Node* offset) {
@@ -1146,7 +1146,7 @@
   if (offset_con != (jlong)Type::OffsetBot) {
     return intcon((int) offset_con);
   }
-  return _gvn.transform( new (C) ConvL2INode(offset));
+  return _gvn.transform( new ConvL2INode(offset));
 }
 
 //-------------------------load_object_klass-----------------------------------
@@ -1165,7 +1165,7 @@
   Node *alen;
   if (alloc == NULL) {
     Node *r_adr = basic_plus_adr(array, arrayOopDesc::length_offset_in_bytes());
-    alen = _gvn.transform( new (C) LoadRangeNode(0, immutable_memory(), r_adr, TypeInt::POS));
+    alen = _gvn.transform( new LoadRangeNode(0, immutable_memory(), r_adr, TypeInt::POS));
   } else {
     alen = alloc->Ideal_length();
     Node* ccast = alloc->make_ideal_length(_gvn.type(array)->is_oopptr(), &_gvn);
@@ -1199,8 +1199,8 @@
   // Construct NULL check
   Node *chk = NULL;
   switch(type) {
-    case T_LONG   : chk = new (C) CmpLNode(value, _gvn.zerocon(T_LONG)); break;
-    case T_INT    : chk = new (C) CmpINode(value, _gvn.intcon(0)); break;
+    case T_LONG   : chk = new CmpLNode(value, _gvn.zerocon(T_LONG)); break;
+    case T_INT    : chk = new CmpINode(value, _gvn.intcon(0)); break;
     case T_ARRAY  : // fall through
       type = T_OBJECT;  // simplify further tests
     case T_OBJECT : {
@@ -1247,7 +1247,7 @@
           return value;           // Elided null check quickly!
         }
       }
-      chk = new (C) CmpPNode( value, null() );
+      chk = new CmpPNode( value, null() );
       break;
     }
 
@@ -1258,7 +1258,7 @@
   chk = _gvn.transform(chk);
 
   BoolTest::mask btest = assert_null ? BoolTest::eq : BoolTest::ne;
-  BoolNode *btst = new (C) BoolNode( chk, btest);
+  BoolNode *btst = new BoolNode( chk, btest);
   Node   *tst = _gvn.transform( btst );
 
   //-----------
@@ -1325,8 +1325,8 @@
 
   if (null_control != NULL) {
     IfNode* iff = create_and_map_if(control(), tst, ok_prob, COUNT_UNKNOWN);
-    Node* null_true = _gvn.transform( new (C) IfFalseNode(iff));
-    set_control(      _gvn.transform( new (C) IfTrueNode(iff)));
+    Node* null_true = _gvn.transform( new IfFalseNode(iff));
+    set_control(      _gvn.transform( new IfTrueNode(iff)));
     if (null_true == top())
       explicit_null_checks_elided++;
     (*null_control) = null_true;
@@ -1378,7 +1378,7 @@
   // Object is already not-null?
   if( t == t_not_null ) return obj;
 
-  Node *cast = new (C) CastPPNode(obj,t_not_null);
+  Node *cast = new CastPPNode(obj,t_not_null);
   cast->init_req(0, control());
   cast = _gvn.transform( cast );
 
@@ -1486,7 +1486,7 @@
 
 //------------------------------set_all_memory_call----------------------------
 void GraphKit::set_all_memory_call(Node* call, bool separate_io_proj) {
-  Node* newmem = _gvn.transform( new (C) ProjNode(call, TypeFunc::Memory, separate_io_proj) );
+  Node* newmem = _gvn.transform( new ProjNode(call, TypeFunc::Memory, separate_io_proj) );
   set_all_memory(newmem);
 }
 
@@ -1721,9 +1721,9 @@
   int index_max = max_jint - 1;  // array size is max_jint, index is one less
   if (sizetype != NULL)  index_max = sizetype->_hi - 1;
   const TypeLong* lidxtype = TypeLong::make(CONST64(0), index_max, Type::WidenMax);
-  idx = _gvn.transform( new (C) ConvI2LNode(idx, lidxtype) );
+  idx = _gvn.transform( new ConvI2LNode(idx, lidxtype) );
 #endif
-  Node* scale = _gvn.transform( new (C) LShiftXNode(idx, intcon(shift)) );
+  Node* scale = _gvn.transform( new LShiftXNode(idx, intcon(shift)) );
   return basic_plus_adr(ary, base, scale);
 }
 
@@ -1771,8 +1771,8 @@
 
   // Re-use the current map to produce the result.
 
-  set_control(_gvn.transform(new (C) ProjNode(call, TypeFunc::Control)));
-  set_i_o(    _gvn.transform(new (C) ProjNode(call, TypeFunc::I_O    , separate_io_proj)));
+  set_control(_gvn.transform(new ProjNode(call, TypeFunc::Control)));
+  set_i_o(    _gvn.transform(new ProjNode(call, TypeFunc::I_O    , separate_io_proj)));
   set_all_memory_call(xcall, separate_io_proj);
 
   //return xcall;   // no need, caller already has it
@@ -1786,7 +1786,7 @@
   if (call->method() == NULL ||
       call->method()->return_type()->basic_type() == T_VOID)
         ret = top();
-  else  ret = _gvn.transform(new (C) ProjNode(call, TypeFunc::Parms));
+  else  ret = _gvn.transform(new ProjNode(call, TypeFunc::Parms));
 
   // Note:  Since any out-of-line call can produce an exception,
   // we always insert an I_O projection from the call into the result.
@@ -1797,8 +1797,8 @@
     // The caller requested separate projections be used by the fall
     // through and exceptional paths, so replace the projections for
     // the fall through path.
-    set_i_o(_gvn.transform( new (C) ProjNode(call, TypeFunc::I_O) ));
-    set_all_memory(_gvn.transform( new (C) ProjNode(call, TypeFunc::Memory) ));
+    set_i_o(_gvn.transform( new ProjNode(call, TypeFunc::I_O) ));
+    set_all_memory(_gvn.transform( new ProjNode(call, TypeFunc::Memory) ));
   }
   return ret;
 }
@@ -1838,13 +1838,13 @@
                                                       Node* keep_mem,
                                                       const TypePtr* hook_mem) {
   // no i/o
-  set_control(_gvn.transform( new (C) ProjNode(call,TypeFunc::Control) ));
+  set_control(_gvn.transform( new ProjNode(call,TypeFunc::Control) ));
   if (keep_mem) {
     // First clone the existing memory state
     set_all_memory(keep_mem);
     if (hook_mem != NULL) {
       // Make memory for the call
-      Node* mem = _gvn.transform( new (C) ProjNode(call, TypeFunc::Memory) );
+      Node* mem = _gvn.transform( new ProjNode(call, TypeFunc::Memory) );
       // Set the RawPtr memory state only.  This covers all the heap top/GC stuff
       // We also use hook_mem to extract specific effects from arraycopy stubs.
       set_memory(mem, hook_mem);
@@ -1968,7 +1968,7 @@
   int adr_type = Compile::AliasIdxRaw;
   Node* ctrl = control();
   Node* cnt  = make_load(ctrl, counter_addr, TypeInt::INT, T_INT, adr_type, MemNode::unordered);
-  Node* incr = _gvn.transform(new (C) AddINode(cnt, _gvn.intcon(1)));
+  Node* incr = _gvn.transform(new AddINode(cnt, _gvn.intcon(1)));
   store_to_memory(ctrl, counter_addr, incr, T_INT, adr_type, MemNode::unordered);
 }
 
@@ -2087,7 +2087,7 @@
   // The debug info is the only real input to this call.
 
   // Halt-and-catch fire here.  The above call should never return!
-  HaltNode* halt = new(C) HaltNode(control(), frameptr());
+  HaltNode* halt = new HaltNode(control(), frameptr());
   _gvn.set_type_bottom(halt);
   root()->add_req(halt);
 
@@ -2169,7 +2169,7 @@
     // the new type. The new type depends on the control: what
     // profiling tells us is only valid from here as far as we can
     // tell.
-    Node* cast = new(C) CheckCastPPNode(control(), n, current_type->remove_speculative()->join_speculative(spec_type));
+    Node* cast = new CheckCastPPNode(control(), n, current_type->remove_speculative()->join_speculative(spec_type));
     cast = _gvn.transform(cast);
     replace_in_map(n, cast);
     n = cast;
@@ -2287,7 +2287,7 @@
 Node* GraphKit::precision_rounding(Node* n) {
   return UseStrictFP && _method->flags().is_strict()
     && UseSSE == 0 && Matcher::strict_fp_requires_explicit_rounding
-    ? _gvn.transform( new (C) RoundFloatNode(0, n) )
+    ? _gvn.transform( new RoundFloatNode(0, n) )
     : n;
 }
 
@@ -2295,7 +2295,7 @@
 Node* GraphKit::dprecision_rounding(Node *n) {
   return UseStrictFP && _method->flags().is_strict()
     && UseSSE <= 1 && Matcher::strict_fp_requires_explicit_rounding
-    ? _gvn.transform( new (C) RoundDoubleNode(0, n) )
+    ? _gvn.transform( new RoundDoubleNode(0, n) )
     : n;
 }
 
@@ -2303,7 +2303,7 @@
 Node* GraphKit::dstore_rounding(Node* n) {
   return Matcher::strict_fp_requires_explicit_rounding
     && UseSSE <= 1
-    ? _gvn.transform( new (C) RoundDoubleNode(0, n) )
+    ? _gvn.transform( new RoundDoubleNode(0, n) )
     : n;
 }
 
@@ -2382,11 +2382,11 @@
   IfNode *opt_iff = _gvn.transform(iff)->as_If();
 
   // Fast path taken; set region slot 2
-  Node *fast_taken = _gvn.transform( new (C) IfFalseNode(opt_iff) );
+  Node *fast_taken = _gvn.transform( new IfFalseNode(opt_iff) );
   region->init_req(2,fast_taken); // Capture fast-control
 
   // Fast path not-taken, i.e. slow path
-  Node *slow_taken = _gvn.transform( new (C) IfTrueNode(opt_iff) );
+  Node *slow_taken = _gvn.transform( new IfTrueNode(opt_iff) );
   return slow_taken;
 }
 
@@ -2410,12 +2410,12 @@
   }
   CallNode* call;
   if (!is_leaf) {
-    call = new(C) CallStaticJavaNode(call_type, call_addr, call_name,
+    call = new CallStaticJavaNode(call_type, call_addr, call_name,
                                            bci(), adr_type);
   } else if (flags & RC_NO_FP) {
-    call = new(C) CallLeafNoFPNode(call_type, call_addr, call_name, adr_type);
+    call = new CallLeafNoFPNode(call_type, call_addr, call_name, adr_type);
   } else {
-    call = new(C) CallLeafNode(call_type, call_addr, call_name, adr_type);
+    call = new CallLeafNode(call_type, call_addr, call_name, adr_type);
   }
 
   // The following is similar to set_edges_for_java_call,
@@ -2476,7 +2476,7 @@
   }
 
   if (has_io) {
-    set_i_o(_gvn.transform(new (C) ProjNode(call, TypeFunc::I_O)));
+    set_i_o(_gvn.transform(new ProjNode(call, TypeFunc::I_O)));
   }
   return call;
 
@@ -2517,10 +2517,10 @@
   if (stopped())  return;
 
   // Make a catch node with just two handlers:  fall-through and catch-all
-  Node* i_o  = _gvn.transform( new (C) ProjNode(call, TypeFunc::I_O, separate_io_proj) );
-  Node* catc = _gvn.transform( new (C) CatchNode(control(), i_o, 2) );
-  Node* norm = _gvn.transform( new (C) CatchProjNode(catc, CatchProjNode::fall_through_index, CatchProjNode::no_handler_bci) );
-  Node* excp = _gvn.transform( new (C) CatchProjNode(catc, CatchProjNode::catch_all_index,    CatchProjNode::no_handler_bci) );
+  Node* i_o  = _gvn.transform( new ProjNode(call, TypeFunc::I_O, separate_io_proj) );
+  Node* catc = _gvn.transform( new CatchNode(control(), i_o, 2) );
+  Node* norm = _gvn.transform( new CatchProjNode(catc, CatchProjNode::fall_through_index, CatchProjNode::no_handler_bci) );
+  Node* excp = _gvn.transform( new CatchProjNode(catc, CatchProjNode::catch_all_index,    CatchProjNode::no_handler_bci) );
 
   { PreserveJVMState pjvms(this);
     set_control(excp);
@@ -2530,7 +2530,7 @@
       // Create an exception state also.
       // Use an exact type if the caller has specified a specific exception.
       const Type* ex_type = TypeOopPtr::make_from_klass_unique(ex_klass)->cast_to_ptr_type(TypePtr::NotNull);
-      Node*       ex_oop  = new (C) CreateExNode(ex_type, control(), i_o);
+      Node*       ex_oop  = new CreateExNode(ex_type, control(), i_o);
       add_exception_state(make_exception_state(_gvn.transform(ex_oop)));
     }
   }
@@ -2580,11 +2580,11 @@
     case SSC_easy_test:
       {
         // Just do a direct pointer compare and be done.
-        Node* cmp = _gvn.transform( new(C) CmpPNode(subklass, superklass) );
-        Node* bol = _gvn.transform( new(C) BoolNode(cmp, BoolTest::eq) );
+        Node* cmp = _gvn.transform( new CmpPNode(subklass, superklass) );
+        Node* bol = _gvn.transform( new BoolNode(cmp, BoolTest::eq) );
         IfNode* iff = create_and_xform_if(control(), bol, PROB_STATIC_FREQUENT, COUNT_UNKNOWN);
-        set_control( _gvn.transform( new(C) IfTrueNode (iff) ) );
-        return       _gvn.transform( new(C) IfFalseNode(iff) );
+        set_control( _gvn.transform( new IfTrueNode (iff) ) );
+        return       _gvn.transform( new IfFalseNode(iff) );
       }
     case SSC_full_test:
       break;
@@ -2599,7 +2599,7 @@
 
   // First load the super-klass's check-offset
   Node *p1 = basic_plus_adr( superklass, superklass, in_bytes(Klass::super_check_offset_offset()) );
-  Node *chk_off = _gvn.transform(new (C) LoadINode(NULL, memory(p1), p1, _gvn.type(p1)->is_ptr(),
+  Node *chk_off = _gvn.transform(new LoadINode(NULL, memory(p1), p1, _gvn.type(p1)->is_ptr(),
                                                    TypeInt::INT, MemNode::unordered));
   int cacheoff_con = in_bytes(Klass::secondary_super_cache_offset());
   bool might_be_cache = (find_int_con(chk_off, cacheoff_con) == cacheoff_con);
@@ -2611,7 +2611,7 @@
   // Worst-case type is a little odd: NULL is allowed as a result (usually
   // klass loads can never produce a NULL).
   Node *chk_off_X = ConvI2X(chk_off);
-  Node *p2 = _gvn.transform( new (C) AddPNode(subklass,subklass,chk_off_X) );
+  Node *p2 = _gvn.transform( new AddPNode(subklass,subklass,chk_off_X) );
   // For some types like interfaces the following loadKlass is from a 1-word
   // cache which is mutable so can't use immutable memory.  Other
   // types load from the super-class display table which is immutable.
@@ -2625,11 +2625,11 @@
   // See if we get an immediate positive hit.  Happens roughly 83% of the
   // time.  Test to see if the value loaded just previously from the subklass
   // is exactly the superklass.
-  Node *cmp1 = _gvn.transform( new (C) CmpPNode( superklass, nkls ) );
-  Node *bol1 = _gvn.transform( new (C) BoolNode( cmp1, BoolTest::eq ) );
+  Node *cmp1 = _gvn.transform( new CmpPNode( superklass, nkls ) );
+  Node *bol1 = _gvn.transform( new BoolNode( cmp1, BoolTest::eq ) );
   IfNode *iff1 = create_and_xform_if( control(), bol1, PROB_LIKELY(0.83f), COUNT_UNKNOWN );
-  Node *iftrue1 = _gvn.transform( new (C) IfTrueNode ( iff1 ) );
-  set_control(    _gvn.transform( new (C) IfFalseNode( iff1 ) ) );
+  Node *iftrue1 = _gvn.transform( new IfTrueNode ( iff1 ) );
+  set_control(    _gvn.transform( new IfFalseNode( iff1 ) ) );
 
   // Compile speed common case: Check for being deterministic right now.  If
   // chk_off is a constant and not equal to cacheoff then we are NOT a
@@ -2642,9 +2642,9 @@
   }
 
   // Gather the various success & failures here
-  RegionNode *r_ok_subtype = new (C) RegionNode(4);
+  RegionNode *r_ok_subtype = new RegionNode(4);
   record_for_igvn(r_ok_subtype);
-  RegionNode *r_not_subtype = new (C) RegionNode(3);
+  RegionNode *r_not_subtype = new RegionNode(3);
   record_for_igvn(r_not_subtype);
 
   r_ok_subtype->init_req(1, iftrue1);
@@ -2655,20 +2655,20 @@
   // cache.  If it points to the display (and NOT the cache) and the display
   // missed then it's not a subtype.
   Node *cacheoff = _gvn.intcon(cacheoff_con);
-  Node *cmp2 = _gvn.transform( new (C) CmpINode( chk_off, cacheoff ) );
-  Node *bol2 = _gvn.transform( new (C) BoolNode( cmp2, BoolTest::ne ) );
+  Node *cmp2 = _gvn.transform( new CmpINode( chk_off, cacheoff ) );
+  Node *bol2 = _gvn.transform( new BoolNode( cmp2, BoolTest::ne ) );
   IfNode *iff2 = create_and_xform_if( control(), bol2, PROB_LIKELY(0.63f), COUNT_UNKNOWN );
-  r_not_subtype->init_req(1, _gvn.transform( new (C) IfTrueNode (iff2) ) );
-  set_control(                _gvn.transform( new (C) IfFalseNode(iff2) ) );
+  r_not_subtype->init_req(1, _gvn.transform( new IfTrueNode (iff2) ) );
+  set_control(                _gvn.transform( new IfFalseNode(iff2) ) );
 
   // Check for self.  Very rare to get here, but it is taken 1/3 the time.
   // No performance impact (too rare) but allows sharing of secondary arrays
   // which has some footprint reduction.
-  Node *cmp3 = _gvn.transform( new (C) CmpPNode( subklass, superklass ) );
-  Node *bol3 = _gvn.transform( new (C) BoolNode( cmp3, BoolTest::eq ) );
+  Node *cmp3 = _gvn.transform( new CmpPNode( subklass, superklass ) );
+  Node *bol3 = _gvn.transform( new BoolNode( cmp3, BoolTest::eq ) );
   IfNode *iff3 = create_and_xform_if( control(), bol3, PROB_LIKELY(0.36f), COUNT_UNKNOWN );
-  r_ok_subtype->init_req(2, _gvn.transform( new (C) IfTrueNode ( iff3 ) ) );
-  set_control(               _gvn.transform( new (C) IfFalseNode( iff3 ) ) );
+  r_ok_subtype->init_req(2, _gvn.transform( new IfTrueNode ( iff3 ) ) );
+  set_control(               _gvn.transform( new IfFalseNode( iff3 ) ) );
 
   // -- Roads not taken here: --
   // We could also have chosen to perform the self-check at the beginning
@@ -2692,13 +2692,13 @@
   // The decision to inline or out-of-line this final check is platform
   // dependent, and is found in the AD file definition of PartialSubtypeCheck.
   Node* psc = _gvn.transform(
-    new (C) PartialSubtypeCheckNode(control(), subklass, superklass) );
-
-  Node *cmp4 = _gvn.transform( new (C) CmpPNode( psc, null() ) );
-  Node *bol4 = _gvn.transform( new (C) BoolNode( cmp4, BoolTest::ne ) );
+    new PartialSubtypeCheckNode(control(), subklass, superklass) );
+
+  Node *cmp4 = _gvn.transform( new CmpPNode( psc, null() ) );
+  Node *bol4 = _gvn.transform( new BoolNode( cmp4, BoolTest::ne ) );
   IfNode *iff4 = create_and_xform_if( control(), bol4, PROB_FAIR, COUNT_UNKNOWN );
-  r_not_subtype->init_req(2, _gvn.transform( new (C) IfTrueNode (iff4) ) );
-  r_ok_subtype ->init_req(3, _gvn.transform( new (C) IfFalseNode(iff4) ) );
+  r_not_subtype->init_req(2, _gvn.transform( new IfTrueNode (iff4) ) );
+  r_ok_subtype ->init_req(3, _gvn.transform( new IfFalseNode(iff4) ) );
 
   // Return false path; set default control to true path.
   set_control( _gvn.transform(r_ok_subtype) );
@@ -2762,18 +2762,18 @@
   const TypeKlassPtr* tklass = TypeKlassPtr::make(klass);
   Node* recv_klass = load_object_klass(receiver);
   Node* want_klass = makecon(tklass);
-  Node* cmp = _gvn.transform( new(C) CmpPNode(recv_klass, want_klass) );
-  Node* bol = _gvn.transform( new(C) BoolNode(cmp, BoolTest::eq) );
+  Node* cmp = _gvn.transform( new CmpPNode(recv_klass, want_klass) );
+  Node* bol = _gvn.transform( new BoolNode(cmp, BoolTest::eq) );
   IfNode* iff = create_and_xform_if(control(), bol, prob, COUNT_UNKNOWN);
-  set_control( _gvn.transform( new(C) IfTrueNode (iff) ));
-  Node* fail = _gvn.transform( new(C) IfFalseNode(iff) );
+  set_control( _gvn.transform( new IfTrueNode (iff) ));
+  Node* fail = _gvn.transform( new IfFalseNode(iff) );
 
   const TypeOopPtr* recv_xtype = tklass->as_instance_type();
   assert(recv_xtype->klass_is_exact(), "");
 
   // Subsume downstream occurrences of receiver with a cast to
   // recv_xtype, since now we know what the type will be.
-  Node* cast = new(C) CheckCastPPNode(control(), receiver, recv_xtype);
+  Node* cast = new CheckCastPPNode(control(), receiver, recv_xtype);
   (*casted_receiver) = _gvn.transform(cast);
   // (User must make the replace_in_map call.)
 
@@ -2920,8 +2920,8 @@
 
   // Make the merge point
   enum { _obj_path = 1, _fail_path, _null_path, PATH_LIMIT };
-  RegionNode* region = new(C) RegionNode(PATH_LIMIT);
-  Node*       phi    = new(C) PhiNode(region, TypeInt::BOOL);
+  RegionNode* region = new RegionNode(PATH_LIMIT);
+  Node*       phi    = new PhiNode(region, TypeInt::BOOL);
   C->set_has_split_ifs(true); // Has chance for split-if optimization
 
   ciProfileData* data = NULL;
@@ -3052,8 +3052,8 @@
 
   // Make the merge point
   enum { _obj_path = 1, _null_path, PATH_LIMIT };
-  RegionNode* region = new (C) RegionNode(PATH_LIMIT);
-  Node*       phi    = new (C) PhiNode(region, toop);
+  RegionNode* region = new RegionNode(PATH_LIMIT);
+  Node*       phi    = new PhiNode(region, toop);
   C->set_has_split_ifs(true); // Has chance for split-if optimization
 
   // Use null-cast information if it is available
@@ -3114,8 +3114,7 @@
     Node* not_subtype_ctrl = gen_subtype_check( obj_klass, superklass );
 
     // Plug in success path into the merge
-    cast_obj = _gvn.transform(new (C) CheckCastPPNode(control(),
-                                                         not_null_obj, toop));
+    cast_obj = _gvn.transform(new CheckCastPPNode(control(), not_null_obj, toop));
     // Failure path ends in uncommon trap (or may be dead - failure impossible)
     if (failure_control == NULL) {
       if (not_subtype_ctrl != top()) { // If failure is possible
@@ -3168,7 +3167,7 @@
   mb->init_req(TypeFunc::Control, control());
   mb->init_req(TypeFunc::Memory,  reset_memory());
   Node* membar = _gvn.transform(mb);
-  set_control(_gvn.transform(new (C) ProjNode(membar, TypeFunc::Control)));
+  set_control(_gvn.transform(new ProjNode(membar, TypeFunc::Control)));
   set_all_memory_call(membar);
   return membar;
 }
@@ -3197,11 +3196,11 @@
     mb->set_req(TypeFunc::Memory, memory(alias_idx));
   }
   Node* membar = _gvn.transform(mb);
-  set_control(_gvn.transform(new (C) ProjNode(membar, TypeFunc::Control)));
+  set_control(_gvn.transform(new ProjNode(membar, TypeFunc::Control)));
   if (alias_idx == Compile::AliasIdxBot) {
-    merged_memory()->set_base_memory(_gvn.transform(new (C) ProjNode(membar, TypeFunc::Memory)));
+    merged_memory()->set_base_memory(_gvn.transform(new ProjNode(membar, TypeFunc::Memory)));
   } else {
-    set_memory(_gvn.transform(new (C) ProjNode(membar, TypeFunc::Memory)),alias_idx);
+    set_memory(_gvn.transform(new ProjNode(membar, TypeFunc::Memory)),alias_idx);
   }
   return membar;
 }
@@ -3221,10 +3220,10 @@
   assert(dead_locals_are_killed(), "should kill locals before sync. point");
 
   // Box the stack location
-  Node* box = _gvn.transform(new (C) BoxLockNode(next_monitor()));
+  Node* box = _gvn.transform(new BoxLockNode(next_monitor()));
   Node* mem = reset_memory();
 
-  FastLockNode * flock = _gvn.transform(new (C) FastLockNode(0, obj, box) )->as_FastLock();
+  FastLockNode * flock = _gvn.transform(new FastLockNode(0, obj, box) )->as_FastLock();
   if (UseBiasedLocking && PrintPreciseBiasedLockingStatistics) {
     // Create the counters for this fast lock.
     flock->create_lock_counter(sync_jvms()); // sync_jvms used to get current bci
@@ -3238,7 +3237,7 @@
   map()->push_monitor( flock );
 
   const TypeFunc *tf = LockNode::lock_type();
-  LockNode *lock = new (C) LockNode(C, tf);
+  LockNode *lock = new LockNode(C, tf);
 
   lock->init_req( TypeFunc::Control, control() );
   lock->init_req( TypeFunc::Memory , mem );
@@ -3292,7 +3291,7 @@
   insert_mem_bar(Op_MemBarReleaseLock);
 
   const TypeFunc *tf = OptoRuntime::complete_monitor_exit_Type();
-  UnlockNode *unlock = new (C) UnlockNode(C, tf);
+  UnlockNode *unlock = new UnlockNode(C, tf);
   uint raw_idx = Compile::AliasIdxRaw;
   unlock->init_req( TypeFunc::Control, control() );
   unlock->init_req( TypeFunc::Memory , memory(raw_idx) );
@@ -3358,19 +3357,19 @@
   alloc->set_req( TypeFunc::FramePtr, frameptr() );
   add_safepoint_edges(alloc);
   Node* allocx = _gvn.transform(alloc);
-  set_control( _gvn.transform(new (C) ProjNode(allocx, TypeFunc::Control) ) );
+  set_control( _gvn.transform(new ProjNode(allocx, TypeFunc::Control) ) );
   // create memory projection for i_o
-  set_memory ( _gvn.transform( new (C) ProjNode(allocx, TypeFunc::Memory, true) ), rawidx );
+  set_memory ( _gvn.transform( new ProjNode(allocx, TypeFunc::Memory, true) ), rawidx );
   make_slow_call_ex(allocx, env()->Throwable_klass(), true);
 
   // create a memory projection as for the normal control path
-  Node* malloc = _gvn.transform(new (C) ProjNode(allocx, TypeFunc::Memory));
+  Node* malloc = _gvn.transform(new ProjNode(allocx, TypeFunc::Memory));
   set_memory(malloc, rawidx);
 
   // a normal slow-call doesn't change i_o, but an allocation does
   // we create a separate i_o projection for the normal control path
-  set_i_o(_gvn.transform( new (C) ProjNode(allocx, TypeFunc::I_O, false) ) );
-  Node* rawoop = _gvn.transform( new (C) ProjNode(allocx, TypeFunc::Parms) );
+  set_i_o(_gvn.transform( new ProjNode(allocx, TypeFunc::I_O, false) ) );
+  Node* rawoop = _gvn.transform( new ProjNode(allocx, TypeFunc::Parms) );
 
   // put in an initialization barrier
   InitializeNode* init = insert_mem_bar_volatile(Op_Initialize, rawidx,
@@ -3406,7 +3405,7 @@
   }
 
   // Cast raw oop to the real thing...
-  Node* javaoop = new (C) CheckCastPPNode(control(), rawoop, oop_type);
+  Node* javaoop = new CheckCastPPNode(control(), rawoop, oop_type);
   javaoop = _gvn.transform(javaoop);
   C->set_recent_alloc(control(), javaoop);
   assert(just_allocated_object(control()) == javaoop, "just allocated");
@@ -3465,9 +3464,9 @@
     // (It may be stress-tested by specifying StressReflectiveCode.)
     // Basically, we want to get into the VM is there's an illegal argument.
     Node* bit = intcon(Klass::_lh_instance_slow_path_bit);
-    initial_slow_test = _gvn.transform( new (C) AndINode(layout_val, bit) );
+    initial_slow_test = _gvn.transform( new AndINode(layout_val, bit) );
     if (extra_slow_test != intcon(0)) {
-      initial_slow_test = _gvn.transform( new (C) OrINode(initial_slow_test, extra_slow_test) );
+      initial_slow_test = _gvn.transform( new OrINode(initial_slow_test, extra_slow_test) );
     }
     // (Macro-expander will further convert this to a Bool, if necessary.)
   }
@@ -3484,7 +3483,7 @@
     // Clear the low bits to extract layout_helper_size_in_bytes:
     assert((int)Klass::_lh_instance_slow_path_bit < BytesPerLong, "clear bit");
     Node* mask = MakeConX(~ (intptr_t)right_n_bits(LogBytesPerLong));
-    size = _gvn.transform( new (C) AndXNode(size, mask) );
+    size = _gvn.transform( new AndXNode(size, mask) );
   }
   if (return_size_val != NULL) {
     (*return_size_val) = size;
@@ -3504,11 +3503,10 @@
   Node *mem = reset_memory();
   set_all_memory(mem); // Create new memory state
 
-  AllocateNode* alloc
-    = new (C) AllocateNode(C, AllocateNode::alloc_type(Type::TOP),
-                           control(), mem, i_o(),
-                           size, klass_node,
-                           initial_slow_test);
+  AllocateNode* alloc = new AllocateNode(C, AllocateNode::alloc_type(Type::TOP),
+                                         control(), mem, i_o(),
+                                         size, klass_node,
+                                         initial_slow_test);
 
   return set_output_for_allocation(alloc, oop_type);
 }
@@ -3531,8 +3529,8 @@
     // Optimistically assume that it is a subtype of Object[],
     // so that we can fold up all the address arithmetic.
     layout_con = Klass::array_layout_helper(T_OBJECT);
-    Node* cmp_lh = _gvn.transform( new(C) CmpINode(layout_val, intcon(layout_con)) );
-    Node* bol_lh = _gvn.transform( new(C) BoolNode(cmp_lh, BoolTest::eq) );
+    Node* cmp_lh = _gvn.transform( new CmpINode(layout_val, intcon(layout_con)) );
+    Node* bol_lh = _gvn.transform( new BoolNode(cmp_lh, BoolTest::eq) );
     { BuildCutout unless(this, bol_lh, PROB_MAX);
       inc_sp(nargs);
       uncommon_trap(Deoptimization::Reason_class_check,
@@ -3556,8 +3554,8 @@
     fast_size_limit <<= (LogBytesPerLong - log2_esize);
   }
 
-  Node* initial_slow_cmp  = _gvn.transform( new (C) CmpUNode( length, intcon( fast_size_limit ) ) );
-  Node* initial_slow_test = _gvn.transform( new (C) BoolNode( initial_slow_cmp, BoolTest::gt ) );
+  Node* initial_slow_cmp  = _gvn.transform( new CmpUNode( length, intcon( fast_size_limit ) ) );
+  Node* initial_slow_test = _gvn.transform( new BoolNode( initial_slow_cmp, BoolTest::gt ) );
   if (initial_slow_test->is_Bool()) {
     // Hide it behind a CMoveI, or else PhaseIdealLoop::split_up will get sick.
     initial_slow_test = initial_slow_test->as_Bool()->as_int_value(&_gvn);
@@ -3585,10 +3583,10 @@
   } else {
     Node* hss   = intcon(Klass::_lh_header_size_shift);
     Node* hsm   = intcon(Klass::_lh_header_size_mask);
-    Node* hsize = _gvn.transform( new(C) URShiftINode(layout_val, hss) );
-    hsize       = _gvn.transform( new(C) AndINode(hsize, hsm) );
+    Node* hsize = _gvn.transform( new URShiftINode(layout_val, hss) );
+    hsize       = _gvn.transform( new AndINode(hsize, hsm) );
     Node* mask  = intcon(round_mask);
-    header_size = _gvn.transform( new(C) AddINode(hsize, mask) );
+    header_size = _gvn.transform( new AddINode(hsize, mask) );
   }
 
   Node* elem_shift = NULL;
@@ -3613,7 +3611,7 @@
       jlong size_max = arrayOopDesc::max_array_length(T_BYTE);
       if (size_max > tllen->_hi)  size_max = tllen->_hi;
       const TypeLong* tlcon = TypeLong::make(CONST64(0), size_max, Type::WidenMin);
-      lengthx = _gvn.transform( new (C) ConvI2LNode(length, tlcon));
+      lengthx = _gvn.transform( new ConvI2LNode(length, tlcon));
     }
   }
 #endif
@@ -3624,11 +3622,11 @@
   // after a successful allocation.
   Node* abody = lengthx;
   if (elem_shift != NULL)
-    abody     = _gvn.transform( new(C) LShiftXNode(lengthx, elem_shift) );
-  Node* size  = _gvn.transform( new(C) AddXNode(headerx, abody) );
+    abody     = _gvn.transform( new LShiftXNode(lengthx, elem_shift) );
+  Node* size  = _gvn.transform( new AddXNode(headerx, abody) );
   if (round_mask != 0) {
     Node* mask = MakeConX(~round_mask);
-    size       = _gvn.transform( new(C) AndXNode(size, mask) );
+    size       = _gvn.transform( new AndXNode(size, mask) );
   }
   // else if round_mask == 0, the size computation is self-rounding
 
@@ -3646,11 +3644,11 @@
 
   // Create the AllocateArrayNode and its result projections
   AllocateArrayNode* alloc
-    = new (C) AllocateArrayNode(C, AllocateArrayNode::alloc_type(TypeInt::INT),
-                                control(), mem, i_o(),
-                                size, klass_node,
-                                initial_slow_test,
-                                length);
+    = new AllocateArrayNode(C, AllocateArrayNode::alloc_type(TypeInt::INT),
+                            control(), mem, i_o(),
+                            size, klass_node,
+                            initial_slow_test,
+                            length);
 
   // Cast to correct type.  Note that the klass_node may be constant or not,
   // and in the latter case the actual array type will be inexact also.
@@ -3760,10 +3758,10 @@
   }
 
   Node *cont    = _gvn.intcon(1);
-  Node* opq     = _gvn.transform(new (C) Opaque1Node(C, cont));
-  Node *bol     = _gvn.transform(new (C) Conv2BNode(opq));
+  Node* opq     = _gvn.transform(new Opaque1Node(C, cont));
+  Node *bol     = _gvn.transform(new Conv2BNode(opq));
   IfNode* iff   = create_and_map_if(control(), bol, PROB_MAX, COUNT_UNKNOWN);
-  Node* iffalse = _gvn.transform(new (C) IfFalseNode(iff));
+  Node* iffalse = _gvn.transform(new IfFalseNode(iff));
   C->add_predicate_opaq(opq);
   {
     PreserveJVMState pjvms(this);
@@ -3771,7 +3769,7 @@
     inc_sp(nargs);
     uncommon_trap(reason, Deoptimization::Action_maybe_recompile);
   }
-  Node* iftrue = _gvn.transform(new (C) IfTrueNode(iff));
+  Node* iftrue = _gvn.transform(new IfTrueNode(iff));
   set_control(iftrue);
 }
 
@@ -3963,7 +3961,7 @@
       __ if_then(index, BoolTest::ne, zeroX, likely); {
 
         // decrement the index
-        Node* next_index = _gvn.transform(new (C) SubXNode(index, __ ConX(sizeof(intptr_t))));
+        Node* next_index = _gvn.transform(new SubXNode(index, __ ConX(sizeof(intptr_t))));
 
         // Now get the buffer location we will log the previous value into and store it
         Node *log_addr = __ AddP(no_base, buffer, next_index);
@@ -4006,7 +4004,7 @@
   //  Now do the queue work
   __ if_then(index, BoolTest::ne, zeroX); {
 
-    Node* next_index = _gvn.transform(new (C) SubXNode(index, __ ConX(sizeof(intptr_t))));
+    Node* next_index = _gvn.transform(new SubXNode(index, __ ConX(sizeof(intptr_t))));
     Node* log_addr = __ AddP(no_base, buffer, next_index);
 
     // Order, see storeCM.
@@ -4213,5 +4211,5 @@
 Node* GraphKit::cast_array_to_stable(Node* ary, const TypeAryPtr* ary_type) {
   // Reify the property as a CastPP node in Ideal graph to comply with monotonicity
   // assumption of CCP analysis.
-  return _gvn.transform(new(C) CastPPNode(ary, ary_type->cast_to_stable(true)));
+  return _gvn.transform(new CastPPNode(ary, ary_type->cast_to_stable(true)));
 }