--- old/src/share/vm/opto/graphKit.cpp 2014-05-15 17:09:28.210522803 +0200 +++ new/src/share/vm/opto/graphKit.cpp 2014-05-15 17:09:27.878522819 +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) ); + new PartialSubtypeCheckNode(control(), subklass, superklass) ); - Node *cmp4 = _gvn.transform( new (C) CmpPNode( psc, null() ) ); - Node *bol4 = _gvn.transform( new (C) BoolNode( cmp4, BoolTest::ne ) ); + 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))); }