archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-28 23:34:52 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8034812: remove IDX_INIT macro hack in Node class

Browse source 
The IDX_INIT macro used by Node::Node(...) to retrieve the Compile object is removed and replaced by a call to Compile::current(). The Node constructor, new operator and all calls to it are adapted accordingly.

Reviewed-by: kvn, jrose, iveresov, goetz
This commit is contained in:
Tobias Hartmann 2014-06-02 08:07:29 +02:00
parent b053fa4c48
commit 2a0815a55e
51 changed files with 1659 additions and 1686 deletions
Download patch file Download diff file Expand all files Collapse all files

188
hotspot/src/cpu/ppc/vm/ppc.ad
View file

@ -1285,9 +1285,9 @@ bool MachConstantBaseNode::requires_postalloc_expand() const { return true; }
void MachConstantBaseNode::postalloc_expand(GrowableArray <Node *> *nodes, PhaseRegAlloc *ra_) { void MachConstantBaseNode::postalloc_expand(GrowableArray <Node *> *nodes, PhaseRegAlloc *ra_) {
Compile *C = ra_->C; Compile *C = ra_->C;
iRegPdstOper *op_dst = new (C) iRegPdstOper(); iRegPdstOper *op_dst = new iRegPdstOper();
MachNode *m1 = new (C) loadToc_hiNode(); MachNode *m1 = new loadToc_hiNode();
MachNode *m2 = new (C) loadToc_loNode(); MachNode *m2 = new loadToc_loNode();
m1->add_req(NULL); m1->add_req(NULL);
m2->add_req(NULL, m1); m2->add_req(NULL, m1);
@ -2232,9 +2232,9 @@ const bool Matcher::isSimpleConstant64(jlong value) {
MachTypeNode *Matcher::make_decode_node(Compile *C) { MachTypeNode *Matcher::make_decode_node(Compile *C) {
assert(Universe::narrow_oop_base() == NULL && Universe::narrow_oop_shift() == 0, assert(Universe::narrow_oop_base() == NULL && Universe::narrow_oop_shift() == 0,
"This method is only implemented for unscaled cOops mode so far"); "This method is only implemented for unscaled cOops mode so far");
MachTypeNode *decode = new (C) decodeN_unscaledNode(); MachTypeNode *decode = new decodeN_unscaledNode();
decode->set_opnd_array(0, new (C) iRegPdstOper()); decode->set_opnd_array(0, new iRegPdstOper());
decode->set_opnd_array(1, new (C) iRegNsrcOper()); decode->set_opnd_array(1, new iRegNsrcOper());
return decode; return decode;
} }
*/ */
@ -2600,20 +2600,20 @@ loadConLNodesTuple loadConLNodesTuple_create(Compile *C, PhaseRegAlloc *ra_, Nod
const bool large_constant_pool = true; // TODO: PPC port C->cfg()->_consts_size > 4000; const bool large_constant_pool = true; // TODO: PPC port C->cfg()->_consts_size > 4000;
if (large_constant_pool) { if (large_constant_pool) {
// Create new nodes. // Create new nodes.
loadConL_hiNode *m1 = new (C) loadConL_hiNode(); loadConL_hiNode *m1 = new loadConL_hiNode();
loadConL_loNode *m2 = new (C) loadConL_loNode(); loadConL_loNode *m2 = new loadConL_loNode();
// inputs for new nodes // inputs for new nodes
m1->add_req(NULL, toc); m1->add_req(NULL, toc);
m2->add_req(NULL, m1); m2->add_req(NULL, m1);
// operands for new nodes // operands for new nodes
m1->_opnds[0] = new (C) iRegLdstOper(); // dst m1->_opnds[0] = new iRegLdstOper(); // dst
m1->_opnds[1] = immSrc; // src m1->_opnds[1] = immSrc; // src
m1->_opnds[2] = new (C) iRegPdstOper(); // toc m1->_opnds[2] = new iRegPdstOper(); // toc
m2->_opnds[0] = new (C) iRegLdstOper(); // dst m2->_opnds[0] = new iRegLdstOper(); // dst
m2->_opnds[1] = immSrc; // src m2->_opnds[1] = immSrc; // src
m2->_opnds[2] = new (C) iRegLdstOper(); // base m2->_opnds[2] = new iRegLdstOper(); // base
// Initialize ins_attrib TOC fields. // Initialize ins_attrib TOC fields.
m1->_const_toc_offset = -1; m1->_const_toc_offset = -1;
@ -2633,15 +2633,15 @@ loadConLNodesTuple loadConLNodesTuple_create(Compile *C, PhaseRegAlloc *ra_, Nod
nodes._last = nodes._large_lo; nodes._last = nodes._large_lo;
assert(m2->bottom_type()->isa_long(), "must be long"); assert(m2->bottom_type()->isa_long(), "must be long");
} else { } else {
loadConLNode *m2 = new (C) loadConLNode(); loadConLNode *m2 = new loadConLNode();
// inputs for new nodes // inputs for new nodes
m2->add_req(NULL, toc); m2->add_req(NULL, toc);
// operands for new nodes // operands for new nodes
m2->_opnds[0] = new (C) iRegLdstOper(); // dst m2->_opnds[0] = new iRegLdstOper(); // dst
m2->_opnds[1] = immSrc; // src m2->_opnds[1] = immSrc; // src
m2->_opnds[2] = new (C) iRegPdstOper(); // toc m2->_opnds[2] = new iRegPdstOper(); // toc
// Initialize ins_attrib instruction offset. // Initialize ins_attrib instruction offset.
m2->_cbuf_insts_offset = -1; m2->_cbuf_insts_offset = -1;
@ -2750,20 +2750,20 @@ encode %{
const bool large_constant_pool = true; // TODO: PPC port C->cfg()->_consts_size > 4000; const bool large_constant_pool = true; // TODO: PPC port C->cfg()->_consts_size > 4000;
if (large_constant_pool) { if (large_constant_pool) {
// Create new nodes. // Create new nodes.
loadConP_hiNode *m1 = new (C) loadConP_hiNode(); loadConP_hiNode *m1 = new loadConP_hiNode();
loadConP_loNode *m2 = new (C) loadConP_loNode(); loadConP_loNode *m2 = new loadConP_loNode();
// inputs for new nodes // inputs for new nodes
m1->add_req(NULL, n_toc); m1->add_req(NULL, n_toc);
m2->add_req(NULL, m1); m2->add_req(NULL, m1);
// operands for new nodes // operands for new nodes
m1->_opnds[0] = new (C) iRegPdstOper(); // dst m1->_opnds[0] = new iRegPdstOper(); // dst
m1->_opnds[1] = op_src; // src m1->_opnds[1] = op_src; // src
m1->_opnds[2] = new (C) iRegPdstOper(); // toc m1->_opnds[2] = new iRegPdstOper(); // toc
m2->_opnds[0] = new (C) iRegPdstOper(); // dst m2->_opnds[0] = new iRegPdstOper(); // dst
m2->_opnds[1] = op_src; // src m2->_opnds[1] = op_src; // src
m2->_opnds[2] = new (C) iRegLdstOper(); // base m2->_opnds[2] = new iRegLdstOper(); // base
// Initialize ins_attrib TOC fields. // Initialize ins_attrib TOC fields.
m1->_const_toc_offset = -1; m1->_const_toc_offset = -1;
@ -2777,15 +2777,15 @@ encode %{
nodes->push(m2); nodes->push(m2);
assert(m2->bottom_type()->isa_ptr(), "must be ptr"); assert(m2->bottom_type()->isa_ptr(), "must be ptr");
} else { } else {
loadConPNode *m2 = new (C) loadConPNode(); loadConPNode *m2 = new loadConPNode();
// inputs for new nodes // inputs for new nodes
m2->add_req(NULL, n_toc); m2->add_req(NULL, n_toc);
// operands for new nodes // operands for new nodes
m2->_opnds[0] = new (C) iRegPdstOper(); // dst m2->_opnds[0] = new iRegPdstOper(); // dst
m2->_opnds[1] = op_src; // src m2->_opnds[1] = op_src; // src
m2->_opnds[2] = new (C) iRegPdstOper(); // toc m2->_opnds[2] = new iRegPdstOper(); // toc
// Register allocation for new nodes. // Register allocation for new nodes.
ra_->set_pair(m2->_idx, ra_->get_reg_second(this), ra_->get_reg_first(this)); ra_->set_pair(m2->_idx, ra_->get_reg_second(this), ra_->get_reg_first(this));
@ -2802,9 +2802,9 @@ encode %{
MachNode *m2; MachNode *m2;
if (large_constant_pool) { if (large_constant_pool) {
m2 = new (C) loadConFCompNode(); m2 = new loadConFCompNode();
} else { } else {
m2 = new (C) loadConFNode(); m2 = new loadConFNode();
} }
// inputs for new nodes // inputs for new nodes
m2->add_req(NULL, n_toc); m2->add_req(NULL, n_toc);
@ -2812,7 +2812,7 @@ encode %{
// operands for new nodes // operands for new nodes
m2->_opnds[0] = op_dst; m2->_opnds[0] = op_dst;
m2->_opnds[1] = op_src; m2->_opnds[1] = op_src;
m2->_opnds[2] = new (C) iRegPdstOper(); // constanttablebase m2->_opnds[2] = new iRegPdstOper(); // constanttablebase
// register allocation for new nodes // register allocation for new nodes
ra_->set_pair(m2->_idx, ra_->get_reg_second(this), ra_->get_reg_first(this)); ra_->set_pair(m2->_idx, ra_->get_reg_second(this), ra_->get_reg_first(this));
@ -2826,9 +2826,9 @@ encode %{
MachNode *m2; MachNode *m2;
if (large_constant_pool) { if (large_constant_pool) {
m2 = new (C) loadConDCompNode(); m2 = new loadConDCompNode();
} else { } else {
m2 = new (C) loadConDNode(); m2 = new loadConDNode();
} }
// inputs for new nodes // inputs for new nodes
m2->add_req(NULL, n_toc); m2->add_req(NULL, n_toc);
@ -2836,7 +2836,7 @@ encode %{
// operands for new nodes // operands for new nodes
m2->_opnds[0] = op_dst; m2->_opnds[0] = op_dst;
m2->_opnds[1] = op_src; m2->_opnds[1] = op_src;
m2->_opnds[2] = new (C) iRegPdstOper(); // constanttablebase m2->_opnds[2] = new iRegPdstOper(); // constanttablebase
// register allocation for new nodes // register allocation for new nodes
ra_->set_pair(m2->_idx, ra_->get_reg_second(this), ra_->get_reg_first(this)); ra_->set_pair(m2->_idx, ra_->get_reg_second(this), ra_->get_reg_first(this));
@ -2918,15 +2918,15 @@ encode %{
if (VM_Version::has_isel()) { if (VM_Version::has_isel()) {
// use isel instruction with Power 7 // use isel instruction with Power 7
cmpP_reg_imm16Node *n_compare = new (C) cmpP_reg_imm16Node(); cmpP_reg_imm16Node *n_compare = new cmpP_reg_imm16Node();
encodeP_subNode *n_sub_base = new (C) encodeP_subNode(); encodeP_subNode *n_sub_base = new encodeP_subNode();
encodeP_shiftNode *n_shift = new (C) encodeP_shiftNode(); encodeP_shiftNode *n_shift = new encodeP_shiftNode();
cond_set_0_oopNode *n_cond_set = new (C) cond_set_0_oopNode(); cond_set_0_oopNode *n_cond_set = new cond_set_0_oopNode();
n_compare->add_req(n_region, n_src); n_compare->add_req(n_region, n_src);
n_compare->_opnds[0] = op_crx; n_compare->_opnds[0] = op_crx;
n_compare->_opnds[1] = op_src; n_compare->_opnds[1] = op_src;
n_compare->_opnds[2] = new (C) immL16Oper(0); n_compare->_opnds[2] = new immL16Oper(0);
n_sub_base->add_req(n_region, n_src); n_sub_base->add_req(n_region, n_src);
n_sub_base->_opnds[0] = op_dst; n_sub_base->_opnds[0] = op_dst;
@ -2956,10 +2956,10 @@ encode %{
} else { } else {
// before Power 7 // before Power 7
moveRegNode *n_move = new (C) moveRegNode(); moveRegNode *n_move = new moveRegNode();
cmpP_reg_imm16Node *n_compare = new (C) cmpP_reg_imm16Node(); cmpP_reg_imm16Node *n_compare = new cmpP_reg_imm16Node();
encodeP_shiftNode *n_shift = new (C) encodeP_shiftNode(); encodeP_shiftNode *n_shift = new encodeP_shiftNode();
cond_sub_baseNode *n_sub_base = new (C) cond_sub_baseNode(); cond_sub_baseNode *n_sub_base = new cond_sub_baseNode();
n_move->add_req(n_region, n_src); n_move->add_req(n_region, n_src);
n_move->_opnds[0] = op_dst; n_move->_opnds[0] = op_dst;
@ -2971,7 +2971,7 @@ encode %{
n_compare->_opnds[0] = op_crx; n_compare->_opnds[0] = op_crx;
n_compare->_opnds[1] = op_src; n_compare->_opnds[1] = op_src;
n_compare->_opnds[2] = new (C) immL16Oper(0); n_compare->_opnds[2] = new immL16Oper(0);
n_sub_base->add_req(n_region, n_compare, n_src); n_sub_base->add_req(n_region, n_compare, n_src);
n_sub_base->_opnds[0] = op_dst; n_sub_base->_opnds[0] = op_dst;
@ -3000,13 +3000,13 @@ encode %{
enc_class postalloc_expand_encode_oop_not_null(iRegNdst dst, iRegPdst src) %{ enc_class postalloc_expand_encode_oop_not_null(iRegNdst dst, iRegPdst src) %{
encodeP_subNode *n1 = new (C) encodeP_subNode(); encodeP_subNode *n1 = new encodeP_subNode();
n1->add_req(n_region, n_src); n1->add_req(n_region, n_src);
n1->_opnds[0] = op_dst; n1->_opnds[0] = op_dst;
n1->_opnds[1] = op_src; n1->_opnds[1] = op_src;
n1->_bottom_type = _bottom_type; n1->_bottom_type = _bottom_type;
encodeP_shiftNode *n2 = new (C) encodeP_shiftNode(); encodeP_shiftNode *n2 = new encodeP_shiftNode();
n2->add_req(n_region, n1); n2->add_req(n_region, n1);
n2->_opnds[0] = op_dst; n2->_opnds[0] = op_dst;
n2->_opnds[1] = op_dst; n2->_opnds[1] = op_dst;
@ -3020,13 +3020,13 @@ encode %{
%} %}
enc_class postalloc_expand_decode_oop(iRegPdst dst, iRegNsrc src, flagsReg crx) %{ enc_class postalloc_expand_decode_oop(iRegPdst dst, iRegNsrc src, flagsReg crx) %{
decodeN_shiftNode *n_shift = new (C) decodeN_shiftNode(); decodeN_shiftNode *n_shift = new decodeN_shiftNode();
cmpN_reg_imm0Node *n_compare = new (C) cmpN_reg_imm0Node(); cmpN_reg_imm0Node *n_compare = new cmpN_reg_imm0Node();
n_compare->add_req(n_region, n_src); n_compare->add_req(n_region, n_src);
n_compare->_opnds[0] = op_crx; n_compare->_opnds[0] = op_crx;
n_compare->_opnds[1] = op_src; n_compare->_opnds[1] = op_src;
n_compare->_opnds[2] = new (C) immN_0Oper(TypeNarrowOop::NULL_PTR); n_compare->_opnds[2] = new immN_0Oper(TypeNarrowOop::NULL_PTR);
n_shift->add_req(n_region, n_src); n_shift->add_req(n_region, n_src);
n_shift->_opnds[0] = op_dst; n_shift->_opnds[0] = op_dst;
@ -3036,13 +3036,13 @@ encode %{
if (VM_Version::has_isel()) { if (VM_Version::has_isel()) {
// use isel instruction with Power 7 // use isel instruction with Power 7
decodeN_addNode *n_add_base = new (C) decodeN_addNode(); decodeN_addNode *n_add_base = new decodeN_addNode();
n_add_base->add_req(n_region, n_shift); n_add_base->add_req(n_region, n_shift);
n_add_base->_opnds[0] = op_dst; n_add_base->_opnds[0] = op_dst;
n_add_base->_opnds[1] = op_dst; n_add_base->_opnds[1] = op_dst;
n_add_base->_bottom_type = _bottom_type; n_add_base->_bottom_type = _bottom_type;
cond_set_0_ptrNode *n_cond_set = new (C) cond_set_0_ptrNode(); cond_set_0_ptrNode *n_cond_set = new cond_set_0_ptrNode();
n_cond_set->add_req(n_region, n_compare, n_add_base); n_cond_set->add_req(n_region, n_compare, n_add_base);
n_cond_set->_opnds[0] = op_dst; n_cond_set->_opnds[0] = op_dst;
n_cond_set->_opnds[1] = op_crx; n_cond_set->_opnds[1] = op_crx;
@ -3064,7 +3064,7 @@ encode %{
} else { } else {
// before Power 7 // before Power 7
cond_add_baseNode *n_add_base = new (C) cond_add_baseNode(); cond_add_baseNode *n_add_base = new cond_add_baseNode();
n_add_base->add_req(n_region, n_compare, n_shift); n_add_base->add_req(n_region, n_compare, n_shift);
n_add_base->_opnds[0] = op_dst; n_add_base->_opnds[0] = op_dst;
@ -3086,13 +3086,13 @@ encode %{
%} %}
enc_class postalloc_expand_decode_oop_not_null(iRegPdst dst, iRegNsrc src) %{ enc_class postalloc_expand_decode_oop_not_null(iRegPdst dst, iRegNsrc src) %{
decodeN_shiftNode *n1 = new (C) decodeN_shiftNode(); decodeN_shiftNode *n1 = new decodeN_shiftNode();
n1->add_req(n_region, n_src); n1->add_req(n_region, n_src);
n1->_opnds[0] = op_dst; n1->_opnds[0] = op_dst;
n1->_opnds[1] = op_src; n1->_opnds[1] = op_src;
n1->_bottom_type = _bottom_type; n1->_bottom_type = _bottom_type;
decodeN_addNode *n2 = new (C) decodeN_addNode(); decodeN_addNode *n2 = new decodeN_addNode();
n2->add_req(n_region, n1); n2->add_req(n_region, n1);
n2->_opnds[0] = op_dst; n2->_opnds[0] = op_dst;
n2->_opnds[1] = op_dst; n2->_opnds[1] = op_dst;
@ -3388,7 +3388,7 @@ encode %{
// Create new nodes. // Create new nodes.
// Make an operand with the bit pattern to load as float. // Make an operand with the bit pattern to load as float.
immLOper *op_repl = new (C) immLOper((jlong)replicate_immF(op_src->constantF())); immLOper *op_repl = new immLOper((jlong)replicate_immF(op_src->constantF()));
loadConLNodesTuple loadConLNodes = loadConLNodesTuple loadConLNodes =
loadConLNodesTuple_create(C, ra_, n_toc, op_repl, loadConLNodesTuple_create(C, ra_, n_toc, op_repl,
@ -3611,11 +3611,11 @@ encode %{
// Create the nodes for loading the IC from the TOC. // Create the nodes for loading the IC from the TOC.
loadConLNodesTuple loadConLNodes_IC = loadConLNodesTuple loadConLNodes_IC =
loadConLNodesTuple_create(C, ra_, n_toc, new (C) immLOper((jlong)Universe::non_oop_word()), loadConLNodesTuple_create(C, ra_, n_toc, new immLOper((jlong)Universe::non_oop_word()),
OptoReg::Name(R19_H_num), OptoReg::Name(R19_num)); OptoReg::Name(R19_H_num), OptoReg::Name(R19_num));
// Create the call node. // Create the call node.
CallDynamicJavaDirectSchedNode *call = new (C) CallDynamicJavaDirectSchedNode(); CallDynamicJavaDirectSchedNode *call = new CallDynamicJavaDirectSchedNode();
call->_method_handle_invoke = _method_handle_invoke; call->_method_handle_invoke = _method_handle_invoke;
call->_vtable_index = _vtable_index; call->_vtable_index = _vtable_index;
call->_method = _method; call->_method = _method;
@ -3765,7 +3765,7 @@ encode %{
#if defined(ABI_ELFv2) #if defined(ABI_ELFv2)
jlong entry_address = (jlong) this->entry_point(); jlong entry_address = (jlong) this->entry_point();
assert(entry_address, "need address here"); assert(entry_address, "need address here");
loadConLNodes_Entry = loadConLNodesTuple_create(C, ra_, n_toc, new (C) immLOper(entry_address), loadConLNodes_Entry = loadConLNodesTuple_create(C, ra_, n_toc, new immLOper(entry_address),
OptoReg::Name(R12_H_num), OptoReg::Name(R12_num)); OptoReg::Name(R12_H_num), OptoReg::Name(R12_num));
#else #else
// Get the struct that describes the function we are about to call. // Get the struct that describes the function we are about to call.
@ -3777,42 +3777,42 @@ encode %{
loadConLNodesTuple loadConLNodes_Toc; loadConLNodesTuple loadConLNodes_Toc;
// Create nodes and operands for loading the entry point. // Create nodes and operands for loading the entry point.
loadConLNodes_Entry = loadConLNodesTuple_create(C, ra_, n_toc, new (C) immLOper(entry_address), loadConLNodes_Entry = loadConLNodesTuple_create(C, ra_, n_toc, new immLOper(entry_address),
OptoReg::Name(R12_H_num), OptoReg::Name(R12_num)); OptoReg::Name(R12_H_num), OptoReg::Name(R12_num));
// Create nodes and operands for loading the env pointer. // Create nodes and operands for loading the env pointer.
if (fd->env() != NULL) { if (fd->env() != NULL) {
loadConLNodes_Env = loadConLNodesTuple_create(C, ra_, n_toc, new (C) immLOper((jlong) fd->env()), loadConLNodes_Env = loadConLNodesTuple_create(C, ra_, n_toc, new immLOper((jlong) fd->env()),
OptoReg::Name(R11_H_num), OptoReg::Name(R11_num)); OptoReg::Name(R11_H_num), OptoReg::Name(R11_num));
} else { } else {
loadConLNodes_Env._large_hi = NULL; loadConLNodes_Env._large_hi = NULL;
loadConLNodes_Env._large_lo = NULL; loadConLNodes_Env._large_lo = NULL;
loadConLNodes_Env._small = NULL; loadConLNodes_Env._small = NULL;
loadConLNodes_Env._last = new (C) loadConL16Node(); loadConLNodes_Env._last = new loadConL16Node();
loadConLNodes_Env._last->_opnds[0] = new (C) iRegLdstOper(); loadConLNodes_Env._last->_opnds[0] = new iRegLdstOper();
loadConLNodes_Env._last->_opnds[1] = new (C) immL16Oper(0); loadConLNodes_Env._last->_opnds[1] = new immL16Oper(0);
ra_->set_pair(loadConLNodes_Env._last->_idx, OptoReg::Name(R11_H_num), OptoReg::Name(R11_num)); ra_->set_pair(loadConLNodes_Env._last->_idx, OptoReg::Name(R11_H_num), OptoReg::Name(R11_num));
} }
// Create nodes and operands for loading the Toc point. // Create nodes and operands for loading the Toc point.
loadConLNodes_Toc = loadConLNodesTuple_create(C, ra_, n_toc, new (C) immLOper((jlong) fd->toc()), loadConLNodes_Toc = loadConLNodesTuple_create(C, ra_, n_toc, new immLOper((jlong) fd->toc()),
OptoReg::Name(R2_H_num), OptoReg::Name(R2_num)); OptoReg::Name(R2_H_num), OptoReg::Name(R2_num));
#endif // ABI_ELFv2 #endif // ABI_ELFv2
// mtctr node // mtctr node
MachNode *mtctr = new (C) CallLeafDirect_mtctrNode(); MachNode *mtctr = new CallLeafDirect_mtctrNode();
assert(loadConLNodes_Entry._last != NULL, "entry must exist"); assert(loadConLNodes_Entry._last != NULL, "entry must exist");
mtctr->add_req(0, loadConLNodes_Entry._last); mtctr->add_req(0, loadConLNodes_Entry._last);
mtctr->_opnds[0] = new (C) iRegLdstOper(); mtctr->_opnds[0] = new iRegLdstOper();
mtctr->_opnds[1] = new (C) iRegLdstOper(); mtctr->_opnds[1] = new iRegLdstOper();
// call node // call node
MachCallLeafNode *call = new (C) CallLeafDirectNode(); MachCallLeafNode *call = new CallLeafDirectNode();
call->_opnds[0] = _opnds[0]; call->_opnds[0] = _opnds[0];
call->_opnds[1] = new (C) methodOper((intptr_t) entry_address); // May get set later. call->_opnds[1] = new methodOper((intptr_t) entry_address); // May get set later.
// Make the new call node look like the old one. // Make the new call node look like the old one.
call->_name = _name; call->_name = _name;
@ -6050,9 +6050,9 @@ instruct loadConN_Ex(iRegNdst dst, immN src) %{
format %{ "LoadN $dst, $src \t// postalloc expanded" %} // mask format %{ "LoadN $dst, $src \t// postalloc expanded" %} // mask
postalloc_expand %{ postalloc_expand %{
MachNode *m1 = new (C) loadConN_hiNode(); MachNode *m1 = new loadConN_hiNode();
MachNode *m2 = new (C) loadConN_loNode(); MachNode *m2 = new loadConN_loNode();
MachNode *m3 = new (C) clearMs32bNode(); MachNode *m3 = new clearMs32bNode();
m1->add_req(NULL); m1->add_req(NULL);
m2->add_req(NULL, m1); m2->add_req(NULL, m1);
m3->add_req(NULL, m2); m3->add_req(NULL, m2);
@ -6117,7 +6117,7 @@ instruct loadConNKlass_Ex(iRegNdst dst, immNKlass src) %{
format %{ "LoadN $dst, $src \t// postalloc expanded" %} // mask format %{ "LoadN $dst, $src \t// postalloc expanded" %} // mask
postalloc_expand %{ postalloc_expand %{
// Load high bits into register. Sign extended. // Load high bits into register. Sign extended.
MachNode *m1 = new (C) loadConNKlass_hiNode(); MachNode *m1 = new loadConNKlass_hiNode();
m1->add_req(NULL); m1->add_req(NULL);
m1->_opnds[0] = op_dst; m1->_opnds[0] = op_dst;
m1->_opnds[1] = op_src; m1->_opnds[1] = op_src;
@ -6127,7 +6127,7 @@ instruct loadConNKlass_Ex(iRegNdst dst, immNKlass src) %{
MachNode *m2 = m1; MachNode *m2 = m1;
if (!Assembler::is_uimm((jlong)Klass::encode_klass((Klass *)op_src->constant()), 31)) { if (!Assembler::is_uimm((jlong)Klass::encode_klass((Klass *)op_src->constant()), 31)) {
// Value might be 1-extended. Mask out these bits. // Value might be 1-extended. Mask out these bits.
m2 = new (C) clearMs32bNode(); m2 = new clearMs32bNode();
m2->add_req(NULL, m1); m2->add_req(NULL, m1);
m2->_opnds[0] = op_dst; m2->_opnds[0] = op_dst;
m2->_opnds[1] = op_dst; m2->_opnds[1] = op_dst;
@ -6135,7 +6135,7 @@ instruct loadConNKlass_Ex(iRegNdst dst, immNKlass src) %{
nodes->push(m2); nodes->push(m2);
} }
MachNode *m3 = new (C) loadConNKlass_loNode(); MachNode *m3 = new loadConNKlass_loNode();
m3->add_req(NULL, m2); m3->add_req(NULL, m2);
m3->_opnds[0] = op_dst; m3->_opnds[0] = op_dst;
m3->_opnds[1] = op_src; m3->_opnds[1] = op_src;
@ -6987,14 +6987,14 @@ instruct encodePKlass_not_null_Ex(iRegNdst dst, iRegLsrc base, iRegPsrc src) %{
format %{ "EncodePKlass $dst, $src\t// $src != Null, postalloc expanded" %} format %{ "EncodePKlass $dst, $src\t// $src != Null, postalloc expanded" %}
postalloc_expand %{ postalloc_expand %{
encodePKlass_sub_baseNode *n1 = new (C) encodePKlass_sub_baseNode(); encodePKlass_sub_baseNode *n1 = new encodePKlass_sub_baseNode();
n1->add_req(n_region, n_base, n_src); n1->add_req(n_region, n_base, n_src);
n1->_opnds[0] = op_dst; n1->_opnds[0] = op_dst;
n1->_opnds[1] = op_base; n1->_opnds[1] = op_base;
n1->_opnds[2] = op_src; n1->_opnds[2] = op_src;
n1->_bottom_type = _bottom_type; n1->_bottom_type = _bottom_type;
encodePKlass_shiftNode *n2 = new (C) encodePKlass_shiftNode(); encodePKlass_shiftNode *n2 = new encodePKlass_shiftNode();
n2->add_req(n_region, n1); n2->add_req(n_region, n1);
n2->_opnds[0] = op_dst; n2->_opnds[0] = op_dst;
n2->_opnds[1] = op_dst; n2->_opnds[1] = op_dst;
@ -7064,14 +7064,14 @@ instruct decodeNKlass_notNull_addBase_Ex(iRegPdst dst, iRegLsrc base, iRegNsrc s
format %{ "DecodeNKlass $dst = $base + ($src << 3) \t// $src != NULL, postalloc expanded" %} format %{ "DecodeNKlass $dst = $base + ($src << 3) \t// $src != NULL, postalloc expanded" %}
postalloc_expand %{ postalloc_expand %{
decodeNKlass_add_baseNode *n1 = new (C) decodeNKlass_add_baseNode(); decodeNKlass_add_baseNode *n1 = new decodeNKlass_add_baseNode();
n1->add_req(n_region, n_base, n_src); n1->add_req(n_region, n_base, n_src);
n1->_opnds[0] = op_dst; n1->_opnds[0] = op_dst;
n1->_opnds[1] = op_base; n1->_opnds[1] = op_base;
n1->_opnds[2] = op_src; n1->_opnds[2] = op_src;
n1->_bottom_type = _bottom_type; n1->_bottom_type = _bottom_type;
decodeNKlass_shiftNode *n2 = new (C) decodeNKlass_shiftNode(); decodeNKlass_shiftNode *n2 = new decodeNKlass_shiftNode();
n2->add_req(n_region, n1); n2->add_req(n_region, n1);
n2->_opnds[0] = op_dst; n2->_opnds[0] = op_dst;
n2->_opnds[1] = op_dst; n2->_opnds[1] = op_dst;
@ -9773,8 +9773,8 @@ instruct cmovI_bso_stackSlotL_conLvalue0_Ex(iRegIdst dst, flagsReg crx, stackSlo
// //
// Create new nodes. // Create new nodes.
MachNode *m1 = new (C) loadConI16Node(); MachNode *m1 = new loadConI16Node();
MachNode *m2 = new (C) cmovI_bso_stackSlotLNode(); MachNode *m2 = new cmovI_bso_stackSlotLNode();
// inputs for new nodes // inputs for new nodes
m1->add_req(n_region); m1->add_req(n_region);
@ -9785,7 +9785,7 @@ instruct cmovI_bso_stackSlotL_conLvalue0_Ex(iRegIdst dst, flagsReg crx, stackSlo
// operands for new nodes // operands for new nodes
m1->_opnds[0] = op_dst; m1->_opnds[0] = op_dst;
m1->_opnds[1] = new (C) immI16Oper(0); m1->_opnds[1] = new immI16Oper(0);
m2->_opnds[0] = op_dst; m2->_opnds[0] = op_dst;
m2->_opnds[1] = op_crx; m2->_opnds[1] = op_crx;
@ -9942,8 +9942,8 @@ instruct cmovL_bso_stackSlotL_conLvalue0_Ex(iRegLdst dst, flagsReg crx, stackSlo
// //
// Create new nodes. // Create new nodes.
MachNode *m1 = new (C) loadConL16Node(); MachNode *m1 = new loadConL16Node();
MachNode *m2 = new (C) cmovL_bso_stackSlotLNode(); MachNode *m2 = new cmovL_bso_stackSlotLNode();
// inputs for new nodes // inputs for new nodes
m1->add_req(n_region); m1->add_req(n_region);
@ -9952,7 +9952,7 @@ instruct cmovL_bso_stackSlotL_conLvalue0_Ex(iRegLdst dst, flagsReg crx, stackSlo
// operands for new nodes // operands for new nodes
m1->_opnds[0] = op_dst; m1->_opnds[0] = op_dst;
m1->_opnds[1] = new (C) immL16Oper(0); m1->_opnds[1] = new immL16Oper(0);
m2->_opnds[0] = op_dst; m2->_opnds[0] = op_dst;
m2->_opnds[1] = op_crx; m2->_opnds[1] = op_crx;
m2->_opnds[2] = op_mem; m2->_opnds[2] = op_mem;
@ -10288,8 +10288,8 @@ instruct cmovI_conIvalueMinus1_conIvalue0_conIvalue1_Ex(iRegIdst dst, flagsReg c
// //
// Create new nodes. // Create new nodes.
MachNode *m1 = new (C) loadConI16Node(); MachNode *m1 = new loadConI16Node();
MachNode *m2 = new (C) cmovI_conIvalueMinus1_conIvalue1Node(); MachNode *m2 = new cmovI_conIvalueMinus1_conIvalue1Node();
// inputs for new nodes // inputs for new nodes
m1->add_req(n_region); m1->add_req(n_region);
@ -10298,7 +10298,7 @@ instruct cmovI_conIvalueMinus1_conIvalue0_conIvalue1_Ex(iRegIdst dst, flagsReg c
// operands for new nodes // operands for new nodes
m1->_opnds[0] = op_dst; m1->_opnds[0] = op_dst;
m1->_opnds[1] = new (C) immI16Oper(0); m1->_opnds[1] = new immI16Oper(0);
m2->_opnds[0] = op_dst; m2->_opnds[0] = op_dst;
m2->_opnds[1] = op_crx; m2->_opnds[1] = op_crx;
@ -10623,8 +10623,8 @@ instruct cmpF_reg_reg_Ex(flagsReg crx, regF src1, regF src2) %{
// //
// Create new nodes. // Create new nodes.
MachNode *m1 = new (C) cmpFUnordered_reg_regNode(); MachNode *m1 = new cmpFUnordered_reg_regNode();
MachNode *m2 = new (C) cmov_bns_lessNode(); MachNode *m2 = new cmov_bns_lessNode();
// inputs for new nodes // inputs for new nodes
m1->add_req(n_region, n_src1, n_src2); m1->add_req(n_region, n_src1, n_src2);
@ -10698,8 +10698,8 @@ instruct cmpD_reg_reg_Ex(flagsReg crx, regD src1, regD src2) %{
// //
// create new nodes // create new nodes
MachNode *m1 = new (C) cmpDUnordered_reg_regNode(); MachNode *m1 = new cmpDUnordered_reg_regNode();
MachNode *m2 = new (C) cmov_bns_lessNode(); MachNode *m2 = new cmov_bns_lessNode();
// inputs for new nodes // inputs for new nodes
m1->add_req(n_region, n_src1, n_src2); m1->add_req(n_region, n_src1, n_src2);

12
hotspot/src/cpu/x86/vm/x86_32.ad
View file

@ -1401,22 +1401,22 @@ void Matcher::pd_implicit_null_fixup(MachNode *node, uint idx) {
// No transformation necessary. // No transformation necessary.
return; return;
case INDIRECT: case INDIRECT:
new_memory = new (C) indirect_win95_safeOper( ); new_memory = new indirect_win95_safeOper( );
break; break;
case INDOFFSET8: case INDOFFSET8:
new_memory = new (C) indOffset8_win95_safeOper(memory->disp(NULL, NULL, 0)); new_memory = new indOffset8_win95_safeOper(memory->disp(NULL, NULL, 0));
break; break;
case INDOFFSET32: case INDOFFSET32:
new_memory = new (C) indOffset32_win95_safeOper(memory->disp(NULL, NULL, 0)); new_memory = new indOffset32_win95_safeOper(memory->disp(NULL, NULL, 0));
break; break;
case INDINDEXOFFSET: case INDINDEXOFFSET:
new_memory = new (C) indIndexOffset_win95_safeOper(memory->disp(NULL, NULL, 0)); new_memory = new indIndexOffset_win95_safeOper(memory->disp(NULL, NULL, 0));
break; break;
case INDINDEXSCALE: case INDINDEXSCALE:
new_memory = new (C) indIndexScale_win95_safeOper(memory->scale()); new_memory = new indIndexScale_win95_safeOper(memory->scale());
break; break;
case INDINDEXSCALEOFFSET: case INDINDEXSCALEOFFSET:
new_memory = new (C) indIndexScaleOffset_win95_safeOper(memory->scale(), memory->disp(NULL, NULL, 0)); new_memory = new indIndexScaleOffset_win95_safeOper(memory->scale(), memory->disp(NULL, NULL, 0));
break; break;
case LOAD_LONG_INDIRECT: case LOAD_LONG_INDIRECT:
case LOAD_LONG_INDOFFSET32: case LOAD_LONG_INDOFFSET32:

36
hotspot/src/share/vm/adlc/output_c.cpp
View file

@ -1000,7 +1000,7 @@ void ArchDesc::build_pipe_classes(FILE *fp_cpp) {
fprintf(fp_cpp, "void Bundle::initialize_nops(MachNode * nop_list[%d], Compile *C) {\n", nopcnt); fprintf(fp_cpp, "void Bundle::initialize_nops(MachNode * nop_list[%d], Compile *C) {\n", nopcnt);
int i = 0; int i = 0;
for ( _pipeline->_noplist.reset(); (nop = _pipeline->_noplist.iter()) != NULL; i++ ) { for ( _pipeline->_noplist.reset(); (nop = _pipeline->_noplist.iter()) != NULL; i++ ) {
fprintf(fp_cpp, " nop_list[%d] = (MachNode *) new (C) %sNode();\n", i, nop); fprintf(fp_cpp, " nop_list[%d] = (MachNode *) new %sNode();\n", i, nop);
} }
fprintf(fp_cpp, "};\n\n"); fprintf(fp_cpp, "};\n\n");
fprintf(fp_cpp, "#ifndef PRODUCT\n"); fprintf(fp_cpp, "#ifndef PRODUCT\n");
@ -1328,7 +1328,7 @@ static void generate_peepreplace( FILE *fp, FormDict &globals, PeepMatch *pmatch
preplace->next_instruction(root_inst); preplace->next_instruction(root_inst);
InstructForm *root_form = globals[root_inst]->is_instruction(); InstructForm *root_form = globals[root_inst]->is_instruction();
assert( root_form != NULL, "Replacement instruction was not previously defined"); assert( root_form != NULL, "Replacement instruction was not previously defined");
fprintf(fp, " %sNode *root = new (C) %sNode();\n", root_inst, root_inst); fprintf(fp, " %sNode *root = new %sNode();\n", root_inst, root_inst);
int inst_num; int inst_num;
const char *op_name; const char *op_name;
@ -1497,11 +1497,11 @@ void ArchDesc::defineExpand(FILE *fp, InstructForm *node) {
new_oper = frm->is_operand(); new_oper = frm->is_operand();
char *tmp = (char *)node->_exprule->_newopconst[new_id]; char *tmp = (char *)node->_exprule->_newopconst[new_id];
if (tmp == NULL) { if (tmp == NULL) {
fprintf(fp," MachOper *op%d = new (C) %sOper();\n", fprintf(fp," MachOper *op%d = new %sOper();\n",
cnt, new_oper->_ident); cnt, new_oper->_ident);
} }
else { else {
fprintf(fp," MachOper *op%d = new (C) %sOper(%s);\n", fprintf(fp," MachOper *op%d = new %sOper(%s);\n",
cnt, new_oper->_ident, tmp); cnt, new_oper->_ident, tmp);
} }
} }
@ -1566,7 +1566,7 @@ void ArchDesc::defineExpand(FILE *fp, InstructForm *node) {
} }
// Build the node for the instruction // Build the node for the instruction
fprintf(fp,"\n %sNode *n%d = new (C) %sNode();\n", new_id, cnt, new_id); fprintf(fp,"\n %sNode *n%d = new %sNode();\n", new_id, cnt, new_id);
// Add control edge for this node // Add control edge for this node
fprintf(fp," n%d->add_req(_in[0]);\n", cnt); fprintf(fp," n%d->add_req(_in[0]);\n", cnt);
// Build the operand for the value this node defines. // Build the operand for the value this node defines.
@ -1729,7 +1729,7 @@ void ArchDesc::defineExpand(FILE *fp, InstructForm *node) {
declared_def = true; declared_def = true;
} }
if (op && op->_interface && op->_interface->is_RegInterface()) { if (op && op->_interface && op->_interface->is_RegInterface()) {
fprintf(fp," def = new (C) MachTempNode(state->MachOperGenerator( %s, C ));\n", fprintf(fp," def = new MachTempNode(state->MachOperGenerator( %s, C ));\n",
machOperEnum(op->_ident)); machOperEnum(op->_ident));
fprintf(fp," add_req(def);\n"); fprintf(fp," add_req(def);\n");
// The operand for TEMP is already constructed during // The operand for TEMP is already constructed during
@ -1760,7 +1760,7 @@ void ArchDesc::defineExpand(FILE *fp, InstructForm *node) {
} }
fprintf(fp," kill = "); fprintf(fp," kill = ");
fprintf(fp,"new (C) MachProjNode( %s, %d, (%s), Op_%s );\n", fprintf(fp,"new MachProjNode( %s, %d, (%s), Op_%s );\n",
machNode, proj_no++, regmask, ideal_type); machNode, proj_no++, regmask, ideal_type);
fprintf(fp," proj_list.push(kill);\n"); fprintf(fp," proj_list.push(kill);\n");
} }
@ -2840,7 +2840,7 @@ static void defineIn_RegMask(FILE *fp, FormDict &globals, OperandForm &oper) {
// generate code to create a clone for a class derived from MachOper // generate code to create a clone for a class derived from MachOper
// //
// (0) MachOper *MachOperXOper::clone(Compile* C) const { // (0) MachOper *MachOperXOper::clone(Compile* C) const {
// (1) return new (C) MachXOper( _ccode, _c0, _c1, ..., _cn); // (1) return new MachXOper( _ccode, _c0, _c1, ..., _cn);
// (2) } // (2) }
// //
static void defineClone(FILE *fp, FormDict &globalNames, OperandForm &oper) { static void defineClone(FILE *fp, FormDict &globalNames, OperandForm &oper) {
@ -2849,7 +2849,7 @@ static void defineClone(FILE *fp, FormDict &globalNames, OperandForm &oper) {
const int num_consts = oper.num_consts(globalNames); const int num_consts = oper.num_consts(globalNames);
const bool is_ideal_bool = oper.is_ideal_bool(); const bool is_ideal_bool = oper.is_ideal_bool();
if( (num_consts > 0) ) { if( (num_consts > 0) ) {
fprintf(fp," return new (C) %sOper(", oper._ident); fprintf(fp," return new %sOper(", oper._ident);
// generate parameters for constants // generate parameters for constants
int i = 0; int i = 0;
fprintf(fp,"_c%d", i); fprintf(fp,"_c%d", i);
@ -2861,7 +2861,7 @@ static void defineClone(FILE *fp, FormDict &globalNames, OperandForm &oper) {
} }
else { else {
assert( num_consts == 0, "Currently support zero or one constant per operand clone function"); assert( num_consts == 0, "Currently support zero or one constant per operand clone function");
fprintf(fp," return new (C) %sOper();\n", oper._ident); fprintf(fp," return new %sOper();\n", oper._ident);
} }
// finish method // finish method
fprintf(fp,"}\n"); fprintf(fp,"}\n");
@ -3106,7 +3106,7 @@ void ArchDesc::defineClasses(FILE *fp) {
defineIn_RegMask(_CPP_MISC_file._fp, _globalNames, *oper); defineIn_RegMask(_CPP_MISC_file._fp, _globalNames, *oper);
fprintf(fp,"MachOper *%sOper::clone(Compile* C) const {\n", oper->_ident); fprintf(fp,"MachOper *%sOper::clone(Compile* C) const {\n", oper->_ident);
fprintf(fp," return new (C) %sOper(_label, _block_num);\n", oper->_ident); fprintf(fp," return new %sOper(_label, _block_num);\n", oper->_ident);
fprintf(fp,"}\n"); fprintf(fp,"}\n");
fprintf(fp,"uint %sOper::opcode() const { return %s; }\n", fprintf(fp,"uint %sOper::opcode() const { return %s; }\n",
@ -3125,7 +3125,7 @@ void ArchDesc::defineClasses(FILE *fp) {
defineIn_RegMask(_CPP_MISC_file._fp, _globalNames, *oper); defineIn_RegMask(_CPP_MISC_file._fp, _globalNames, *oper);
fprintf(fp,"MachOper *%sOper::clone(Compile* C) const {\n", oper->_ident); fprintf(fp,"MachOper *%sOper::clone(Compile* C) const {\n", oper->_ident);
fprintf(fp," return new (C) %sOper(_method);\n", oper->_ident); fprintf(fp," return new %sOper(_method);\n", oper->_ident);
fprintf(fp,"}\n"); fprintf(fp,"}\n");
fprintf(fp,"uint %sOper::opcode() const { return %s; }\n", fprintf(fp,"uint %sOper::opcode() const { return %s; }\n",
@ -3815,7 +3815,7 @@ static void genMachOperCase(FILE *fp, FormDict &globalNames, ArchDesc &AD,
// Generate the case statement for this opcode // Generate the case statement for this opcode
fprintf(fp, " case %s:", opEnumName); fprintf(fp, " case %s:", opEnumName);
fprintf(fp, "\n return new (C) %sOper(", opName); fprintf(fp, "\n return new %sOper(", opName);
// Access parameters for constructor from the stat object // Access parameters for constructor from the stat object
// //
// Build access to condition code value // Build access to condition code value
@ -3894,7 +3894,7 @@ void ArchDesc::buildMachNode(FILE *fp_cpp, InstructForm *inst, const char *inden
const char *opClass = inst->_ident; const char *opClass = inst->_ident;
// Create the MachNode object // Create the MachNode object
fprintf(fp_cpp, "%s %sNode *node = new (C) %sNode();\n",indent, opClass,opClass); fprintf(fp_cpp, "%s %sNode *node = new %sNode();\n",indent, opClass,opClass);
if ( (inst->num_post_match_opnds() != 0) ) { if ( (inst->num_post_match_opnds() != 0) ) {
// Instruction that contains operands which are not in match rule. // Instruction that contains operands which are not in match rule.
@ -3936,7 +3936,7 @@ void ArchDesc::buildMachNode(FILE *fp_cpp, InstructForm *inst, const char *inden
// Check for multiple constants and then fill them in. // Check for multiple constants and then fill them in.
// Just like MachOperGenerator // Just like MachOperGenerator
const char *opName = inst->_matrule->_rChild->_opType; const char *opName = inst->_matrule->_rChild->_opType;
fprintf(fp_cpp, "new (C) %sOper(", opName); fprintf(fp_cpp, "new %sOper(", opName);
// Grab operand form // Grab operand form
OperandForm *op = (_globalNames[opName])->is_operand(); OperandForm *op = (_globalNames[opName])->is_operand();
// Look up the number of constants // Look up the number of constants
@ -4010,7 +4010,7 @@ bool InstructForm::define_cisc_version(ArchDesc &AD, FILE *fp_cpp) {
fprintf(fp_cpp, "// Build CISC version of this instruction\n"); fprintf(fp_cpp, "// Build CISC version of this instruction\n");
fprintf(fp_cpp, "MachNode *%sNode::cisc_version( int offset, Compile* C ) {\n", this->_ident); fprintf(fp_cpp, "MachNode *%sNode::cisc_version( int offset, Compile* C ) {\n", this->_ident);
// Create the MachNode object // Create the MachNode object
fprintf(fp_cpp, " %sNode *node = new (C) %sNode();\n", name, name); fprintf(fp_cpp, " %sNode *node = new %sNode();\n", name, name);
// Fill in the bottom_type where requested // Fill in the bottom_type where requested
if ( this->captures_bottom_type(AD.globalNames()) ) { if ( this->captures_bottom_type(AD.globalNames()) ) {
fprintf(fp_cpp, " node->_bottom_type = bottom_type();\n"); fprintf(fp_cpp, " node->_bottom_type = bottom_type();\n");
@ -4026,7 +4026,7 @@ bool InstructForm::define_cisc_version(ArchDesc &AD, FILE *fp_cpp) {
fprintf(fp_cpp, " fill_new_machnode(node, C);\n"); fprintf(fp_cpp, " fill_new_machnode(node, C);\n");
// Construct operand to access [stack_pointer + offset] // Construct operand to access [stack_pointer + offset]
fprintf(fp_cpp, " // Construct operand to access [stack_pointer + offset]\n"); fprintf(fp_cpp, " // Construct operand to access [stack_pointer + offset]\n");
fprintf(fp_cpp, " node->set_opnd_array(cisc_operand(), new (C) %sOper(offset));\n", cisc_oper_name); fprintf(fp_cpp, " node->set_opnd_array(cisc_operand(), new %sOper(offset));\n", cisc_oper_name);
fprintf(fp_cpp, "\n"); fprintf(fp_cpp, "\n");
// Return result and exit scope // Return result and exit scope
@ -4057,7 +4057,7 @@ bool InstructForm::define_short_branch_methods(ArchDesc &AD, FILE *fp_cpp) {
fprintf(fp_cpp, "// Build short branch version of this instruction\n"); fprintf(fp_cpp, "// Build short branch version of this instruction\n");
fprintf(fp_cpp, "MachNode *%sNode::short_branch_version(Compile* C) {\n", this->_ident); fprintf(fp_cpp, "MachNode *%sNode::short_branch_version(Compile* C) {\n", this->_ident);
// Create the MachNode object // Create the MachNode object
fprintf(fp_cpp, " %sNode *node = new (C) %sNode();\n", name, name); fprintf(fp_cpp, " %sNode *node = new %sNode();\n", name, name);
if( is_ideal_if() ) { if( is_ideal_if() ) {
fprintf(fp_cpp, " node->_prob = _prob;\n"); fprintf(fp_cpp, " node->_prob = _prob;\n");
fprintf(fp_cpp, " node->_fcnt = _fcnt;\n"); fprintf(fp_cpp, " node->_fcnt = _fcnt;\n");

64
hotspot/src/share/vm/opto/addnode.cpp
View file

@ -254,47 +254,46 @@ Node *AddINode::Ideal(PhaseGVN *phase, bool can_reshape) {
const Type *t_sub1 = phase->type( in1->in(1) ); const Type *t_sub1 = phase->type( in1->in(1) );
const Type *t_2 = phase->type( in2 ); const Type *t_2 = phase->type( in2 );
if( t_sub1->singleton() && t_2->singleton() && t_sub1 != Type::TOP && t_2 != Type::TOP ) if( t_sub1->singleton() && t_2->singleton() && t_sub1 != Type::TOP && t_2 != Type::TOP )
return new (phase->C) SubINode(phase->makecon( add_ring( t_sub1, t_2 ) ), return new SubINode(phase->makecon( add_ring( t_sub1, t_2 ) ), in1->in(2) );
in1->in(2) );
// Convert "(a-b)+(c-d)" into "(a+c)-(b+d)" // Convert "(a-b)+(c-d)" into "(a+c)-(b+d)"
if( op2 == Op_SubI ) { if( op2 == Op_SubI ) {
// Check for dead cycle: d = (a-b)+(c-d) // Check for dead cycle: d = (a-b)+(c-d)
assert( in1->in(2) != this && in2->in(2) != this, assert( in1->in(2) != this && in2->in(2) != this,
"dead loop in AddINode::Ideal" ); "dead loop in AddINode::Ideal" );
Node *sub = new (phase->C) SubINode(NULL, NULL); Node *sub = new SubINode(NULL, NULL);
sub->init_req(1, phase->transform(new (phase->C) AddINode(in1->in(1), in2->in(1) ) )); sub->init_req(1, phase->transform(new AddINode(in1->in(1), in2->in(1) ) ));
sub->init_req(2, phase->transform(new (phase->C) AddINode(in1->in(2), in2->in(2) ) )); sub->init_req(2, phase->transform(new AddINode(in1->in(2), in2->in(2) ) ));
return sub; return sub;
} }
// Convert "(a-b)+(b+c)" into "(a+c)" // Convert "(a-b)+(b+c)" into "(a+c)"
if( op2 == Op_AddI && in1->in(2) == in2->in(1) ) { if( op2 == Op_AddI && in1->in(2) == in2->in(1) ) {
assert(in1->in(1) != this && in2->in(2) != this,"dead loop in AddINode::Ideal"); assert(in1->in(1) != this && in2->in(2) != this,"dead loop in AddINode::Ideal");
return new (phase->C) AddINode(in1->in(1), in2->in(2)); return new AddINode(in1->in(1), in2->in(2));
} }
// Convert "(a-b)+(c+b)" into "(a+c)" // Convert "(a-b)+(c+b)" into "(a+c)"
if( op2 == Op_AddI && in1->in(2) == in2->in(2) ) { if( op2 == Op_AddI && in1->in(2) == in2->in(2) ) {
assert(in1->in(1) != this && in2->in(1) != this,"dead loop in AddINode::Ideal"); assert(in1->in(1) != this && in2->in(1) != this,"dead loop in AddINode::Ideal");
return new (phase->C) AddINode(in1->in(1), in2->in(1)); return new AddINode(in1->in(1), in2->in(1));
} }
// Convert "(a-b)+(b-c)" into "(a-c)" // Convert "(a-b)+(b-c)" into "(a-c)"
if( op2 == Op_SubI && in1->in(2) == in2->in(1) ) { if( op2 == Op_SubI && in1->in(2) == in2->in(1) ) {
assert(in1->in(1) != this && in2->in(2) != this,"dead loop in AddINode::Ideal"); assert(in1->in(1) != this && in2->in(2) != this,"dead loop in AddINode::Ideal");
return new (phase->C) SubINode(in1->in(1), in2->in(2)); return new SubINode(in1->in(1), in2->in(2));
} }
// Convert "(a-b)+(c-a)" into "(c-b)" // Convert "(a-b)+(c-a)" into "(c-b)"
if( op2 == Op_SubI && in1->in(1) == in2->in(2) ) { if( op2 == Op_SubI && in1->in(1) == in2->in(2) ) {
assert(in1->in(2) != this && in2->in(1) != this,"dead loop in AddINode::Ideal"); assert(in1->in(2) != this && in2->in(1) != this,"dead loop in AddINode::Ideal");
return new (phase->C) SubINode(in2->in(1), in1->in(2)); return new SubINode(in2->in(1), in1->in(2));
} }
} }
// Convert "x+(0-y)" into "(x-y)" // Convert "x+(0-y)" into "(x-y)"
if( op2 == Op_SubI && phase->type(in2->in(1)) == TypeInt::ZERO ) if( op2 == Op_SubI && phase->type(in2->in(1)) == TypeInt::ZERO )
return new (phase->C) SubINode(in1, in2->in(2) ); return new SubINode(in1, in2->in(2) );
// Convert "(0-y)+x" into "(x-y)" // Convert "(0-y)+x" into "(x-y)"
if( op1 == Op_SubI && phase->type(in1->in(1)) == TypeInt::ZERO ) if( op1 == Op_SubI && phase->type(in1->in(1)) == TypeInt::ZERO )
return new (phase->C) SubINode( in2, in1->in(2) ); return new SubINode( in2, in1->in(2) );
// Convert (x>>>z)+y into (x+(y<<z))>>>z for small constant z and y. // Convert (x>>>z)+y into (x+(y<<z))>>>z for small constant z and y.
// Helps with array allocation math constant folding // Helps with array allocation math constant folding
@ -315,8 +314,8 @@ Node *AddINode::Ideal(PhaseGVN *phase, bool can_reshape) {
if( z < 5 && -5 < y && y < 0 ) { if( z < 5 && -5 < y && y < 0 ) {
const Type *t_in11 = phase->type(in1->in(1)); const Type *t_in11 = phase->type(in1->in(1));
if( t_in11 != Type::TOP && (t_in11->is_int()->_lo >= -(y << z)) ) { if( t_in11 != Type::TOP && (t_in11->is_int()->_lo >= -(y << z)) ) {
Node *a = phase->transform( new (phase->C) AddINode( in1->in(1), phase->intcon(y<<z) ) ); Node *a = phase->transform( new AddINode( in1->in(1), phase->intcon(y<<z) ) );
return new (phase->C) URShiftINode( a, in1->in(2) ); return new URShiftINode( a, in1->in(2) );
} }
} }
} }
@ -387,47 +386,46 @@ Node *AddLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
const Type *t_sub1 = phase->type( in1->in(1) ); const Type *t_sub1 = phase->type( in1->in(1) );
const Type *t_2 = phase->type( in2 ); const Type *t_2 = phase->type( in2 );
if( t_sub1->singleton() && t_2->singleton() && t_sub1 != Type::TOP && t_2 != Type::TOP ) if( t_sub1->singleton() && t_2->singleton() && t_sub1 != Type::TOP && t_2 != Type::TOP )
return new (phase->C) SubLNode(phase->makecon( add_ring( t_sub1, t_2 ) ), return new SubLNode(phase->makecon( add_ring( t_sub1, t_2 ) ), in1->in(2) );
in1->in(2) );
// Convert "(a-b)+(c-d)" into "(a+c)-(b+d)" // Convert "(a-b)+(c-d)" into "(a+c)-(b+d)"
if( op2 == Op_SubL ) { if( op2 == Op_SubL ) {
// Check for dead cycle: d = (a-b)+(c-d) // Check for dead cycle: d = (a-b)+(c-d)
assert( in1->in(2) != this && in2->in(2) != this, assert( in1->in(2) != this && in2->in(2) != this,
"dead loop in AddLNode::Ideal" ); "dead loop in AddLNode::Ideal" );
Node *sub = new (phase->C) SubLNode(NULL, NULL); Node *sub = new SubLNode(NULL, NULL);
sub->init_req(1, phase->transform(new (phase->C) AddLNode(in1->in(1), in2->in(1) ) )); sub->init_req(1, phase->transform(new AddLNode(in1->in(1), in2->in(1) ) ));
sub->init_req(2, phase->transform(new (phase->C) AddLNode(in1->in(2), in2->in(2) ) )); sub->init_req(2, phase->transform(new AddLNode(in1->in(2), in2->in(2) ) ));
return sub; return sub;
} }
// Convert "(a-b)+(b+c)" into "(a+c)" // Convert "(a-b)+(b+c)" into "(a+c)"
if( op2 == Op_AddL && in1->in(2) == in2->in(1) ) { if( op2 == Op_AddL && in1->in(2) == in2->in(1) ) {
assert(in1->in(1) != this && in2->in(2) != this,"dead loop in AddLNode::Ideal"); assert(in1->in(1) != this && in2->in(2) != this,"dead loop in AddLNode::Ideal");
return new (phase->C) AddLNode(in1->in(1), in2->in(2)); return new AddLNode(in1->in(1), in2->in(2));
} }
// Convert "(a-b)+(c+b)" into "(a+c)" // Convert "(a-b)+(c+b)" into "(a+c)"
if( op2 == Op_AddL && in1->in(2) == in2->in(2) ) { if( op2 == Op_AddL && in1->in(2) == in2->in(2) ) {
assert(in1->in(1) != this && in2->in(1) != this,"dead loop in AddLNode::Ideal"); assert(in1->in(1) != this && in2->in(1) != this,"dead loop in AddLNode::Ideal");
return new (phase->C) AddLNode(in1->in(1), in2->in(1)); return new AddLNode(in1->in(1), in2->in(1));
} }
// Convert "(a-b)+(b-c)" into "(a-c)" // Convert "(a-b)+(b-c)" into "(a-c)"
if( op2 == Op_SubL && in1->in(2) == in2->in(1) ) { if( op2 == Op_SubL && in1->in(2) == in2->in(1) ) {
assert(in1->in(1) != this && in2->in(2) != this,"dead loop in AddLNode::Ideal"); assert(in1->in(1) != this && in2->in(2) != this,"dead loop in AddLNode::Ideal");
return new (phase->C) SubLNode(in1->in(1), in2->in(2)); return new SubLNode(in1->in(1), in2->in(2));
} }
// Convert "(a-b)+(c-a)" into "(c-b)" // Convert "(a-b)+(c-a)" into "(c-b)"
if( op2 == Op_SubL && in1->in(1) == in1->in(2) ) { if( op2 == Op_SubL && in1->in(1) == in1->in(2) ) {
assert(in1->in(2) != this && in2->in(1) != this,"dead loop in AddLNode::Ideal"); assert(in1->in(2) != this && in2->in(1) != this,"dead loop in AddLNode::Ideal");
return new (phase->C) SubLNode(in2->in(1), in1->in(2)); return new SubLNode(in2->in(1), in1->in(2));
} }
} }
// Convert "x+(0-y)" into "(x-y)" // Convert "x+(0-y)" into "(x-y)"
if( op2 == Op_SubL && phase->type(in2->in(1)) == TypeLong::ZERO ) if( op2 == Op_SubL && phase->type(in2->in(1)) == TypeLong::ZERO )
return new (phase->C) SubLNode( in1, in2->in(2) ); return new SubLNode( in1, in2->in(2) );
// Convert "(0-y)+x" into "(x-y)" // Convert "(0-y)+x" into "(x-y)"
if( op1 == Op_SubL && phase->type(in1->in(1)) == TypeInt::ZERO ) if( op1 == Op_SubL && phase->type(in1->in(1)) == TypeInt::ZERO )
return new (phase->C) SubLNode( in2, in1->in(2) ); return new SubLNode( in2, in1->in(2) );
// Convert "X+X+X+X+X...+X+Y" into "k*X+Y" or really convert "X+(X+Y)" // Convert "X+X+X+X+X...+X+Y" into "k*X+Y" or really convert "X+(X+Y)"
// into "(X<<1)+Y" and let shift-folding happen. // into "(X<<1)+Y" and let shift-folding happen.
@ -435,8 +433,8 @@ Node *AddLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
in2->in(1) == in1 && in2->in(1) == in1 &&
op1 != Op_ConL && op1 != Op_ConL &&
0 ) { 0 ) {
Node *shift = phase->transform(new (phase->C) LShiftLNode(in1,phase->intcon(1))); Node *shift = phase->transform(new LShiftLNode(in1,phase->intcon(1)));
return new (phase->C) AddLNode(shift,in2->in(2)); return new AddLNode(shift,in2->in(2));
} }
return AddNode::Ideal(phase, can_reshape); return AddNode::Ideal(phase, can_reshape);
@ -596,7 +594,7 @@ Node *AddPNode::Ideal(PhaseGVN *phase, bool can_reshape) {
offset = phase->MakeConX(t2->get_con() + t12->get_con()); offset = phase->MakeConX(t2->get_con() + t12->get_con());
} else { } else {
// Else move the constant to the right. ((A+con)+B) into ((A+B)+con) // Else move the constant to the right. ((A+con)+B) into ((A+B)+con)
address = phase->transform(new (phase->C) AddPNode(in(Base),addp->in(Address),in(Offset))); address = phase->transform(new AddPNode(in(Base),addp->in(Address),in(Offset)));
offset = addp->in(Offset); offset = addp->in(Offset);
} }
PhaseIterGVN *igvn = phase->is_IterGVN(); PhaseIterGVN *igvn = phase->is_IterGVN();
@ -616,7 +614,7 @@ Node *AddPNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// If this is a NULL+long form (from unsafe accesses), switch to a rawptr. // If this is a NULL+long form (from unsafe accesses), switch to a rawptr.
if (phase->type(in(Address)) == TypePtr::NULL_PTR) { if (phase->type(in(Address)) == TypePtr::NULL_PTR) {
Node* offset = in(Offset); Node* offset = in(Offset);
return new (phase->C) CastX2PNode(offset); return new CastX2PNode(offset);
} }
} }
@ -628,7 +626,7 @@ Node *AddPNode::Ideal(PhaseGVN *phase, bool can_reshape) {
if( add->Opcode() == Op_AddX && add->in(1) != add ) { if( add->Opcode() == Op_AddX && add->in(1) != add ) {
const Type *t22 = phase->type( add->in(2) ); const Type *t22 = phase->type( add->in(2) );
if( t22->singleton() && (t22 != Type::TOP) ) { // Right input is an add of a constant? if( t22->singleton() && (t22 != Type::TOP) ) { // Right input is an add of a constant?
set_req(Address, phase->transform(new (phase->C) AddPNode(in(Base),in(Address),add->in(1)))); set_req(Address, phase->transform(new AddPNode(in(Base),in(Address),add->in(1))));
set_req(Offset, add->in(2)); set_req(Offset, add->in(2));
PhaseIterGVN *igvn = phase->is_IterGVN(); PhaseIterGVN *igvn = phase->is_IterGVN();
if (add->outcnt() == 0 && igvn) { if (add->outcnt() == 0 && igvn) {
@ -858,7 +856,7 @@ Node *MinINode::Ideal(PhaseGVN *phase, bool can_reshape) {
// to force a right-spline graph for the rest of MinINode::Ideal(). // to force a right-spline graph for the rest of MinINode::Ideal().
if( l->Opcode() == Op_MinI ) { if( l->Opcode() == Op_MinI ) {
assert( l != l->in(1), "dead loop in MinINode::Ideal" ); assert( l != l->in(1), "dead loop in MinINode::Ideal" );
r = phase->transform(new (phase->C) MinINode(l->in(2),r)); r = phase->transform(new MinINode(l->in(2),r));
l = l->in(1); l = l->in(1);
set_req(1, l); set_req(1, l);
set_req(2, r); set_req(2, r);
@ -906,18 +904,18 @@ Node *MinINode::Ideal(PhaseGVN *phase, bool can_reshape) {
} }
if( x->_idx > y->_idx ) if( x->_idx > y->_idx )
return new (phase->C) MinINode(r->in(1),phase->transform(new (phase->C) MinINode(l,r->in(2)))); return new MinINode(r->in(1),phase->transform(new MinINode(l,r->in(2))));
// See if covers: MIN2(x+c0,MIN2(y+c1,z)) // See if covers: MIN2(x+c0,MIN2(y+c1,z))
if( !phase->eqv(x,y) ) return NULL; if( !phase->eqv(x,y) ) return NULL;
// If (y == x) transform MIN2(x+c0, MIN2(x+c1,z)) into // If (y == x) transform MIN2(x+c0, MIN2(x+c1,z)) into
// MIN2(x+c0 or x+c1 which less, z). // MIN2(x+c0 or x+c1 which less, z).
return new (phase->C) MinINode(phase->transform(new (phase->C) AddINode(x,phase->intcon(MIN2(x_off,y_off)))),r->in(2)); return new MinINode(phase->transform(new AddINode(x,phase->intcon(MIN2(x_off,y_off)))),r->in(2));
} else { } else {
// See if covers: MIN2(x+c0,y+c1) // See if covers: MIN2(x+c0,y+c1)
if( !phase->eqv(x,y) ) return NULL; if( !phase->eqv(x,y) ) return NULL;
// If (y == x) transform MIN2(x+c0,x+c1) into x+c0 or x+c1 which less. // If (y == x) transform MIN2(x+c0,x+c1) into x+c0 or x+c1 which less.
return new (phase->C) AddINode(x,phase->intcon(MIN2(x_off,y_off))); return new AddINode(x,phase->intcon(MIN2(x_off,y_off)));
} }
} }

6
hotspot/src/share/vm/opto/block.cpp
View file

@ -373,7 +373,7 @@ PhaseCFG::PhaseCFG(Arena* arena, RootNode* root, Matcher& matcher)
// I'll need a few machine-specific GotoNodes. Make an Ideal GotoNode, // I'll need a few machine-specific GotoNodes. Make an Ideal GotoNode,
// then Match it into a machine-specific Node. Then clone the machine // then Match it into a machine-specific Node. Then clone the machine
// Node on demand. // Node on demand.
Node *x = new (C) GotoNode(NULL); Node *x = new GotoNode(NULL);
x->init_req(0, x); x->init_req(0, x);
_goto = matcher.match_tree(x); _goto = matcher.match_tree(x);
assert(_goto != NULL, ""); assert(_goto != NULL, "");
@ -426,7 +426,7 @@ uint PhaseCFG::build_cfg() {
!p->is_block_start() ); !p->is_block_start() );
// Make the block begin with one of Region or StartNode. // Make the block begin with one of Region or StartNode.
if( !p->is_block_start() ) { if( !p->is_block_start() ) {
RegionNode *r = new (C) RegionNode( 2 ); RegionNode *r = new RegionNode( 2 );
r->init_req(1, p); // Insert RegionNode in the way r->init_req(1, p); // Insert RegionNode in the way
proj->set_req(0, r); // Insert RegionNode in the way proj->set_req(0, r); // Insert RegionNode in the way
p = r; p = r;
@ -501,7 +501,7 @@ void PhaseCFG::insert_goto_at(uint block_no, uint succ_no) {
// get ProjNode corresponding to the succ_no'th successor of the in block // get ProjNode corresponding to the succ_no'th successor of the in block
ProjNode* proj = in->get_node(in->number_of_nodes() - in->_num_succs + succ_no)->as_Proj(); ProjNode* proj = in->get_node(in->number_of_nodes() - in->_num_succs + succ_no)->as_Proj();
// create region for basic block // create region for basic block
RegionNode* region = new (C) RegionNode(2); RegionNode* region = new RegionNode(2);
region->init_req(1, proj); region->init_req(1, proj);
// setup corresponding basic block // setup corresponding basic block
Block* block = new (_block_arena) Block(_block_arena, region); Block* block = new (_block_arena) Block(_block_arena, region);

14
hotspot/src/share/vm/opto/callGenerator.cpp
View file

@ -136,7 +136,7 @@ JVMState* DirectCallGenerator::generate(JVMState* jvms, Parse* parent_parser) {
kit.C->log()->elem("direct_call bci='%d'", jvms->bci()); kit.C->log()->elem("direct_call bci='%d'", jvms->bci());
} }
CallStaticJavaNode *call = new (kit.C) CallStaticJavaNode(kit.C, tf(), target, method(), kit.bci()); CallStaticJavaNode *call = new CallStaticJavaNode(kit.C, tf(), target, method(), kit.bci());
_call_node = call; // Save the call node in case we need it later _call_node = call; // Save the call node in case we need it later
if (!is_static) { if (!is_static) {
// Make an explicit receiver null_check as part of this call. // Make an explicit receiver null_check as part of this call.
@ -225,7 +225,7 @@ JVMState* VirtualCallGenerator::generate(JVMState* jvms, Parse* parent_parser) {
"no vtable calls if +UseInlineCaches "); "no vtable calls if +UseInlineCaches ");
address target = SharedRuntime::get_resolve_virtual_call_stub(); address target = SharedRuntime::get_resolve_virtual_call_stub();
// Normal inline cache used for call // Normal inline cache used for call
CallDynamicJavaNode *call = new (kit.C) CallDynamicJavaNode(tf(), target, method(), _vtable_index, kit.bci()); CallDynamicJavaNode *call = new CallDynamicJavaNode(tf(), target, method(), _vtable_index, kit.bci());
kit.set_arguments_for_java_call(call); kit.set_arguments_for_java_call(call);
kit.set_edges_for_java_call(call); kit.set_edges_for_java_call(call);
Node* ret = kit.set_results_for_java_call(call); Node* ret = kit.set_results_for_java_call(call);
@ -350,7 +350,7 @@ void LateInlineCallGenerator::do_late_inline() {
JVMState* old_jvms = call->jvms(); JVMState* old_jvms = call->jvms();
JVMState* jvms = old_jvms->clone_shallow(C); JVMState* jvms = old_jvms->clone_shallow(C);
uint size = call->req(); uint size = call->req();
SafePointNode* map = new (C) SafePointNode(size, jvms); SafePointNode* map = new SafePointNode(size, jvms);
for (uint i1 = 0; i1 < size; i1++) { for (uint i1 = 0; i1 < size; i1++) {
map->init_req(i1, call->in(i1)); map->init_req(i1, call->in(i1));
} }
@ -717,7 +717,7 @@ JVMState* PredictedCallGenerator::generate(JVMState* jvms, Parse* parent_parser)
// Finish the diamond. // Finish the diamond.
kit.C->set_has_split_ifs(true); // Has chance for split-if optimization kit.C->set_has_split_ifs(true); // Has chance for split-if optimization
RegionNode* region = new (kit.C) RegionNode(3); RegionNode* region = new RegionNode(3);
region->init_req(1, kit.control()); region->init_req(1, kit.control());
region->init_req(2, slow_map->control()); region->init_req(2, slow_map->control());
kit.set_control(gvn.transform(region)); kit.set_control(gvn.transform(region));
@ -825,7 +825,7 @@ CallGenerator* CallGenerator::for_method_handle_inline(JVMState* jvms, ciMethod*
const TypeOopPtr* arg_type = arg->bottom_type()->isa_oopptr(); const TypeOopPtr* arg_type = arg->bottom_type()->isa_oopptr();
const Type* sig_type = TypeOopPtr::make_from_klass(signature->accessing_klass()); const Type* sig_type = TypeOopPtr::make_from_klass(signature->accessing_klass());
if (arg_type != NULL && !arg_type->higher_equal(sig_type)) { if (arg_type != NULL && !arg_type->higher_equal(sig_type)) {
Node* cast_obj = gvn.transform(new (C) CheckCastPPNode(kit.control(), arg, sig_type)); Node* cast_obj = gvn.transform(new CheckCastPPNode(kit.control(), arg, sig_type));
kit.set_argument(0, cast_obj); kit.set_argument(0, cast_obj);
} }
} }
@ -837,7 +837,7 @@ CallGenerator* CallGenerator::for_method_handle_inline(JVMState* jvms, ciMethod*
const TypeOopPtr* arg_type = arg->bottom_type()->isa_oopptr(); const TypeOopPtr* arg_type = arg->bottom_type()->isa_oopptr();
const Type* sig_type = TypeOopPtr::make_from_klass(t->as_klass()); const Type* sig_type = TypeOopPtr::make_from_klass(t->as_klass());
if (arg_type != NULL && !arg_type->higher_equal(sig_type)) { if (arg_type != NULL && !arg_type->higher_equal(sig_type)) {
Node* cast_obj = gvn.transform(new (C) CheckCastPPNode(kit.control(), arg, sig_type)); Node* cast_obj = gvn.transform(new CheckCastPPNode(kit.control(), arg, sig_type));
kit.set_argument(receiver_skip + i, cast_obj); kit.set_argument(receiver_skip + i, cast_obj);
} }
} }
@ -978,7 +978,7 @@ JVMState* PredictedIntrinsicGenerator::generate(JVMState* jvms, Parse* parent_pa
// Finish the diamond. // Finish the diamond.
kit.C->set_has_split_ifs(true); // Has chance for split-if optimization kit.C->set_has_split_ifs(true); // Has chance for split-if optimization
RegionNode* region = new (kit.C) RegionNode(3); RegionNode* region = new RegionNode(3);
region->init_req(1, kit.control()); region->init_req(1, kit.control());
region->init_req(2, slow_map->control()); region->init_req(2, slow_map->control());
kit.set_control(gvn.transform(region)); kit.set_control(gvn.transform(region));

22
hotspot/src/share/vm/opto/callnode.cpp
View file

@ -74,20 +74,20 @@ Node *StartNode::match( const ProjNode *proj, const Matcher *match ) {
case TypeFunc::Control: case TypeFunc::Control:
case TypeFunc::I_O: case TypeFunc::I_O:
case TypeFunc::Memory: case TypeFunc::Memory:
return new (match->C) MachProjNode(this,proj->_con,RegMask::Empty,MachProjNode::unmatched_proj); return new MachProjNode(this,proj->_con,RegMask::Empty,MachProjNode::unmatched_proj);
case TypeFunc::FramePtr: case TypeFunc::FramePtr:
return new (match->C) MachProjNode(this,proj->_con,Matcher::c_frame_ptr_mask, Op_RegP); return new MachProjNode(this,proj->_con,Matcher::c_frame_ptr_mask, Op_RegP);
case TypeFunc::ReturnAdr: case TypeFunc::ReturnAdr:
return new (match->C) MachProjNode(this,proj->_con,match->_return_addr_mask,Op_RegP); return new MachProjNode(this,proj->_con,match->_return_addr_mask,Op_RegP);
case TypeFunc::Parms: case TypeFunc::Parms:
default: { default: {
uint parm_num = proj->_con - TypeFunc::Parms; uint parm_num = proj->_con - TypeFunc::Parms;
const Type *t = _domain->field_at(proj->_con); const Type *t = _domain->field_at(proj->_con);
if (t->base() == Type::Half) // 2nd half of Longs and Doubles if (t->base() == Type::Half) // 2nd half of Longs and Doubles
return new (match->C) ConNode(Type::TOP); return new ConNode(Type::TOP);
uint ideal_reg = t->ideal_reg(); uint ideal_reg = t->ideal_reg();
RegMask &rm = match->_calling_convention_mask[parm_num]; RegMask &rm = match->_calling_convention_mask[parm_num];
return new (match->C) MachProjNode(this,proj->_con,rm,ideal_reg); return new MachProjNode(this,proj->_con,rm,ideal_reg);
} }
} }
return NULL; return NULL;
@ -685,12 +685,12 @@ Node *CallNode::match( const ProjNode *proj, const Matcher *match ) {
case TypeFunc::Control: case TypeFunc::Control:
case TypeFunc::I_O: case TypeFunc::I_O:
case TypeFunc::Memory: case TypeFunc::Memory:
return new (match->C) MachProjNode(this,proj->_con,RegMask::Empty,MachProjNode::unmatched_proj); return new MachProjNode(this,proj->_con,RegMask::Empty,MachProjNode::unmatched_proj);
case TypeFunc::Parms+1: // For LONG & DOUBLE returns case TypeFunc::Parms+1: // For LONG & DOUBLE returns
assert(tf()->_range->field_at(TypeFunc::Parms+1) == Type::HALF, ""); assert(tf()->_range->field_at(TypeFunc::Parms+1) == Type::HALF, "");
// 2nd half of doubles and longs // 2nd half of doubles and longs
return new (match->C) MachProjNode(this,proj->_con, RegMask::Empty, (uint)OptoReg::Bad); return new MachProjNode(this,proj->_con, RegMask::Empty, (uint)OptoReg::Bad);
case TypeFunc::Parms: { // Normal returns case TypeFunc::Parms: { // Normal returns
uint ideal_reg = tf()->range()->field_at(TypeFunc::Parms)->ideal_reg(); uint ideal_reg = tf()->range()->field_at(TypeFunc::Parms)->ideal_reg();
@ -700,7 +700,7 @@ Node *CallNode::match( const ProjNode *proj, const Matcher *match ) {
RegMask rm = RegMask(regs.first()); RegMask rm = RegMask(regs.first());
if( OptoReg::is_valid(regs.second()) ) if( OptoReg::is_valid(regs.second()) )
rm.Insert( regs.second() ); rm.Insert( regs.second() );
return new (match->C) MachProjNode(this,proj->_con,rm,ideal_reg); return new MachProjNode(this,proj->_con,rm,ideal_reg);
} }
case TypeFunc::ReturnAdr: case TypeFunc::ReturnAdr:
@ -1288,10 +1288,10 @@ Node* AllocateArrayNode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node* nproj = catchproj->clone(); Node* nproj = catchproj->clone();
igvn->register_new_node_with_optimizer(nproj); igvn->register_new_node_with_optimizer(nproj);
Node *frame = new (phase->C) ParmNode( phase->C->start(), TypeFunc::FramePtr ); Node *frame = new ParmNode( phase->C->start(), TypeFunc::FramePtr );
frame = phase->transform(frame); frame = phase->transform(frame);
// Halt & Catch Fire // Halt & Catch Fire
Node *halt = new (phase->C) HaltNode( nproj, frame ); Node *halt = new HaltNode( nproj, frame );
phase->C->root()->add_req(halt); phase->C->root()->add_req(halt);
phase->transform(halt); phase->transform(halt);
@ -1333,7 +1333,7 @@ Node *AllocateArrayNode::make_ideal_length(const TypeOopPtr* oop_type, PhaseTran
if (!allow_new_nodes) return NULL; if (!allow_new_nodes) return NULL;
// Create a cast which is control dependent on the initialization to // Create a cast which is control dependent on the initialization to
// propagate the fact that the array length must be positive. // propagate the fact that the array length must be positive.
length = new (phase->C) CastIINode(length, narrow_length_type); length = new CastIINode(length, narrow_length_type);
length->set_req(0, initialization()->proj_out(0)); length->set_req(0, initialization()->proj_out(0));
} }
} }

8
hotspot/src/share/vm/opto/castnode.cpp
View file

@ -228,11 +228,11 @@ static inline Node* addP_of_X2P(PhaseGVN *phase,
Node* dispX, Node* dispX,
bool negate = false) { bool negate = false) {
if (negate) { if (negate) {
dispX = new (phase->C) SubXNode(phase->MakeConX(0), phase->transform(dispX)); dispX = new SubXNode(phase->MakeConX(0), phase->transform(dispX));
} }
return new (phase->C) AddPNode(phase->C->top(), return new AddPNode(phase->C->top(),
phase->transform(new (phase->C) CastX2PNode(base)), phase->transform(new CastX2PNode(base)),
phase->transform(dispX)); phase->transform(dispX));
} }
Node *CastX2PNode::Ideal(PhaseGVN *phase, bool can_reshape) { Node *CastX2PNode::Ideal(PhaseGVN *phase, bool can_reshape) {

60
hotspot/src/share/vm/opto/cfgnode.cpp
View file

@ -662,17 +662,17 @@ Node *RegionNode::Ideal(PhaseGVN *phase, bool can_reshape) {
convf2i->in(1) == bot_in ) { convf2i->in(1) == bot_in ) {
// Matched pattern, including LShiftI; RShiftI, replace with integer compares // Matched pattern, including LShiftI; RShiftI, replace with integer compares
// max test // max test
Node *cmp = gvn->register_new_node_with_optimizer(new (phase->C) CmpINode( convf2i, min )); Node *cmp = gvn->register_new_node_with_optimizer(new CmpINode( convf2i, min ));
Node *boo = gvn->register_new_node_with_optimizer(new (phase->C) BoolNode( cmp, BoolTest::lt )); Node *boo = gvn->register_new_node_with_optimizer(new BoolNode( cmp, BoolTest::lt ));
IfNode *iff = (IfNode*)gvn->register_new_node_with_optimizer(new (phase->C) IfNode( top_if->in(0), boo, PROB_UNLIKELY_MAG(5), top_if->_fcnt )); IfNode *iff = (IfNode*)gvn->register_new_node_with_optimizer(new IfNode( top_if->in(0), boo, PROB_UNLIKELY_MAG(5), top_if->_fcnt ));
Node *if_min= gvn->register_new_node_with_optimizer(new (phase->C) IfTrueNode (iff)); Node *if_min= gvn->register_new_node_with_optimizer(new IfTrueNode (iff));
Node *ifF = gvn->register_new_node_with_optimizer(new (phase->C) IfFalseNode(iff)); Node *ifF = gvn->register_new_node_with_optimizer(new IfFalseNode(iff));
// min test // min test
cmp = gvn->register_new_node_with_optimizer(new (phase->C) CmpINode( convf2i, max )); cmp = gvn->register_new_node_with_optimizer(new CmpINode( convf2i, max ));
boo = gvn->register_new_node_with_optimizer(new (phase->C) BoolNode( cmp, BoolTest::gt )); boo = gvn->register_new_node_with_optimizer(new BoolNode( cmp, BoolTest::gt ));
iff = (IfNode*)gvn->register_new_node_with_optimizer(new (phase->C) IfNode( ifF, boo, PROB_UNLIKELY_MAG(5), bot_if->_fcnt )); iff = (IfNode*)gvn->register_new_node_with_optimizer(new IfNode( ifF, boo, PROB_UNLIKELY_MAG(5), bot_if->_fcnt ));
Node *if_max= gvn->register_new_node_with_optimizer(new (phase->C) IfTrueNode (iff)); Node *if_max= gvn->register_new_node_with_optimizer(new IfTrueNode (iff));
ifF = gvn->register_new_node_with_optimizer(new (phase->C) IfFalseNode(iff)); ifF = gvn->register_new_node_with_optimizer(new IfFalseNode(iff));
// update input edges to region node // update input edges to region node
set_req_X( min_idx, if_min, gvn ); set_req_X( min_idx, if_min, gvn );
set_req_X( max_idx, if_max, gvn ); set_req_X( max_idx, if_max, gvn );
@ -731,7 +731,7 @@ const TypePtr* flatten_phi_adr_type(const TypePtr* at) {
PhiNode* PhiNode::make(Node* r, Node* x, const Type *t, const TypePtr* at) { PhiNode* PhiNode::make(Node* r, Node* x, const Type *t, const TypePtr* at) {
uint preds = r->req(); // Number of predecessor paths uint preds = r->req(); // Number of predecessor paths
assert(t != Type::MEMORY || at == flatten_phi_adr_type(at), "flatten at"); assert(t != Type::MEMORY || at == flatten_phi_adr_type(at), "flatten at");
PhiNode* p = new (Compile::current()) PhiNode(r, t, at); PhiNode* p = new PhiNode(r, t, at);
for (uint j = 1; j < preds; j++) { for (uint j = 1; j < preds; j++) {
// Fill in all inputs, except those which the region does not yet have // Fill in all inputs, except those which the region does not yet have
if (r->in(j) != NULL) if (r->in(j) != NULL)
@ -749,7 +749,7 @@ PhiNode* PhiNode::make_blank(Node* r, Node* x) {
const Type* t = x->bottom_type(); const Type* t = x->bottom_type();
const TypePtr* at = NULL; const TypePtr* at = NULL;
if (t == Type::MEMORY) at = flatten_phi_adr_type(x->adr_type()); if (t == Type::MEMORY) at = flatten_phi_adr_type(x->adr_type());
return new (Compile::current()) PhiNode(r, t, at); return new PhiNode(r, t, at);
} }
@ -1258,9 +1258,9 @@ static Node *is_x2logic( PhaseGVN *phase, PhiNode *phi, int true_path ) {
} else return NULL; } else return NULL;
// Build int->bool conversion // Build int->bool conversion
Node *n = new (phase->C) Conv2BNode( cmp->in(1) ); Node *n = new Conv2BNode( cmp->in(1) );
if( flipped ) if( flipped )
n = new (phase->C) XorINode( phase->transform(n), phase->intcon(1) ); n = new XorINode( phase->transform(n), phase->intcon(1) );
return n; return n;
} }
@ -1320,9 +1320,9 @@ static Node* is_cond_add(PhaseGVN *phase, PhiNode *phi, int true_path) {
if( q->is_Con() && phase->type(q) != TypeInt::ZERO && y->is_Con() ) if( q->is_Con() && phase->type(q) != TypeInt::ZERO && y->is_Con() )
return NULL; return NULL;
Node *cmplt = phase->transform( new (phase->C) CmpLTMaskNode(p,q) ); Node *cmplt = phase->transform( new CmpLTMaskNode(p,q) );
Node *j_and = phase->transform( new (phase->C) AndINode(cmplt,y) ); Node *j_and = phase->transform( new AndINode(cmplt,y) );
return new (phase->C) AddINode(j_and,x); return new AddINode(j_and,x);
} }
//------------------------------is_absolute------------------------------------ //------------------------------is_absolute------------------------------------
@ -1384,17 +1384,17 @@ static Node* is_absolute( PhaseGVN *phase, PhiNode *phi_root, int true_path) {
if( sub->Opcode() != Op_SubF || if( sub->Opcode() != Op_SubF ||
sub->in(2) != x || sub->in(2) != x ||
phase->type(sub->in(1)) != tzero ) return NULL; phase->type(sub->in(1)) != tzero ) return NULL;
x = new (phase->C) AbsFNode(x); x = new AbsFNode(x);
if (flip) { if (flip) {
x = new (phase->C) SubFNode(sub->in(1), phase->transform(x)); x = new SubFNode(sub->in(1), phase->transform(x));
} }
} else { } else {
if( sub->Opcode() != Op_SubD || if( sub->Opcode() != Op_SubD ||
sub->in(2) != x || sub->in(2) != x ||
phase->type(sub->in(1)) != tzero ) return NULL; phase->type(sub->in(1)) != tzero ) return NULL;
x = new (phase->C) AbsDNode(x); x = new AbsDNode(x);
if (flip) { if (flip) {
x = new (phase->C) SubDNode(sub->in(1), phase->transform(x)); x = new SubDNode(sub->in(1), phase->transform(x));
} }
} }
@ -1469,7 +1469,7 @@ static Node* split_flow_path(PhaseGVN *phase, PhiNode *phi) {
// Now start splitting out the flow paths that merge the same value. // Now start splitting out the flow paths that merge the same value.
// Split first the RegionNode. // Split first the RegionNode.
PhaseIterGVN *igvn = phase->is_IterGVN(); PhaseIterGVN *igvn = phase->is_IterGVN();
RegionNode *newr = new (phase->C) RegionNode(hit+1); RegionNode *newr = new RegionNode(hit+1);
split_once(igvn, phi, val, r, newr); split_once(igvn, phi, val, r, newr);
// Now split all other Phis than this one // Now split all other Phis than this one
@ -1781,13 +1781,13 @@ Node *PhiNode::Ideal(PhaseGVN *phase, bool can_reshape) {
} }
if (doit) { if (doit) {
if (base == NULL) { if (base == NULL) {
base = new (phase->C) PhiNode(in(0), type, NULL); base = new PhiNode(in(0), type, NULL);
for (uint i = 1; i < req(); i++) { for (uint i = 1; i < req(); i++) {
base->init_req(i, in(i)->in(AddPNode::Base)); base->init_req(i, in(i)->in(AddPNode::Base));
} }
phase->is_IterGVN()->register_new_node_with_optimizer(base); phase->is_IterGVN()->register_new_node_with_optimizer(base);
} }
return new (phase->C) AddPNode(base, base, y); return new AddPNode(base, base, y);
} }
} }
} }
@ -1864,7 +1864,7 @@ Node *PhiNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// Phi(...MergeMem(m0, m1:AT1, m2:AT2)...) into // Phi(...MergeMem(m0, m1:AT1, m2:AT2)...) into
// MergeMem(Phi(...m0...), Phi:AT1(...m1...), Phi:AT2(...m2...)) // MergeMem(Phi(...m0...), Phi:AT1(...m1...), Phi:AT2(...m2...))
PhaseIterGVN *igvn = phase->is_IterGVN(); PhaseIterGVN *igvn = phase->is_IterGVN();
Node* hook = new (phase->C) Node(1); Node* hook = new Node(1);
PhiNode* new_base = (PhiNode*) clone(); PhiNode* new_base = (PhiNode*) clone();
// Must eagerly register phis, since they participate in loops. // Must eagerly register phis, since they participate in loops.
if (igvn) { if (igvn) {
@ -1961,7 +1961,7 @@ Node *PhiNode::Ideal(PhaseGVN *phase, bool can_reshape) {
} else { } else {
narrow_t = TypeNarrowKlass::make(this->bottom_type()->is_ptr()); narrow_t = TypeNarrowKlass::make(this->bottom_type()->is_ptr());
} }
PhiNode* new_phi = new (phase->C) PhiNode(r, narrow_t); PhiNode* new_phi = new PhiNode(r, narrow_t);
uint orig_cnt = req(); uint orig_cnt = req();
for (uint i=1; i<req(); ++i) {// For all paths in for (uint i=1; i<req(); ++i) {// For all paths in
Node *ii = in(i); Node *ii = in(i);
@ -1975,9 +1975,9 @@ Node *PhiNode::Ideal(PhaseGVN *phase, bool can_reshape) {
new_ii = new_phi; new_ii = new_phi;
} else { } else {
if (is_decodeN) { if (is_decodeN) {
new_ii = new (phase->C) EncodePNode(ii, narrow_t); new_ii = new EncodePNode(ii, narrow_t);
} else { } else {
new_ii = new (phase->C) EncodePKlassNode(ii, narrow_t); new_ii = new EncodePKlassNode(ii, narrow_t);
} }
igvn->register_new_node_with_optimizer(new_ii); igvn->register_new_node_with_optimizer(new_ii);
} }
@ -1986,9 +1986,9 @@ Node *PhiNode::Ideal(PhaseGVN *phase, bool can_reshape) {
} }
igvn->register_new_node_with_optimizer(new_phi, this); igvn->register_new_node_with_optimizer(new_phi, this);
if (is_decodeN) { if (is_decodeN) {
progress = new (phase->C) DecodeNNode(new_phi, bottom_type()); progress = new DecodeNNode(new_phi, bottom_type());
} else { } else {
progress = new (phase->C) DecodeNKlassNode(new_phi, bottom_type()); progress = new DecodeNKlassNode(new_phi, bottom_type());
} }
} }
} }

4
hotspot/src/share/vm/opto/chaitin.cpp
View file

@ -1730,7 +1730,7 @@ Node *PhaseChaitin::find_base_for_derived( Node **derived_base_map, Node *derive
// Now we see we need a base-Phi here to merge the bases // Now we see we need a base-Phi here to merge the bases
const Type *t = base->bottom_type(); const Type *t = base->bottom_type();
base = new (C) PhiNode( derived->in(0), t ); base = new PhiNode( derived->in(0), t );
for( i = 1; i < derived->req(); i++ ) { for( i = 1; i < derived->req(); i++ ) {
base->init_req(i, find_base_for_derived(derived_base_map, derived->in(i), maxlrg)); base->init_req(i, find_base_for_derived(derived_base_map, derived->in(i), maxlrg));
t = t->meet(base->in(i)->bottom_type()); t = t->meet(base->in(i)->bottom_type());
@ -1800,7 +1800,7 @@ bool PhaseChaitin::stretch_base_pointer_live_ranges(ResourceArea *a) {
Block *phi_block = _cfg.get_block_for_node(phi); Block *phi_block = _cfg.get_block_for_node(phi);
if (_cfg.get_block_for_node(phi_block->pred(2)) == block) { if (_cfg.get_block_for_node(phi_block->pred(2)) == block) {
const RegMask *mask = C->matcher()->idealreg2spillmask[Op_RegI]; const RegMask *mask = C->matcher()->idealreg2spillmask[Op_RegI];
Node *spill = new (C) MachSpillCopyNode(MachSpillCopyNode::LoopPhiInput, phi, *mask, *mask); Node *spill = new MachSpillCopyNode(MachSpillCopyNode::LoopPhiInput, phi, *mask, *mask);
insert_proj( phi_block, 1, spill, maxlrg++ ); insert_proj( phi_block, 1, spill, maxlrg++ );
n->set_req(1,spill); n->set_req(1,spill);
must_recompute_live = true; must_recompute_live = true;

6
hotspot/src/share/vm/opto/coalesce.cpp
View file

@ -291,7 +291,7 @@ void PhaseAggressiveCoalesce::insert_copies( Matcher &matcher ) {
_phc.clone_projs(pred, pred->end_idx(), m, copy, _phc._lrg_map); _phc.clone_projs(pred, pred->end_idx(), m, copy, _phc._lrg_map);
} else { } else {
const RegMask *rm = C->matcher()->idealreg2spillmask[m->ideal_reg()]; const RegMask *rm = C->matcher()->idealreg2spillmask[m->ideal_reg()];
copy = new (C) MachSpillCopyNode(MachSpillCopyNode::PhiInput, m, *rm, *rm); copy = new MachSpillCopyNode(MachSpillCopyNode::PhiInput, m, *rm, *rm);
// Find a good place to insert. Kinda tricky, use a subroutine // Find a good place to insert. Kinda tricky, use a subroutine
insert_copy_with_overlap(pred,copy,phi_name,src_name); insert_copy_with_overlap(pred,copy,phi_name,src_name);
} }
@ -325,7 +325,7 @@ void PhaseAggressiveCoalesce::insert_copies( Matcher &matcher ) {
l += _phc.clone_projs(b, l, m, copy, _phc._lrg_map); l += _phc.clone_projs(b, l, m, copy, _phc._lrg_map);
} else { } else {
const RegMask *rm = C->matcher()->idealreg2spillmask[m->ideal_reg()]; const RegMask *rm = C->matcher()->idealreg2spillmask[m->ideal_reg()];
copy = new (C) MachSpillCopyNode(MachSpillCopyNode::TwoAddress, m, *rm, *rm); copy = new MachSpillCopyNode(MachSpillCopyNode::TwoAddress, m, *rm, *rm);
// Insert the copy in the basic block, just before us // Insert the copy in the basic block, just before us
b->insert_node(copy, l++); b->insert_node(copy, l++);
} }
@ -372,7 +372,7 @@ void PhaseAggressiveCoalesce::insert_copies( Matcher &matcher ) {
continue; // Live out; do not pre-split continue; // Live out; do not pre-split
// Split the lrg at this use // Split the lrg at this use
const RegMask *rm = C->matcher()->idealreg2spillmask[inp->ideal_reg()]; const RegMask *rm = C->matcher()->idealreg2spillmask[inp->ideal_reg()];
Node* copy = new (C) MachSpillCopyNode(MachSpillCopyNode::DebugUse, inp, *rm, *rm); Node* copy = new MachSpillCopyNode(MachSpillCopyNode::DebugUse, inp, *rm, *rm);
// Insert the copy in the use-def chain // Insert the copy in the use-def chain
n->set_req(inpidx, copy ); n->set_req(inpidx, copy );
// Insert the copy in the basic block, just before us // Insert the copy in the basic block, just before us

26
hotspot/src/share/vm/opto/compile.cpp
View file

@ -95,7 +95,7 @@
// Constant table base node singleton. // Constant table base node singleton.
MachConstantBaseNode* Compile::mach_constant_base_node() { MachConstantBaseNode* Compile::mach_constant_base_node() {
if (_mach_constant_base_node == NULL) { if (_mach_constant_base_node == NULL) {
_mach_constant_base_node = new (C) MachConstantBaseNode(); _mach_constant_base_node = new MachConstantBaseNode();
_mach_constant_base_node->add_req(C->root()); _mach_constant_base_node->add_req(C->root());
} }
return _mach_constant_base_node; return _mach_constant_base_node;
@ -748,14 +748,14 @@ Compile::Compile( ciEnv* ci_env, C2Compiler* compiler, ciMethod* target, int osr
const TypeTuple *domain = StartOSRNode::osr_domain(); const TypeTuple *domain = StartOSRNode::osr_domain();
const TypeTuple *range = TypeTuple::make_range(method()->signature()); const TypeTuple *range = TypeTuple::make_range(method()->signature());
init_tf(TypeFunc::make(domain, range)); init_tf(TypeFunc::make(domain, range));
StartNode* s = new (this) StartOSRNode(root(), domain); StartNode* s = new StartOSRNode(root(), domain);
initial_gvn()->set_type_bottom(s); initial_gvn()->set_type_bottom(s);
init_start(s); init_start(s);
cg = CallGenerator::for_osr(method(), entry_bci()); cg = CallGenerator::for_osr(method(), entry_bci());
} else { } else {
// Normal case. // Normal case.
init_tf(TypeFunc::make(method())); init_tf(TypeFunc::make(method()));
StartNode* s = new (this) StartNode(root(), tf()->domain()); StartNode* s = new StartNode(root(), tf()->domain());
initial_gvn()->set_type_bottom(s); initial_gvn()->set_type_bottom(s);
init_start(s); init_start(s);
if (method()->intrinsic_id() == vmIntrinsics::_Reference_get && UseG1GC) { if (method()->intrinsic_id() == vmIntrinsics::_Reference_get && UseG1GC) {
@ -1061,9 +1061,9 @@ void Compile::Init(int aliaslevel) {
// Globally visible Nodes // Globally visible Nodes
// First set TOP to NULL to give safe behavior during creation of RootNode // First set TOP to NULL to give safe behavior during creation of RootNode
set_cached_top_node(NULL); set_cached_top_node(NULL);
set_root(new (this) RootNode()); set_root(new RootNode());
// Now that you have a Root to point to, create the real TOP // Now that you have a Root to point to, create the real TOP
set_cached_top_node( new (this) ConNode(Type::TOP) ); set_cached_top_node( new ConNode(Type::TOP) );
set_recent_alloc(NULL, NULL); set_recent_alloc(NULL, NULL);
// Create Debug Information Recorder to record scopes, oopmaps, etc. // Create Debug Information Recorder to record scopes, oopmaps, etc.
@ -2757,9 +2757,9 @@ void Compile::final_graph_reshaping_impl( Node *n, Final_Reshape_Counts &frc) {
// Decode a narrow oop to match address // Decode a narrow oop to match address
// [R12 + narrow_oop_reg<<3 + offset] // [R12 + narrow_oop_reg<<3 + offset]
if (t->isa_oopptr()) { if (t->isa_oopptr()) {
nn = new (this) DecodeNNode(nn, t); nn = new DecodeNNode(nn, t);
} else { } else {
nn = new (this) DecodeNKlassNode(nn, t); nn = new DecodeNKlassNode(nn, t);
} }
n->set_req(AddPNode::Base, nn); n->set_req(AddPNode::Base, nn);
n->set_req(AddPNode::Address, nn); n->set_req(AddPNode::Address, nn);
@ -2880,7 +2880,7 @@ void Compile::final_graph_reshaping_impl( Node *n, Final_Reshape_Counts &frc) {
} }
} }
if (new_in2 != NULL) { if (new_in2 != NULL) {
Node* cmpN = new (this) CmpNNode(in1->in(1), new_in2); Node* cmpN = new CmpNNode(in1->in(1), new_in2);
n->subsume_by(cmpN, this); n->subsume_by(cmpN, this);
if (in1->outcnt() == 0) { if (in1->outcnt() == 0) {
in1->disconnect_inputs(NULL, this); in1->disconnect_inputs(NULL, this);
@ -2979,8 +2979,8 @@ void Compile::final_graph_reshaping_impl( Node *n, Final_Reshape_Counts &frc) {
n->subsume_by(divmod->mod_proj(), this); n->subsume_by(divmod->mod_proj(), this);
} else { } else {
// replace a%b with a-((a/b)*b) // replace a%b with a-((a/b)*b)
Node* mult = new (this) MulINode(d, d->in(2)); Node* mult = new MulINode(d, d->in(2));
Node* sub = new (this) SubINode(d->in(1), mult); Node* sub = new SubINode(d->in(1), mult);
n->subsume_by(sub, this); n->subsume_by(sub, this);
} }
} }
@ -2999,8 +2999,8 @@ void Compile::final_graph_reshaping_impl( Node *n, Final_Reshape_Counts &frc) {
n->subsume_by(divmod->mod_proj(), this); n->subsume_by(divmod->mod_proj(), this);
} else { } else {
// replace a%b with a-((a/b)*b) // replace a%b with a-((a/b)*b)
Node* mult = new (this) MulLNode(d, d->in(2)); Node* mult = new MulLNode(d, d->in(2));
Node* sub = new (this) SubLNode(d->in(1), mult); Node* sub = new SubLNode(d->in(1), mult);
n->subsume_by(sub, this); n->subsume_by(sub, this);
} }
} }
@ -3049,7 +3049,7 @@ void Compile::final_graph_reshaping_impl( Node *n, Final_Reshape_Counts &frc) {
} }
} else { } else {
if (t == NULL || t->_lo < 0 || t->_hi > (int)mask) { if (t == NULL || t->_lo < 0 || t->_hi > (int)mask) {
Node* shift = new (this) AndINode(in2, ConNode::make(this, TypeInt::make(mask))); Node* shift = new AndINode(in2, ConNode::make(this, TypeInt::make(mask)));
n->set_req(2, shift); n->set_req(2, shift);
} }
} }

22
hotspot/src/share/vm/opto/connode.cpp
View file

@ -45,17 +45,17 @@ uint ConNode::hash() const {
//------------------------------make------------------------------------------- //------------------------------make-------------------------------------------
ConNode *ConNode::make( Compile* C, const Type *t ) { ConNode *ConNode::make( Compile* C, const Type *t ) {
switch( t->basic_type() ) { switch( t->basic_type() ) {
case T_INT: return new (C) ConINode( t->is_int() ); case T_INT: return new ConINode( t->is_int() );
case T_LONG: return new (C) ConLNode( t->is_long() ); case T_LONG: return new ConLNode( t->is_long() );
case T_FLOAT: return new (C) ConFNode( t->is_float_constant() ); case T_FLOAT: return new ConFNode( t->is_float_constant() );
case T_DOUBLE: return new (C) ConDNode( t->is_double_constant() ); case T_DOUBLE: return new ConDNode( t->is_double_constant() );
case T_VOID: return new (C) ConNode ( Type::TOP ); case T_VOID: return new ConNode ( Type::TOP );
case T_OBJECT: return new (C) ConPNode( t->is_ptr() ); case T_OBJECT: return new ConPNode( t->is_ptr() );
case T_ARRAY: return new (C) ConPNode( t->is_aryptr() ); case T_ARRAY: return new ConPNode( t->is_aryptr() );
case T_ADDRESS: return new (C) ConPNode( t->is_ptr() ); case T_ADDRESS: return new ConPNode( t->is_ptr() );
case T_NARROWOOP: return new (C) ConNNode( t->is_narrowoop() ); case T_NARROWOOP: return new ConNNode( t->is_narrowoop() );
case T_NARROWKLASS: return new (C) ConNKlassNode( t->is_narrowklass() ); case T_NARROWKLASS: return new ConNKlassNode( t->is_narrowklass() );
case T_METADATA: return new (C) ConPNode( t->is_ptr() ); case T_METADATA: return new ConPNode( t->is_ptr() );
// Expected cases: TypePtr::NULL_PTR, any is_rawptr() // Expected cases: TypePtr::NULL_PTR, any is_rawptr()
// Also seen: AnyPtr(TopPTR *+top); from command line: // Also seen: AnyPtr(TopPTR *+top); from command line:
// r -XX:+PrintOpto -XX:CIStart=285 -XX:+CompileTheWorld -XX:CompileTheWorldStartAt=660 // r -XX:+PrintOpto -XX:CIStart=285 -XX:+CompileTheWorld -XX:CompileTheWorldStartAt=660

12
hotspot/src/share/vm/opto/connode.hpp
View file

@ -58,7 +58,7 @@ public:
// Factory method: // Factory method:
static ConINode* make( Compile* C, int con ) { static ConINode* make( Compile* C, int con ) {
return new (C) ConINode( TypeInt::make(con) ); return new ConINode( TypeInt::make(con) );
} }
}; };
@ -73,9 +73,9 @@ public:
// Factory methods: // Factory methods:
static ConPNode* make( Compile *C ,address con ) { static ConPNode* make( Compile *C ,address con ) {
if (con == NULL) if (con == NULL)
return new (C) ConPNode( TypePtr::NULL_PTR ) ; return new ConPNode( TypePtr::NULL_PTR ) ;
else else
return new (C) ConPNode( TypeRawPtr::make(con) ); return new ConPNode( TypeRawPtr::make(con) );
} }
}; };
@ -106,7 +106,7 @@ public:
// Factory method: // Factory method:
static ConLNode* make( Compile *C ,jlong con ) { static ConLNode* make( Compile *C ,jlong con ) {
return new (C) ConLNode( TypeLong::make(con) ); return new ConLNode( TypeLong::make(con) );
} }
}; };
@ -120,7 +120,7 @@ public:
// Factory method: // Factory method:
static ConFNode* make( Compile *C, float con ) { static ConFNode* make( Compile *C, float con ) {
return new (C) ConFNode( TypeF::make(con) ); return new ConFNode( TypeF::make(con) );
} }
}; };
@ -134,7 +134,7 @@ public:
// Factory method: // Factory method:
static ConDNode* make( Compile *C, double con ) { static ConDNode* make( Compile *C, double con ) {
return new (C) ConDNode( TypeD::make(con) ); return new ConDNode( TypeD::make(con) );
} }
}; };

14
hotspot/src/share/vm/opto/convertnode.cpp
View file

@ -374,11 +374,11 @@ Node *ConvI2LNode::Ideal(PhaseGVN *phase, bool can_reshape) {
ryhi = -rylo0; ryhi = -rylo0;
} }
Node* cx = phase->transform( new (phase->C) ConvI2LNode(x, TypeLong::make(rxlo, rxhi, widen)) ); Node* cx = phase->transform( new ConvI2LNode(x, TypeLong::make(rxlo, rxhi, widen)) );
Node* cy = phase->transform( new (phase->C) ConvI2LNode(y, TypeLong::make(rylo, ryhi, widen)) ); Node* cy = phase->transform( new ConvI2LNode(y, TypeLong::make(rylo, ryhi, widen)) );
switch (op) { switch (op) {
case Op_AddI: return new (phase->C) AddLNode(cx, cy); case Op_AddI: return new AddLNode(cx, cy);
case Op_SubI: return new (phase->C) SubLNode(cx, cy); case Op_SubI: return new SubLNode(cx, cy);
default: ShouldNotReachHere(); default: ShouldNotReachHere();
} }
} }
@ -452,9 +452,9 @@ Node *ConvL2INode::Ideal(PhaseGVN *phase, bool can_reshape) {
assert( x != andl && y != andl, "dead loop in ConvL2INode::Ideal" ); assert( x != andl && y != andl, "dead loop in ConvL2INode::Ideal" );
if (phase->type(x) == Type::TOP) return NULL; if (phase->type(x) == Type::TOP) return NULL;
if (phase->type(y) == Type::TOP) return NULL; if (phase->type(y) == Type::TOP) return NULL;
Node *add1 = phase->transform(new (phase->C) ConvL2INode(x)); Node *add1 = phase->transform(new ConvL2INode(x));
Node *add2 = phase->transform(new (phase->C) ConvL2INode(y)); Node *add2 = phase->transform(new ConvL2INode(y));
return new (phase->C) AddINode(add1,add2); return new AddINode(add1,add2);
} }
// Disable optimization: LoadL->ConvL2I ==> LoadI. // Disable optimization: LoadL->ConvL2I ==> LoadI.

168
hotspot/src/share/vm/opto/divnode.cpp
View file

@ -106,7 +106,7 @@ static Node *transform_int_divide( PhaseGVN *phase, Node *dividend, jint divisor
// division by +/- 1 // division by +/- 1
if (!d_pos) { if (!d_pos) {
// Just negate the value // Just negate the value
q = new (phase->C) SubINode(phase->intcon(0), dividend); q = new SubINode(phase->intcon(0), dividend);
} }
} else if ( is_power_of_2(d) ) { } else if ( is_power_of_2(d) ) {
// division by +/- a power of 2 // division by +/- a power of 2
@ -143,18 +143,18 @@ static Node *transform_int_divide( PhaseGVN *phase, Node *dividend, jint divisor
// (-2+3)>>2 becomes 0, etc. // (-2+3)>>2 becomes 0, etc.
// Compute 0 or -1, based on sign bit // Compute 0 or -1, based on sign bit
Node *sign = phase->transform(new (phase->C) RShiftINode(dividend, phase->intcon(N - 1))); Node *sign = phase->transform(new RShiftINode(dividend, phase->intcon(N - 1)));
// Mask sign bit to the low sign bits // Mask sign bit to the low sign bits
Node *round = phase->transform(new (phase->C) URShiftINode(sign, phase->intcon(N - l))); Node *round = phase->transform(new URShiftINode(sign, phase->intcon(N - l)));
// Round up before shifting // Round up before shifting
dividend = phase->transform(new (phase->C) AddINode(dividend, round)); dividend = phase->transform(new AddINode(dividend, round));
} }
// Shift for division // Shift for division
q = new (phase->C) RShiftINode(dividend, phase->intcon(l)); q = new RShiftINode(dividend, phase->intcon(l));
if (!d_pos) { if (!d_pos) {
q = new (phase->C) SubINode(phase->intcon(0), phase->transform(q)); q = new SubINode(phase->intcon(0), phase->transform(q));
} }
} else { } else {
// Attempt the jint constant divide -> multiply transform found in // Attempt the jint constant divide -> multiply transform found in
@ -166,33 +166,33 @@ static Node *transform_int_divide( PhaseGVN *phase, Node *dividend, jint divisor
jint shift_const; jint shift_const;
if (magic_int_divide_constants(d, magic_const, shift_const)) { if (magic_int_divide_constants(d, magic_const, shift_const)) {
Node *magic = phase->longcon(magic_const); Node *magic = phase->longcon(magic_const);
Node *dividend_long = phase->transform(new (phase->C) ConvI2LNode(dividend)); Node *dividend_long = phase->transform(new ConvI2LNode(dividend));
// Compute the high half of the dividend x magic multiplication // Compute the high half of the dividend x magic multiplication
Node *mul_hi = phase->transform(new (phase->C) MulLNode(dividend_long, magic)); Node *mul_hi = phase->transform(new MulLNode(dividend_long, magic));
if (magic_const < 0) { if (magic_const < 0) {
mul_hi = phase->transform(new (phase->C) RShiftLNode(mul_hi, phase->intcon(N))); mul_hi = phase->transform(new RShiftLNode(mul_hi, phase->intcon(N)));
mul_hi = phase->transform(new (phase->C) ConvL2INode(mul_hi)); mul_hi = phase->transform(new ConvL2INode(mul_hi));
// The magic multiplier is too large for a 32 bit constant. We've adjusted // The magic multiplier is too large for a 32 bit constant. We've adjusted
// it down by 2^32, but have to add 1 dividend back in after the multiplication. // it down by 2^32, but have to add 1 dividend back in after the multiplication.
// This handles the "overflow" case described by Granlund and Montgomery. // This handles the "overflow" case described by Granlund and Montgomery.
mul_hi = phase->transform(new (phase->C) AddINode(dividend, mul_hi)); mul_hi = phase->transform(new AddINode(dividend, mul_hi));
// Shift over the (adjusted) mulhi // Shift over the (adjusted) mulhi
if (shift_const != 0) { if (shift_const != 0) {
mul_hi = phase->transform(new (phase->C) RShiftINode(mul_hi, phase->intcon(shift_const))); mul_hi = phase->transform(new RShiftINode(mul_hi, phase->intcon(shift_const)));
} }
} else { } else {
// No add is required, we can merge the shifts together. // No add is required, we can merge the shifts together.
mul_hi = phase->transform(new (phase->C) RShiftLNode(mul_hi, phase->intcon(N + shift_const))); mul_hi = phase->transform(new RShiftLNode(mul_hi, phase->intcon(N + shift_const)));
mul_hi = phase->transform(new (phase->C) ConvL2INode(mul_hi)); mul_hi = phase->transform(new ConvL2INode(mul_hi));
} }
// Get a 0 or -1 from the sign of the dividend. // Get a 0 or -1 from the sign of the dividend.
Node *addend0 = mul_hi; Node *addend0 = mul_hi;
Node *addend1 = phase->transform(new (phase->C) RShiftINode(dividend, phase->intcon(N-1))); Node *addend1 = phase->transform(new RShiftINode(dividend, phase->intcon(N-1)));
// If the divisor is negative, swap the order of the input addends; // If the divisor is negative, swap the order of the input addends;
// this has the effect of negating the quotient. // this has the effect of negating the quotient.
@ -202,7 +202,7 @@ static Node *transform_int_divide( PhaseGVN *phase, Node *dividend, jint divisor
// Adjust the final quotient by subtracting -1 (adding 1) // Adjust the final quotient by subtracting -1 (adding 1)
// from the mul_hi. // from the mul_hi.
q = new (phase->C) SubINode(addend0, addend1); q = new SubINode(addend0, addend1);
} }
} }
@ -261,7 +261,7 @@ static Node* long_by_long_mulhi(PhaseGVN* phase, Node* dividend, jlong magic_con
// no need to synthesize it in ideal nodes. // no need to synthesize it in ideal nodes.
if (Matcher::has_match_rule(Op_MulHiL)) { if (Matcher::has_match_rule(Op_MulHiL)) {
Node* v = phase->longcon(magic_const); Node* v = phase->longcon(magic_const);
return new (phase->C) MulHiLNode(dividend, v); return new MulHiLNode(dividend, v);
} }
// Taken from Hacker's Delight, Fig. 8-2. Multiply high signed. // Taken from Hacker's Delight, Fig. 8-2. Multiply high signed.
@ -287,11 +287,11 @@ static Node* long_by_long_mulhi(PhaseGVN* phase, Node* dividend, jlong magic_con
const int N = 64; const int N = 64;
// Dummy node to keep intermediate nodes alive during construction // Dummy node to keep intermediate nodes alive during construction
Node* hook = new (phase->C) Node(4); Node* hook = new Node(4);
// u0 = u & 0xFFFFFFFF; u1 = u >> 32; // u0 = u & 0xFFFFFFFF; u1 = u >> 32;
Node* u0 = phase->transform(new (phase->C) AndLNode(dividend, phase->longcon(0xFFFFFFFF))); Node* u0 = phase->transform(new AndLNode(dividend, phase->longcon(0xFFFFFFFF)));
Node* u1 = phase->transform(new (phase->C) RShiftLNode(dividend, phase->intcon(N / 2))); Node* u1 = phase->transform(new RShiftLNode(dividend, phase->intcon(N / 2)));
hook->init_req(0, u0); hook->init_req(0, u0);
hook->init_req(1, u1); hook->init_req(1, u1);
@ -300,29 +300,29 @@ static Node* long_by_long_mulhi(PhaseGVN* phase, Node* dividend, jlong magic_con
Node* v1 = phase->longcon(magic_const >> (N / 2)); Node* v1 = phase->longcon(magic_const >> (N / 2));
// w0 = u0*v0; // w0 = u0*v0;
Node* w0 = phase->transform(new (phase->C) MulLNode(u0, v0)); Node* w0 = phase->transform(new MulLNode(u0, v0));
// t = u1*v0 + (w0 >> 32); // t = u1*v0 + (w0 >> 32);
Node* u1v0 = phase->transform(new (phase->C) MulLNode(u1, v0)); Node* u1v0 = phase->transform(new MulLNode(u1, v0));
Node* temp = phase->transform(new (phase->C) URShiftLNode(w0, phase->intcon(N / 2))); Node* temp = phase->transform(new URShiftLNode(w0, phase->intcon(N / 2)));
Node* t = phase->transform(new (phase->C) AddLNode(u1v0, temp)); Node* t = phase->transform(new AddLNode(u1v0, temp));
hook->init_req(2, t); hook->init_req(2, t);
// w1 = t & 0xFFFFFFFF; // w1 = t & 0xFFFFFFFF;
Node* w1 = phase->transform(new (phase->C) AndLNode(t, phase->longcon(0xFFFFFFFF))); Node* w1 = phase->transform(new AndLNode(t, phase->longcon(0xFFFFFFFF)));
hook->init_req(3, w1); hook->init_req(3, w1);
// w2 = t >> 32; // w2 = t >> 32;
Node* w2 = phase->transform(new (phase->C) RShiftLNode(t, phase->intcon(N / 2))); Node* w2 = phase->transform(new RShiftLNode(t, phase->intcon(N / 2)));
// w1 = u0*v1 + w1; // w1 = u0*v1 + w1;
Node* u0v1 = phase->transform(new (phase->C) MulLNode(u0, v1)); Node* u0v1 = phase->transform(new MulLNode(u0, v1));
w1 = phase->transform(new (phase->C) AddLNode(u0v1, w1)); w1 = phase->transform(new AddLNode(u0v1, w1));
// return u1*v1 + w2 + (w1 >> 32); // return u1*v1 + w2 + (w1 >> 32);
Node* u1v1 = phase->transform(new (phase->C) MulLNode(u1, v1)); Node* u1v1 = phase->transform(new MulLNode(u1, v1));
Node* temp1 = phase->transform(new (phase->C) AddLNode(u1v1, w2)); Node* temp1 = phase->transform(new AddLNode(u1v1, w2));
Node* temp2 = phase->transform(new (phase->C) RShiftLNode(w1, phase->intcon(N / 2))); Node* temp2 = phase->transform(new RShiftLNode(w1, phase->intcon(N / 2)));
// Remove the bogus extra edges used to keep things alive // Remove the bogus extra edges used to keep things alive
PhaseIterGVN* igvn = phase->is_IterGVN(); PhaseIterGVN* igvn = phase->is_IterGVN();
@ -334,7 +334,7 @@ static Node* long_by_long_mulhi(PhaseGVN* phase, Node* dividend, jlong magic_con
} }
} }
return new (phase->C) AddLNode(temp1, temp2); return new AddLNode(temp1, temp2);
} }
@ -357,7 +357,7 @@ static Node *transform_long_divide( PhaseGVN *phase, Node *dividend, jlong divis
// division by +/- 1 // division by +/- 1
if (!d_pos) { if (!d_pos) {
// Just negate the value // Just negate the value
q = new (phase->C) SubLNode(phase->longcon(0), dividend); q = new SubLNode(phase->longcon(0), dividend);
} }
} else if ( is_power_of_2_long(d) ) { } else if ( is_power_of_2_long(d) ) {
@ -396,18 +396,18 @@ static Node *transform_long_divide( PhaseGVN *phase, Node *dividend, jlong divis
// (-2+3)>>2 becomes 0, etc. // (-2+3)>>2 becomes 0, etc.
// Compute 0 or -1, based on sign bit // Compute 0 or -1, based on sign bit
Node *sign = phase->transform(new (phase->C) RShiftLNode(dividend, phase->intcon(N - 1))); Node *sign = phase->transform(new RShiftLNode(dividend, phase->intcon(N - 1)));
// Mask sign bit to the low sign bits // Mask sign bit to the low sign bits
Node *round = phase->transform(new (phase->C) URShiftLNode(sign, phase->intcon(N - l))); Node *round = phase->transform(new URShiftLNode(sign, phase->intcon(N - l)));
// Round up before shifting // Round up before shifting
dividend = phase->transform(new (phase->C) AddLNode(dividend, round)); dividend = phase->transform(new AddLNode(dividend, round));
} }
// Shift for division // Shift for division
q = new (phase->C) RShiftLNode(dividend, phase->intcon(l)); q = new RShiftLNode(dividend, phase->intcon(l));
if (!d_pos) { if (!d_pos) {
q = new (phase->C) SubLNode(phase->longcon(0), phase->transform(q)); q = new SubLNode(phase->longcon(0), phase->transform(q));
} }
} else if ( !Matcher::use_asm_for_ldiv_by_con(d) ) { // Use hardware DIV instruction when } else if ( !Matcher::use_asm_for_ldiv_by_con(d) ) { // Use hardware DIV instruction when
// it is faster than code generated below. // it is faster than code generated below.
@ -427,17 +427,17 @@ static Node *transform_long_divide( PhaseGVN *phase, Node *dividend, jlong divis
// The magic multiplier is too large for a 64 bit constant. We've adjusted // The magic multiplier is too large for a 64 bit constant. We've adjusted
// it down by 2^64, but have to add 1 dividend back in after the multiplication. // it down by 2^64, but have to add 1 dividend back in after the multiplication.
// This handles the "overflow" case described by Granlund and Montgomery. // This handles the "overflow" case described by Granlund and Montgomery.
mul_hi = phase->transform(new (phase->C) AddLNode(dividend, mul_hi)); mul_hi = phase->transform(new AddLNode(dividend, mul_hi));
} }
// Shift over the (adjusted) mulhi // Shift over the (adjusted) mulhi
if (shift_const != 0) { if (shift_const != 0) {
mul_hi = phase->transform(new (phase->C) RShiftLNode(mul_hi, phase->intcon(shift_const))); mul_hi = phase->transform(new RShiftLNode(mul_hi, phase->intcon(shift_const)));
} }
// Get a 0 or -1 from the sign of the dividend. // Get a 0 or -1 from the sign of the dividend.
Node *addend0 = mul_hi; Node *addend0 = mul_hi;
Node *addend1 = phase->transform(new (phase->C) RShiftLNode(dividend, phase->intcon(N-1))); Node *addend1 = phase->transform(new RShiftLNode(dividend, phase->intcon(N-1)));
// If the divisor is negative, swap the order of the input addends; // If the divisor is negative, swap the order of the input addends;
// this has the effect of negating the quotient. // this has the effect of negating the quotient.
@ -447,7 +447,7 @@ static Node *transform_long_divide( PhaseGVN *phase, Node *dividend, jlong divis
// Adjust the final quotient by subtracting -1 (adding 1) // Adjust the final quotient by subtracting -1 (adding 1)
// from the mul_hi. // from the mul_hi.
q = new (phase->C) SubLNode(addend0, addend1); q = new SubLNode(addend0, addend1);
} }
} }
@ -737,7 +737,7 @@ Node *DivFNode::Ideal(PhaseGVN *phase, bool can_reshape) {
assert( frexp((double)reciprocal, &exp) == 0.5, "reciprocal should be power of 2" ); assert( frexp((double)reciprocal, &exp) == 0.5, "reciprocal should be power of 2" );
// return multiplication by the reciprocal // return multiplication by the reciprocal
return (new (phase->C) MulFNode(in(1), phase->makecon(TypeF::make(reciprocal)))); return (new MulFNode(in(1), phase->makecon(TypeF::make(reciprocal))));
} }
//============================================================================= //=============================================================================
@ -831,7 +831,7 @@ Node *DivDNode::Ideal(PhaseGVN *phase, bool can_reshape) {
assert( frexp(reciprocal, &exp) == 0.5, "reciprocal should be power of 2" ); assert( frexp(reciprocal, &exp) == 0.5, "reciprocal should be power of 2" );
// return multiplication by the reciprocal // return multiplication by the reciprocal
return (new (phase->C) MulDNode(in(1), phase->makecon(TypeD::make(reciprocal)))); return (new MulDNode(in(1), phase->makecon(TypeD::make(reciprocal))));
} }
//============================================================================= //=============================================================================
@ -858,7 +858,7 @@ Node *ModINode::Ideal(PhaseGVN *phase, bool can_reshape) {
if( !ti->is_con() ) return NULL; if( !ti->is_con() ) return NULL;
jint con = ti->get_con(); jint con = ti->get_con();
Node *hook = new (phase->C) Node(1); Node *hook = new Node(1);
// First, special check for modulo 2^k-1 // First, special check for modulo 2^k-1
if( con >= 0 && con < max_jint && is_power_of_2(con+1) ) { if( con >= 0 && con < max_jint && is_power_of_2(con+1) ) {
@ -878,24 +878,24 @@ Node *ModINode::Ideal(PhaseGVN *phase, bool can_reshape) {
hook->init_req(0, x); // Add a use to x to prevent him from dying hook->init_req(0, x); // Add a use to x to prevent him from dying
// Generate code to reduce X rapidly to nearly 2^k-1. // Generate code to reduce X rapidly to nearly 2^k-1.
for( int i = 0; i < trip_count; i++ ) { for( int i = 0; i < trip_count; i++ ) {
Node *xl = phase->transform( new (phase->C) AndINode(x,divisor) ); Node *xl = phase->transform( new AndINode(x,divisor) );
Node *xh = phase->transform( new (phase->C) RShiftINode(x,phase->intcon(k)) ); // Must be signed Node *xh = phase->transform( new RShiftINode(x,phase->intcon(k)) ); // Must be signed
x = phase->transform( new (phase->C) AddINode(xh,xl) ); x = phase->transform( new AddINode(xh,xl) );
hook->set_req(0, x); hook->set_req(0, x);
} }
// Generate sign-fixup code. Was original value positive? // Generate sign-fixup code. Was original value positive?
// int hack_res = (i >= 0) ? divisor : 1; // int hack_res = (i >= 0) ? divisor : 1;
Node *cmp1 = phase->transform( new (phase->C) CmpINode( in(1), phase->intcon(0) ) ); Node *cmp1 = phase->transform( new CmpINode( in(1), phase->intcon(0) ) );
Node *bol1 = phase->transform( new (phase->C) BoolNode( cmp1, BoolTest::ge ) ); Node *bol1 = phase->transform( new BoolNode( cmp1, BoolTest::ge ) );
Node *cmov1= phase->transform( new (phase->C) CMoveINode(bol1, phase->intcon(1), divisor, TypeInt::POS) ); Node *cmov1= phase->transform( new CMoveINode(bol1, phase->intcon(1), divisor, TypeInt::POS) );
// if( x >= hack_res ) x -= divisor; // if( x >= hack_res ) x -= divisor;
Node *sub = phase->transform( new (phase->C) SubINode( x, divisor ) ); Node *sub = phase->transform( new SubINode( x, divisor ) );
Node *cmp2 = phase->transform( new (phase->C) CmpINode( x, cmov1 ) ); Node *cmp2 = phase->transform( new CmpINode( x, cmov1 ) );
Node *bol2 = phase->transform( new (phase->C) BoolNode( cmp2, BoolTest::ge ) ); Node *bol2 = phase->transform( new BoolNode( cmp2, BoolTest::ge ) );
// Convention is to not transform the return value of an Ideal // Convention is to not transform the return value of an Ideal
// since Ideal is expected to return a modified 'this' or a new node. // since Ideal is expected to return a modified 'this' or a new node.
Node *cmov2= new (phase->C) CMoveINode(bol2, x, sub, TypeInt::INT); Node *cmov2= new CMoveINode(bol2, x, sub, TypeInt::INT);
// cmov2 is now the mod // cmov2 is now the mod
// Now remove the bogus extra edges used to keep things alive // Now remove the bogus extra edges used to keep things alive
@ -918,7 +918,7 @@ Node *ModINode::Ideal(PhaseGVN *phase, bool can_reshape) {
jint pos_con = (con >= 0) ? con : -con; jint pos_con = (con >= 0) ? con : -con;
// integer Mod 1 is always 0 // integer Mod 1 is always 0
if( pos_con == 1 ) return new (phase->C) ConINode(TypeInt::ZERO); if( pos_con == 1 ) return new ConINode(TypeInt::ZERO);
int log2_con = -1; int log2_con = -1;
@ -931,7 +931,7 @@ Node *ModINode::Ideal(PhaseGVN *phase, bool can_reshape) {
// See if this can be masked, if the dividend is non-negative // See if this can be masked, if the dividend is non-negative
if( dti && dti->_lo >= 0 ) if( dti && dti->_lo >= 0 )
return ( new (phase->C) AndINode( in(1), phase->intcon( pos_con-1 ) ) ); return ( new AndINode( in(1), phase->intcon( pos_con-1 ) ) );
} }
// Save in(1) so that it cannot be changed or deleted // Save in(1) so that it cannot be changed or deleted
@ -946,12 +946,12 @@ Node *ModINode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node *mult = NULL; Node *mult = NULL;
if( log2_con >= 0 ) if( log2_con >= 0 )
mult = phase->transform( new (phase->C) LShiftINode( divide, phase->intcon( log2_con ) ) ); mult = phase->transform( new LShiftINode( divide, phase->intcon( log2_con ) ) );
else else
mult = phase->transform( new (phase->C) MulINode( divide, phase->intcon( pos_con ) ) ); mult = phase->transform( new MulINode( divide, phase->intcon( pos_con ) ) );
// Finally, subtract the multiplied divided value from the original // Finally, subtract the multiplied divided value from the original
result = new (phase->C) SubINode( in(1), mult ); result = new SubINode( in(1), mult );
} }
// Now remove the bogus extra edges used to keep things alive // Now remove the bogus extra edges used to keep things alive
@ -1029,7 +1029,7 @@ Node *ModLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
if( !tl->is_con() ) return NULL; if( !tl->is_con() ) return NULL;
jlong con = tl->get_con(); jlong con = tl->get_con();
Node *hook = new (phase->C) Node(1); Node *hook = new Node(1);
// Expand mod // Expand mod
if( con >= 0 && con < max_jlong && is_power_of_2_long(con+1) ) { if( con >= 0 && con < max_jlong && is_power_of_2_long(con+1) ) {
@ -1051,24 +1051,24 @@ Node *ModLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
hook->init_req(0, x); // Add a use to x to prevent him from dying hook->init_req(0, x); // Add a use to x to prevent him from dying
// Generate code to reduce X rapidly to nearly 2^k-1. // Generate code to reduce X rapidly to nearly 2^k-1.
for( int i = 0; i < trip_count; i++ ) { for( int i = 0; i < trip_count; i++ ) {
Node *xl = phase->transform( new (phase->C) AndLNode(x,divisor) ); Node *xl = phase->transform( new AndLNode(x,divisor) );
Node *xh = phase->transform( new (phase->C) RShiftLNode(x,phase->intcon(k)) ); // Must be signed Node *xh = phase->transform( new RShiftLNode(x,phase->intcon(k)) ); // Must be signed
x = phase->transform( new (phase->C) AddLNode(xh,xl) ); x = phase->transform( new AddLNode(xh,xl) );
hook->set_req(0, x); // Add a use to x to prevent him from dying hook->set_req(0, x); // Add a use to x to prevent him from dying
} }
// Generate sign-fixup code. Was original value positive? // Generate sign-fixup code. Was original value positive?
// long hack_res = (i >= 0) ? divisor : CONST64(1); // long hack_res = (i >= 0) ? divisor : CONST64(1);
Node *cmp1 = phase->transform( new (phase->C) CmpLNode( in(1), phase->longcon(0) ) ); Node *cmp1 = phase->transform( new CmpLNode( in(1), phase->longcon(0) ) );
Node *bol1 = phase->transform( new (phase->C) BoolNode( cmp1, BoolTest::ge ) ); Node *bol1 = phase->transform( new BoolNode( cmp1, BoolTest::ge ) );
Node *cmov1= phase->transform( new (phase->C) CMoveLNode(bol1, phase->longcon(1), divisor, TypeLong::LONG) ); Node *cmov1= phase->transform( new CMoveLNode(bol1, phase->longcon(1), divisor, TypeLong::LONG) );
// if( x >= hack_res ) x -= divisor; // if( x >= hack_res ) x -= divisor;
Node *sub = phase->transform( new (phase->C) SubLNode( x, divisor ) ); Node *sub = phase->transform( new SubLNode( x, divisor ) );
Node *cmp2 = phase->transform( new (phase->C) CmpLNode( x, cmov1 ) ); Node *cmp2 = phase->transform( new CmpLNode( x, cmov1 ) );
Node *bol2 = phase->transform( new (phase->C) BoolNode( cmp2, BoolTest::ge ) ); Node *bol2 = phase->transform( new BoolNode( cmp2, BoolTest::ge ) );
// Convention is to not transform the return value of an Ideal // Convention is to not transform the return value of an Ideal
// since Ideal is expected to return a modified 'this' or a new node. // since Ideal is expected to return a modified 'this' or a new node.
Node *cmov2= new (phase->C) CMoveLNode(bol2, x, sub, TypeLong::LONG); Node *cmov2= new CMoveLNode(bol2, x, sub, TypeLong::LONG);
// cmov2 is now the mod // cmov2 is now the mod
// Now remove the bogus extra edges used to keep things alive // Now remove the bogus extra edges used to keep things alive
@ -1091,7 +1091,7 @@ Node *ModLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
jlong pos_con = (con >= 0) ? con : -con; jlong pos_con = (con >= 0) ? con : -con;
// integer Mod 1 is always 0 // integer Mod 1 is always 0
if( pos_con == 1 ) return new (phase->C) ConLNode(TypeLong::ZERO); if( pos_con == 1 ) return new ConLNode(TypeLong::ZERO);
int log2_con = -1; int log2_con = -1;
@ -1104,7 +1104,7 @@ Node *ModLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// See if this can be masked, if the dividend is non-negative // See if this can be masked, if the dividend is non-negative
if( dtl && dtl->_lo >= 0 ) if( dtl && dtl->_lo >= 0 )
return ( new (phase->C) AndLNode( in(1), phase->longcon( pos_con-1 ) ) ); return ( new AndLNode( in(1), phase->longcon( pos_con-1 ) ) );
} }
// Save in(1) so that it cannot be changed or deleted // Save in(1) so that it cannot be changed or deleted
@ -1119,12 +1119,12 @@ Node *ModLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node *mult = NULL; Node *mult = NULL;
if( log2_con >= 0 ) if( log2_con >= 0 )
mult = phase->transform( new (phase->C) LShiftLNode( divide, phase->intcon( log2_con ) ) ); mult = phase->transform( new LShiftLNode( divide, phase->intcon( log2_con ) ) );
else else
mult = phase->transform( new (phase->C) MulLNode( divide, phase->longcon( pos_con ) ) ); mult = phase->transform( new MulLNode( divide, phase->longcon( pos_con ) ) );
// Finally, subtract the multiplied divided value from the original // Finally, subtract the multiplied divided value from the original
result = new (phase->C) SubLNode( in(1), mult ); result = new SubLNode( in(1), mult );
} }
// Now remove the bogus extra edges used to keep things alive // Now remove the bogus extra edges used to keep things alive
@ -1279,9 +1279,9 @@ DivModINode* DivModINode::make(Compile* C, Node* div_or_mod) {
assert(n->Opcode() == Op_DivI || n->Opcode() == Op_ModI, assert(n->Opcode() == Op_DivI || n->Opcode() == Op_ModI,
"only div or mod input pattern accepted"); "only div or mod input pattern accepted");
DivModINode* divmod = new (C) DivModINode(n->in(0), n->in(1), n->in(2)); DivModINode* divmod = new DivModINode(n->in(0), n->in(1), n->in(2));
Node* dproj = new (C) ProjNode(divmod, DivModNode::div_proj_num); Node* dproj = new ProjNode(divmod, DivModNode::div_proj_num);
Node* mproj = new (C) ProjNode(divmod, DivModNode::mod_proj_num); Node* mproj = new ProjNode(divmod, DivModNode::mod_proj_num);
return divmod; return divmod;
} }
@ -1291,9 +1291,9 @@ DivModLNode* DivModLNode::make(Compile* C, Node* div_or_mod) {
assert(n->Opcode() == Op_DivL || n->Opcode() == Op_ModL, assert(n->Opcode() == Op_DivL || n->Opcode() == Op_ModL,
"only div or mod input pattern accepted"); "only div or mod input pattern accepted");
DivModLNode* divmod = new (C) DivModLNode(n->in(0), n->in(1), n->in(2)); DivModLNode* divmod = new DivModLNode(n->in(0), n->in(1), n->in(2));
Node* dproj = new (C) ProjNode(divmod, DivModNode::div_proj_num); Node* dproj = new ProjNode(divmod, DivModNode::div_proj_num);
Node* mproj = new (C) ProjNode(divmod, DivModNode::mod_proj_num); Node* mproj = new ProjNode(divmod, DivModNode::mod_proj_num);
return divmod; return divmod;
} }
@ -1308,7 +1308,7 @@ Node *DivModINode::match( const ProjNode *proj, const Matcher *match ) {
assert(proj->_con == mod_proj_num, "must be div or mod projection"); assert(proj->_con == mod_proj_num, "must be div or mod projection");
rm = match->modI_proj_mask(); rm = match->modI_proj_mask();
} }
return new (match->C)MachProjNode(this, proj->_con, rm, ideal_reg); return new MachProjNode(this, proj->_con, rm, ideal_reg);
} }
@ -1323,5 +1323,5 @@ Node *DivModLNode::match( const ProjNode *proj, const Matcher *match ) {
assert(proj->_con == mod_proj_num, "must be div or mod projection"); assert(proj->_con == mod_proj_num, "must be div or mod projection");
rm = match->modL_proj_mask(); rm = match->modL_proj_mask();
} }
return new (match->C)MachProjNode(this, proj->_con, rm, ideal_reg); return new MachProjNode(this, proj->_con, rm, ideal_reg);
} }

14
hotspot/src/share/vm/opto/doCall.cpp
View file

@ -596,7 +596,7 @@ void Parse::do_call() {
const Type* sig_type = TypeOopPtr::make_from_klass(ctype->as_klass()); const Type* sig_type = TypeOopPtr::make_from_klass(ctype->as_klass());
if (arg_type != NULL && !arg_type->higher_equal(sig_type)) { if (arg_type != NULL && !arg_type->higher_equal(sig_type)) {
Node* retnode = pop(); Node* retnode = pop();
Node* cast_obj = _gvn.transform(new (C) CheckCastPPNode(control(), retnode, sig_type)); Node* cast_obj = _gvn.transform(new CheckCastPPNode(control(), retnode, sig_type));
push(cast_obj); push(cast_obj);
} }
} }
@ -689,7 +689,7 @@ void Parse::catch_call_exceptions(ciExceptionHandlerStream& handlers) {
} }
int len = bcis->length(); int len = bcis->length();
CatchNode *cn = new (C) CatchNode(control(), i_o, len+1); CatchNode *cn = new CatchNode(control(), i_o, len+1);
Node *catch_ = _gvn.transform(cn); Node *catch_ = _gvn.transform(cn);
// now branch with the exception state to each of the (potential) // now branch with the exception state to each of the (potential)
@ -700,14 +700,14 @@ void Parse::catch_call_exceptions(ciExceptionHandlerStream& handlers) {
// Locals are just copied from before the call. // Locals are just copied from before the call.
// Get control from the CatchNode. // Get control from the CatchNode.
int handler_bci = bcis->at(i); int handler_bci = bcis->at(i);
Node* ctrl = _gvn.transform( new (C) CatchProjNode(catch_, i+1,handler_bci)); Node* ctrl = _gvn.transform( new CatchProjNode(catch_, i+1,handler_bci));
// This handler cannot happen? // This handler cannot happen?
if (ctrl == top()) continue; if (ctrl == top()) continue;
set_control(ctrl); set_control(ctrl);
// Create exception oop // Create exception oop
const TypeInstPtr* extype = extypes->at(i)->is_instptr(); const TypeInstPtr* extype = extypes->at(i)->is_instptr();
Node *ex_oop = _gvn.transform(new (C) CreateExNode(extypes->at(i), ctrl, i_o)); Node *ex_oop = _gvn.transform(new CreateExNode(extypes->at(i), ctrl, i_o));
// Handle unloaded exception classes. // Handle unloaded exception classes.
if (saw_unloaded->contains(handler_bci)) { if (saw_unloaded->contains(handler_bci)) {
@ -746,7 +746,7 @@ void Parse::catch_call_exceptions(ciExceptionHandlerStream& handlers) {
// The first CatchProj is for the normal return. // The first CatchProj is for the normal return.
// (Note: If this is a call to rethrow_Java, this node goes dead.) // (Note: If this is a call to rethrow_Java, this node goes dead.)
set_control(_gvn.transform( new (C) CatchProjNode(catch_, CatchProjNode::fall_through_index, CatchProjNode::no_handler_bci))); set_control(_gvn.transform( new CatchProjNode(catch_, CatchProjNode::fall_through_index, CatchProjNode::no_handler_bci)));
} }
@ -797,7 +797,7 @@ void Parse::catch_inline_exceptions(SafePointNode* ex_map) {
// I'm loading the class from, I can replace the LoadKlass with the // I'm loading the class from, I can replace the LoadKlass with the
// klass constant for the exception oop. // klass constant for the exception oop.
if( ex_node->is_Phi() ) { if( ex_node->is_Phi() ) {
ex_klass_node = new (C) PhiNode( ex_node->in(0), TypeKlassPtr::OBJECT ); ex_klass_node = new PhiNode( ex_node->in(0), TypeKlassPtr::OBJECT );
for( uint i = 1; i < ex_node->req(); i++ ) { for( uint i = 1; i < ex_node->req(); i++ ) {
Node* p = basic_plus_adr( ex_node->in(i), ex_node->in(i), oopDesc::klass_offset_in_bytes() ); Node* p = basic_plus_adr( ex_node->in(i), ex_node->in(i), oopDesc::klass_offset_in_bytes() );
Node* k = _gvn.transform( LoadKlassNode::make(_gvn, immutable_memory(), p, TypeInstPtr::KLASS, TypeKlassPtr::OBJECT) ); Node* k = _gvn.transform( LoadKlassNode::make(_gvn, immutable_memory(), p, TypeInstPtr::KLASS, TypeKlassPtr::OBJECT) );
@ -863,7 +863,7 @@ void Parse::catch_inline_exceptions(SafePointNode* ex_map) {
PreserveJVMState pjvms(this); PreserveJVMState pjvms(this);
const TypeInstPtr* tinst = TypeOopPtr::make_from_klass_unique(klass)->cast_to_ptr_type(TypePtr::NotNull)->is_instptr(); const TypeInstPtr* tinst = TypeOopPtr::make_from_klass_unique(klass)->cast_to_ptr_type(TypePtr::NotNull)->is_instptr();
assert(klass->has_subklass() || tinst->klass_is_exact(), "lost exactness"); assert(klass->has_subklass() || tinst->klass_is_exact(), "lost exactness");
Node* ex_oop = _gvn.transform(new (C) CheckCastPPNode(control(), ex_node, tinst)); Node* ex_oop = _gvn.transform(new CheckCastPPNode(control(), ex_node, tinst));
push_ex_oop(ex_oop); // Push exception oop for handler push_ex_oop(ex_oop); // Push exception oop for handler
#ifndef PRODUCT #ifndef PRODUCT
if (PrintOpto && WizardMode) { if (PrintOpto && WizardMode) {

75
hotspot/src/share/vm/opto/generateOptoStub.cpp
View file

@ -50,7 +50,7 @@ void GraphKit::gen_stub(address C_function,
const TypeTuple *jrange = C->tf()->range(); const TypeTuple *jrange = C->tf()->range();
// The procedure start // The procedure start
StartNode* start = new (C) StartNode(root(), jdomain); StartNode* start = new StartNode(root(), jdomain);
_gvn.set_type_bottom(start); _gvn.set_type_bottom(start);
// Make a map, with JVM state // Make a map, with JVM state
@ -64,7 +64,7 @@ void GraphKit::gen_stub(address C_function,
jvms->set_scloff(max_map); jvms->set_scloff(max_map);
jvms->set_endoff(max_map); jvms->set_endoff(max_map);
{ {
SafePointNode *map = new (C) SafePointNode( max_map, jvms ); SafePointNode *map = new SafePointNode( max_map, jvms );
jvms->set_map(map); jvms->set_map(map);
set_jvms(jvms); set_jvms(jvms);
assert(map == this->map(), "kit.map is set"); assert(map == this->map(), "kit.map is set");
@ -73,7 +73,7 @@ void GraphKit::gen_stub(address C_function,
// Make up the parameters // Make up the parameters
uint i; uint i;
for( i = 0; i < parm_cnt; i++ ) for( i = 0; i < parm_cnt; i++ )
map()->init_req(i, _gvn.transform(new (C) ParmNode(start, i))); map()->init_req(i, _gvn.transform(new ParmNode(start, i)));
for( ; i<map()->req(); i++ ) for( ; i<map()->req(); i++ )
map()->init_req(i, top()); // For nicer debugging map()->init_req(i, top()); // For nicer debugging
@ -81,7 +81,7 @@ void GraphKit::gen_stub(address C_function,
set_all_memory(map()->memory()); set_all_memory(map()->memory());
// Get base of thread-local storage area // Get base of thread-local storage area
Node* thread = _gvn.transform( new (C) ThreadLocalNode() ); Node* thread = _gvn.transform( new ThreadLocalNode() );
const int NoAlias = Compile::AliasIdxBot; const int NoAlias = Compile::AliasIdxBot;
@ -166,8 +166,7 @@ void GraphKit::gen_stub(address C_function,
//----------------------------- //-----------------------------
// Make the call node // Make the call node
CallRuntimeNode *call = new (C) CallRuntimeNode *call = new CallRuntimeNode(c_sig, C_function, name, TypePtr::BOTTOM);
CallRuntimeNode(c_sig, C_function, name, TypePtr::BOTTOM);
//----------------------------- //-----------------------------
// Fix-up the debug info for the call // Fix-up the debug info for the call
@ -184,7 +183,7 @@ void GraphKit::gen_stub(address C_function,
for (; i < parm_cnt; i++) { // Regular input arguments for (; i < parm_cnt; i++) { // Regular input arguments
// Convert ints to longs if required. // Convert ints to longs if required.
if (CCallingConventionRequiresIntsAsLongs && jdomain->field_at(i)->isa_int()) { if (CCallingConventionRequiresIntsAsLongs && jdomain->field_at(i)->isa_int()) {
Node* int_as_long = _gvn.transform(new (C) ConvI2LNode(map()->in(i))); Node* int_as_long = _gvn.transform(new ConvI2LNode(map()->in(i)));
call->init_req(cnt++, int_as_long); // long call->init_req(cnt++, int_as_long); // long
call->init_req(cnt++, top()); // half call->init_req(cnt++, top()); // half
} else { } else {
@ -200,23 +199,23 @@ void GraphKit::gen_stub(address C_function,
//----------------------------- //-----------------------------
// Now set up the return results // Now set up the return results
set_control( _gvn.transform( new (C) ProjNode(call,TypeFunc::Control)) ); set_control( _gvn.transform( new ProjNode(call,TypeFunc::Control)) );
set_i_o( _gvn.transform( new (C) ProjNode(call,TypeFunc::I_O )) ); set_i_o( _gvn.transform( new ProjNode(call,TypeFunc::I_O )) );
set_all_memory_call(call); set_all_memory_call(call);
if (range->cnt() > TypeFunc::Parms) { if (range->cnt() > TypeFunc::Parms) {
Node* retnode = _gvn.transform( new (C) ProjNode(call,TypeFunc::Parms) ); Node* retnode = _gvn.transform( new ProjNode(call,TypeFunc::Parms) );
// C-land is allowed to return sub-word values. Convert to integer type. // C-land is allowed to return sub-word values. Convert to integer type.
assert( retval != Type::TOP, "" ); assert( retval != Type::TOP, "" );
if (retval == TypeInt::BOOL) { if (retval == TypeInt::BOOL) {
retnode = _gvn.transform( new (C) AndINode(retnode, intcon(0xFF)) ); retnode = _gvn.transform( new AndINode(retnode, intcon(0xFF)) );
} else if (retval == TypeInt::CHAR) { } else if (retval == TypeInt::CHAR) {
retnode = _gvn.transform( new (C) AndINode(retnode, intcon(0xFFFF)) ); retnode = _gvn.transform( new AndINode(retnode, intcon(0xFFFF)) );
} else if (retval == TypeInt::BYTE) { } else if (retval == TypeInt::BYTE) {
retnode = _gvn.transform( new (C) LShiftINode(retnode, intcon(24)) ); retnode = _gvn.transform( new LShiftINode(retnode, intcon(24)) );
retnode = _gvn.transform( new (C) RShiftINode(retnode, intcon(24)) ); retnode = _gvn.transform( new RShiftINode(retnode, intcon(24)) );
} else if (retval == TypeInt::SHORT) { } else if (retval == TypeInt::SHORT) {
retnode = _gvn.transform( new (C) LShiftINode(retnode, intcon(16)) ); retnode = _gvn.transform( new LShiftINode(retnode, intcon(16)) );
retnode = _gvn.transform( new (C) RShiftINode(retnode, intcon(16)) ); retnode = _gvn.transform( new RShiftINode(retnode, intcon(16)) );
} }
map()->set_req( TypeFunc::Parms, retnode ); map()->set_req( TypeFunc::Parms, retnode );
} }
@ -253,21 +252,21 @@ void GraphKit::gen_stub(address C_function,
Node* exit_memory = reset_memory(); Node* exit_memory = reset_memory();
Node* cmp = _gvn.transform( new (C) CmpPNode(pending, null()) ); Node* cmp = _gvn.transform( new CmpPNode(pending, null()) );
Node* bo = _gvn.transform( new (C) BoolNode(cmp, BoolTest::ne) ); Node* bo = _gvn.transform( new BoolNode(cmp, BoolTest::ne) );
IfNode *iff = create_and_map_if(control(), bo, PROB_MIN, COUNT_UNKNOWN); IfNode *iff = create_and_map_if(control(), bo, PROB_MIN, COUNT_UNKNOWN);
Node* if_null = _gvn.transform( new (C) IfFalseNode(iff) ); Node* if_null = _gvn.transform( new IfFalseNode(iff) );
Node* if_not_null = _gvn.transform( new (C) IfTrueNode(iff) ); Node* if_not_null = _gvn.transform( new IfTrueNode(iff) );
assert (StubRoutines::forward_exception_entry() != NULL, "must be generated before"); assert (StubRoutines::forward_exception_entry() != NULL, "must be generated before");
Node *exc_target = makecon(TypeRawPtr::make( StubRoutines::forward_exception_entry() )); Node *exc_target = makecon(TypeRawPtr::make( StubRoutines::forward_exception_entry() ));
Node *to_exc = new (C) TailCallNode(if_not_null, Node *to_exc = new TailCallNode(if_not_null,
i_o(), i_o(),
exit_memory, exit_memory,
frameptr(), frameptr(),
returnadr(), returnadr(),
exc_target, null()); exc_target, null());
root()->add_req(_gvn.transform(to_exc)); // bind to root to keep live root()->add_req(_gvn.transform(to_exc)); // bind to root to keep live
C->init_start(start); C->init_start(start);
@ -277,27 +276,27 @@ void GraphKit::gen_stub(address C_function,
switch( is_fancy_jump ) { switch( is_fancy_jump ) {
case 0: // Make a return instruction case 0: // Make a return instruction
// Return to caller, free any space for return address // Return to caller, free any space for return address
ret = new (C) ReturnNode(TypeFunc::Parms, if_null, ret = new ReturnNode(TypeFunc::Parms, if_null,
i_o(), i_o(),
exit_memory, exit_memory,
frameptr(), frameptr(),
returnadr()); returnadr());
if (C->tf()->range()->cnt() > TypeFunc::Parms) if (C->tf()->range()->cnt() > TypeFunc::Parms)
ret->add_req( map()->in(TypeFunc::Parms) ); ret->add_req( map()->in(TypeFunc::Parms) );
break; break;
case 1: // This is a fancy tail-call jump. Jump to computed address. case 1: // This is a fancy tail-call jump. Jump to computed address.
// Jump to new callee; leave old return address alone. // Jump to new callee; leave old return address alone.
ret = new (C) TailCallNode(if_null, ret = new TailCallNode(if_null,
i_o(), i_o(),
exit_memory, exit_memory,
frameptr(), frameptr(),
returnadr(), returnadr(),
target, map()->in(TypeFunc::Parms)); target, map()->in(TypeFunc::Parms));
break; break;
case 2: // Pop return address & jump case 2: // Pop return address & jump
// Throw away old return address; jump to new computed address // 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"); //assert(C_function == CAST_FROM_FN_PTR(address, OptoRuntime::rethrow_C), "fancy_jump==2 only for rethrow");
ret = new (C) TailJumpNode(if_null, ret = new TailJumpNode(if_null,
i_o(), i_o(),
exit_memory, exit_memory,
frameptr(), frameptr(),

254
hotspot/src/share/vm/opto/graphKit.cpp
View file

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

42
hotspot/src/share/vm/opto/graphKit.hpp
View file

@ -309,31 +309,31 @@ class GraphKit : public Phase {
// Some convenient shortcuts for common nodes // Some convenient shortcuts for common nodes
Node* IfTrue(IfNode* iff) { return _gvn.transform(new (C) IfTrueNode(iff)); } Node* IfTrue(IfNode* iff) { return _gvn.transform(new IfTrueNode(iff)); }
Node* IfFalse(IfNode* iff) { return _gvn.transform(new (C) IfFalseNode(iff)); } Node* IfFalse(IfNode* iff) { return _gvn.transform(new IfFalseNode(iff)); }
Node* AddI(Node* l, Node* r) { return _gvn.transform(new (C) AddINode(l, r)); } Node* AddI(Node* l, Node* r) { return _gvn.transform(new AddINode(l, r)); }
Node* SubI(Node* l, Node* r) { return _gvn.transform(new (C) SubINode(l, r)); } Node* SubI(Node* l, Node* r) { return _gvn.transform(new SubINode(l, r)); }
Node* MulI(Node* l, Node* r) { return _gvn.transform(new (C) MulINode(l, r)); } Node* MulI(Node* l, Node* r) { return _gvn.transform(new MulINode(l, r)); }
Node* DivI(Node* ctl, Node* l, Node* r) { return _gvn.transform(new (C) DivINode(ctl, l, r)); } Node* DivI(Node* ctl, Node* l, Node* r) { return _gvn.transform(new DivINode(ctl, l, r)); }
Node* AndI(Node* l, Node* r) { return _gvn.transform(new (C) AndINode(l, r)); } Node* AndI(Node* l, Node* r) { return _gvn.transform(new AndINode(l, r)); }
Node* OrI(Node* l, Node* r) { return _gvn.transform(new (C) OrINode(l, r)); } Node* OrI(Node* l, Node* r) { return _gvn.transform(new OrINode(l, r)); }
Node* XorI(Node* l, Node* r) { return _gvn.transform(new (C) XorINode(l, r)); } Node* XorI(Node* l, Node* r) { return _gvn.transform(new XorINode(l, r)); }
Node* MaxI(Node* l, Node* r) { return _gvn.transform(new (C) MaxINode(l, r)); } Node* MaxI(Node* l, Node* r) { return _gvn.transform(new MaxINode(l, r)); }
Node* MinI(Node* l, Node* r) { return _gvn.transform(new (C) MinINode(l, r)); } Node* MinI(Node* l, Node* r) { return _gvn.transform(new MinINode(l, r)); }
Node* LShiftI(Node* l, Node* r) { return _gvn.transform(new (C) LShiftINode(l, r)); } Node* LShiftI(Node* l, Node* r) { return _gvn.transform(new LShiftINode(l, r)); }
Node* RShiftI(Node* l, Node* r) { return _gvn.transform(new (C) RShiftINode(l, r)); } Node* RShiftI(Node* l, Node* r) { return _gvn.transform(new RShiftINode(l, r)); }
Node* URShiftI(Node* l, Node* r) { return _gvn.transform(new (C) URShiftINode(l, r)); } Node* URShiftI(Node* l, Node* r) { return _gvn.transform(new URShiftINode(l, r)); }
Node* CmpI(Node* l, Node* r) { return _gvn.transform(new (C) CmpINode(l, r)); } Node* CmpI(Node* l, Node* r) { return _gvn.transform(new CmpINode(l, r)); }
Node* CmpL(Node* l, Node* r) { return _gvn.transform(new (C) CmpLNode(l, r)); } Node* CmpL(Node* l, Node* r) { return _gvn.transform(new CmpLNode(l, r)); }
Node* CmpP(Node* l, Node* r) { return _gvn.transform(new (C) CmpPNode(l, r)); } Node* CmpP(Node* l, Node* r) { return _gvn.transform(new CmpPNode(l, r)); }
Node* Bool(Node* cmp, BoolTest::mask relop) { return _gvn.transform(new (C) BoolNode(cmp, relop)); } Node* Bool(Node* cmp, BoolTest::mask relop) { return _gvn.transform(new BoolNode(cmp, relop)); }
Node* AddP(Node* b, Node* a, Node* o) { return _gvn.transform(new (C) AddPNode(b, a, o)); } Node* AddP(Node* b, Node* a, Node* o) { return _gvn.transform(new AddPNode(b, a, o)); }
// Convert between int and long, and size_t. // Convert between int and long, and size_t.
// (See macros ConvI2X, etc., in type.hpp for ConvI2X, etc.) // (See macros ConvI2X, etc., in type.hpp for ConvI2X, etc.)
@ -867,7 +867,7 @@ class GraphKit : public Phase {
// Handy for making control flow // Handy for making control flow
IfNode* create_and_map_if(Node* ctrl, Node* tst, float prob, float cnt) { IfNode* create_and_map_if(Node* ctrl, Node* tst, float prob, float cnt) {
IfNode* iff = new (C) IfNode(ctrl, tst, prob, cnt);// New IfNode's IfNode* iff = new IfNode(ctrl, tst, prob, cnt);// New IfNode's
_gvn.set_type(iff, iff->Value(&_gvn)); // Value may be known at parse-time _gvn.set_type(iff, iff->Value(&_gvn)); // Value may be known at parse-time
// Place 'if' on worklist if it will be in graph // Place 'if' on worklist if it will be in graph
if (!tst->is_Con()) record_for_igvn(iff); // Range-check and Null-check removal is later if (!tst->is_Con()) record_for_igvn(iff); // Range-check and Null-check removal is later
@ -875,7 +875,7 @@ class GraphKit : public Phase {
} }
IfNode* create_and_xform_if(Node* ctrl, Node* tst, float prob, float cnt) { IfNode* create_and_xform_if(Node* ctrl, Node* tst, float prob, float cnt) {
IfNode* iff = new (C) IfNode(ctrl, tst, prob, cnt);// New IfNode's IfNode* iff = new IfNode(ctrl, tst, prob, cnt);// New IfNode's
_gvn.transform(iff); // Value may be known at parse-time _gvn.transform(iff); // Value may be known at parse-time
// Place 'if' on worklist if it will be in graph // Place 'if' on worklist if it will be in graph
if (!tst->is_Con()) record_for_igvn(iff); // Range-check and Null-check removal is later if (!tst->is_Con()) record_for_igvn(iff); // Range-check and Null-check removal is later

20
hotspot/src/share/vm/opto/idealKit.cpp
View file

@ -86,7 +86,7 @@ void IdealKit::if_then(Node* left, BoolTest::mask relop,
} }
// Delay gvn.tranform on if-nodes until construction is finished // Delay gvn.tranform on if-nodes until construction is finished
// to prevent a constant bool input from discarding a control output. // to prevent a constant bool input from discarding a control output.
IfNode* iff = delay_transform(new (C) IfNode(ctrl(), bol, prob, cnt))->as_If(); IfNode* iff = delay_transform(new IfNode(ctrl(), bol, prob, cnt))->as_If();
Node* then = IfTrue(iff); Node* then = IfTrue(iff);
Node* elsen = IfFalse(iff); Node* elsen = IfFalse(iff);
Node* else_cvstate = copy_cvstate(); Node* else_cvstate = copy_cvstate();
@ -205,7 +205,7 @@ Node* IdealKit::make_label(int goto_ct) {
assert(_cvstate != NULL, "must declare variables before labels"); assert(_cvstate != NULL, "must declare variables before labels");
Node* lab = new_cvstate(); Node* lab = new_cvstate();
int sz = 1 + goto_ct + 1 /* fall thru */; int sz = 1 + goto_ct + 1 /* fall thru */;
Node* reg = delay_transform(new (C) RegionNode(sz)); Node* reg = delay_transform(new RegionNode(sz));
lab->init_req(TypeFunc::Control, reg); lab->init_req(TypeFunc::Control, reg);
return lab; return lab;
} }
@ -312,7 +312,7 @@ Node* IdealKit::delay_transform(Node* n) {
//-----------------------------new_cvstate----------------------------------- //-----------------------------new_cvstate-----------------------------------
Node* IdealKit::new_cvstate() { Node* IdealKit::new_cvstate() {
uint sz = _var_ct + first_var; uint sz = _var_ct + first_var;
return new (C) Node(sz); return new Node(sz);
} }
//-----------------------------copy_cvstate----------------------------------- //-----------------------------copy_cvstate-----------------------------------
@ -397,7 +397,7 @@ Node* IdealKit::storeCM(Node* ctl, Node* adr, Node *val, Node* oop_store, int oo
// Add required edge to oop_store, optimizer does not support precedence edges. // Add required edge to oop_store, optimizer does not support precedence edges.
// Convert required edge to precedence edge before allocation. // Convert required edge to precedence edge before allocation.
Node* st = new (C) StoreCMNode(ctl, mem, adr, adr_type, val, oop_store, oop_adr_idx); Node* st = new StoreCMNode(ctl, mem, adr, adr_type, val, oop_store, oop_adr_idx);
st = transform(st); st = transform(st);
set_memory(st, adr_idx); set_memory(st, adr_idx);
@ -497,7 +497,7 @@ void IdealKit::make_leaf_call(const TypeFunc *slow_call_type,
uint adr_idx = C->get_alias_index(adr_type); uint adr_idx = C->get_alias_index(adr_type);
// Slow-path leaf call // Slow-path leaf call
CallNode *call = (CallNode*)new (C) CallLeafNode( slow_call_type, slow_call, leaf_name, adr_type); CallNode *call = (CallNode*)new CallLeafNode( slow_call_type, slow_call, leaf_name, adr_type);
// Set fixed predefined input arguments // Set fixed predefined input arguments
call->init_req( TypeFunc::Control, ctrl() ); call->init_req( TypeFunc::Control, ctrl() );
@ -518,10 +518,10 @@ void IdealKit::make_leaf_call(const TypeFunc *slow_call_type,
// Slow leaf call has no side-effects, sets few values // Slow leaf call has no side-effects, sets few values
set_ctrl(transform( new (C) ProjNode(call,TypeFunc::Control) )); set_ctrl(transform( new ProjNode(call,TypeFunc::Control) ));
// Make memory for the call // 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. // Set the RawPtr memory state only.
set_memory(mem, adr_idx); set_memory(mem, adr_idx);
@ -544,7 +544,7 @@ void IdealKit::make_leaf_call_no_fp(const TypeFunc *slow_call_type,
uint adr_idx = C->get_alias_index(adr_type); uint adr_idx = C->get_alias_index(adr_type);
// Slow-path leaf call // Slow-path leaf call
CallNode *call = (CallNode*)new (C) CallLeafNoFPNode( slow_call_type, slow_call, leaf_name, adr_type); CallNode *call = (CallNode*)new CallLeafNoFPNode( slow_call_type, slow_call, leaf_name, adr_type);
// Set fixed predefined input arguments // Set fixed predefined input arguments
call->init_req( TypeFunc::Control, ctrl() ); call->init_req( TypeFunc::Control, ctrl() );
@ -565,10 +565,10 @@ void IdealKit::make_leaf_call_no_fp(const TypeFunc *slow_call_type,
// Slow leaf call has no side-effects, sets few values // Slow leaf call has no side-effects, sets few values
set_ctrl(transform( new (C) ProjNode(call,TypeFunc::Control) )); set_ctrl(transform( new ProjNode(call,TypeFunc::Control) ));
// Make memory for the call // 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. // Set the RawPtr memory state only.
set_memory(mem, adr_idx); set_memory(mem, adr_idx);

34
hotspot/src/share/vm/opto/idealKit.hpp
View file

@ -173,43 +173,43 @@ class IdealKit: public StackObj {
void goto_(Node* lab, bool bind = false); void goto_(Node* lab, bool bind = false);
void declarations_done(); void declarations_done();
Node* IfTrue(IfNode* iff) { return transform(new (C) IfTrueNode(iff)); } Node* IfTrue(IfNode* iff) { return transform(new IfTrueNode(iff)); }
Node* IfFalse(IfNode* iff) { return transform(new (C) IfFalseNode(iff)); } Node* IfFalse(IfNode* iff) { return transform(new IfFalseNode(iff)); }
// Data // Data
Node* ConI(jint k) { return (Node*)gvn().intcon(k); } Node* ConI(jint k) { return (Node*)gvn().intcon(k); }
Node* makecon(const Type *t) const { return _gvn.makecon(t); } Node* makecon(const Type *t) const { return _gvn.makecon(t); }
Node* AddI(Node* l, Node* r) { return transform(new (C) AddINode(l, r)); } Node* AddI(Node* l, Node* r) { return transform(new AddINode(l, r)); }
Node* SubI(Node* l, Node* r) { return transform(new (C) SubINode(l, r)); } Node* SubI(Node* l, Node* r) { return transform(new SubINode(l, r)); }
Node* AndI(Node* l, Node* r) { return transform(new (C) AndINode(l, r)); } Node* AndI(Node* l, Node* r) { return transform(new AndINode(l, r)); }
Node* MaxI(Node* l, Node* r) { return transform(new (C) MaxINode(l, r)); } Node* MaxI(Node* l, Node* r) { return transform(new MaxINode(l, r)); }
Node* LShiftI(Node* l, Node* r) { return transform(new (C) LShiftINode(l, r)); } Node* LShiftI(Node* l, Node* r) { return transform(new LShiftINode(l, r)); }
Node* CmpI(Node* l, Node* r) { return transform(new (C) CmpINode(l, r)); } Node* CmpI(Node* l, Node* r) { return transform(new CmpINode(l, r)); }
Node* Bool(Node* cmp, BoolTest::mask relop) { return transform(new (C) BoolNode(cmp, relop)); } Node* Bool(Node* cmp, BoolTest::mask relop) { return transform(new BoolNode(cmp, relop)); }
void increment(IdealVariable& v, Node* j) { set(v, AddI(value(v), j)); } void increment(IdealVariable& v, Node* j) { set(v, AddI(value(v), j)); }
void decrement(IdealVariable& v, Node* j) { set(v, SubI(value(v), j)); } void decrement(IdealVariable& v, Node* j) { set(v, SubI(value(v), j)); }
Node* CmpL(Node* l, Node* r) { return transform(new (C) CmpLNode(l, r)); } Node* CmpL(Node* l, Node* r) { return transform(new CmpLNode(l, r)); }
// TLS // TLS
Node* thread() { return gvn().transform(new (C) ThreadLocalNode()); } Node* thread() { return gvn().transform(new ThreadLocalNode()); }
// Pointers // Pointers
// Raw address should be transformed regardless 'delay_transform' flag // Raw address should be transformed regardless 'delay_transform' flag
// to produce canonical form CastX2P(offset). // to produce canonical form CastX2P(offset).
Node* AddP(Node *base, Node *ptr, Node *off) { return _gvn.transform(new (C) AddPNode(base, ptr, off)); } Node* AddP(Node *base, Node *ptr, Node *off) { return _gvn.transform(new AddPNode(base, ptr, off)); }
Node* CmpP(Node* l, Node* r) { return transform(new (C) CmpPNode(l, r)); } Node* CmpP(Node* l, Node* r) { return transform(new CmpPNode(l, r)); }
#ifdef _LP64 #ifdef _LP64
Node* XorX(Node* l, Node* r) { return transform(new (C) XorLNode(l, r)); } Node* XorX(Node* l, Node* r) { return transform(new XorLNode(l, r)); }
#else // _LP64 #else // _LP64
Node* XorX(Node* l, Node* r) { return transform(new (C) XorINode(l, r)); } Node* XorX(Node* l, Node* r) { return transform(new XorINode(l, r)); }
#endif // _LP64 #endif // _LP64
Node* URShiftX(Node* l, Node* r) { return transform(new (C) URShiftXNode(l, r)); } Node* URShiftX(Node* l, Node* r) { return transform(new URShiftXNode(l, r)); }
Node* ConX(jint k) { return (Node*)gvn().MakeConX(k); } Node* ConX(jint k) { return (Node*)gvn().MakeConX(k); }
Node* CastPX(Node* ctl, Node* p) { return transform(new (C) CastP2XNode(ctl, p)); } Node* CastPX(Node* ctl, Node* p) { return transform(new CastP2XNode(ctl, p)); }
// Memory operations // Memory operations

52
hotspot/src/share/vm/opto/ifnode.cpp
View file

@ -238,10 +238,10 @@ static Node* split_if(IfNode *iff, PhaseIterGVN *igvn) {
Node* predicate_x = NULL; Node* predicate_x = NULL;
bool counted_loop = r->is_CountedLoop(); bool counted_loop = r->is_CountedLoop();
Node *region_c = new (igvn->C) RegionNode(req_c + 1); Node *region_c = new RegionNode(req_c + 1);
Node *phi_c = con1; Node *phi_c = con1;
uint len = r->req(); uint len = r->req();
Node *region_x = new (igvn->C) RegionNode(len - req_c); Node *region_x = new RegionNode(len - req_c);
Node *phi_x = PhiNode::make_blank(region_x, phi); Node *phi_x = PhiNode::make_blank(region_x, phi);
for (uint i = 1, i_c = 1, i_x = 1; i < len; i++) { for (uint i = 1, i_c = 1, i_x = 1; i < len; i++) {
if (phi->in(i) == con1) { if (phi->in(i) == con1) {
@ -272,7 +272,7 @@ static Node* split_if(IfNode *iff, PhaseIterGVN *igvn) {
// Prevent the untimely death of phi_x. Currently he has no uses. He is // Prevent the untimely death of phi_x. Currently he has no uses. He is
// about to get one. If this only use goes away, then phi_x will look dead. // about to get one. If this only use goes away, then phi_x will look dead.
// However, he will be picking up some more uses down below. // However, he will be picking up some more uses down below.
Node *hook = new (igvn->C) Node(4); Node *hook = new Node(4);
hook->init_req(0, phi_x); hook->init_req(0, phi_x);
hook->init_req(1, phi_c); hook->init_req(1, phi_c);
phi_x = phase->transform( phi_x ); phi_x = phase->transform( phi_x );
@ -284,30 +284,30 @@ static Node* split_if(IfNode *iff, PhaseIterGVN *igvn) {
cmp_x->set_req(2,con2); cmp_x->set_req(2,con2);
cmp_x = phase->transform(cmp_x); cmp_x = phase->transform(cmp_x);
// Make the bool // Make the bool
Node *b_c = phase->transform(new (igvn->C) BoolNode(cmp_c,b->_test._test)); Node *b_c = phase->transform(new BoolNode(cmp_c,b->_test._test));
Node *b_x = phase->transform(new (igvn->C) BoolNode(cmp_x,b->_test._test)); Node *b_x = phase->transform(new BoolNode(cmp_x,b->_test._test));
// Make the IfNode // Make the IfNode
IfNode *iff_c = new (igvn->C) IfNode(region_c,b_c,iff->_prob,iff->_fcnt); IfNode *iff_c = new IfNode(region_c,b_c,iff->_prob,iff->_fcnt);
igvn->set_type_bottom(iff_c); igvn->set_type_bottom(iff_c);
igvn->_worklist.push(iff_c); igvn->_worklist.push(iff_c);
hook->init_req(2, iff_c); hook->init_req(2, iff_c);
IfNode *iff_x = new (igvn->C) IfNode(region_x,b_x,iff->_prob, iff->_fcnt); IfNode *iff_x = new IfNode(region_x,b_x,iff->_prob, iff->_fcnt);
igvn->set_type_bottom(iff_x); igvn->set_type_bottom(iff_x);
igvn->_worklist.push(iff_x); igvn->_worklist.push(iff_x);
hook->init_req(3, iff_x); hook->init_req(3, iff_x);
// Make the true/false arms // Make the true/false arms
Node *iff_c_t = phase->transform(new (igvn->C) IfTrueNode (iff_c)); Node *iff_c_t = phase->transform(new IfTrueNode (iff_c));
Node *iff_c_f = phase->transform(new (igvn->C) IfFalseNode(iff_c)); Node *iff_c_f = phase->transform(new IfFalseNode(iff_c));
if (predicate_c != NULL) { if (predicate_c != NULL) {
assert(predicate_x == NULL, "only one predicate entry expected"); assert(predicate_x == NULL, "only one predicate entry expected");
// Clone loop predicates to each path // Clone loop predicates to each path
iff_c_t = igvn->clone_loop_predicates(predicate_c, iff_c_t, !counted_loop); iff_c_t = igvn->clone_loop_predicates(predicate_c, iff_c_t, !counted_loop);
iff_c_f = igvn->clone_loop_predicates(predicate_c, iff_c_f, !counted_loop); iff_c_f = igvn->clone_loop_predicates(predicate_c, iff_c_f, !counted_loop);
} }
Node *iff_x_t = phase->transform(new (igvn->C) IfTrueNode (iff_x)); Node *iff_x_t = phase->transform(new IfTrueNode (iff_x));
Node *iff_x_f = phase->transform(new (igvn->C) IfFalseNode(iff_x)); Node *iff_x_f = phase->transform(new IfFalseNode(iff_x));
if (predicate_x != NULL) { if (predicate_x != NULL) {
assert(predicate_c == NULL, "only one predicate entry expected"); assert(predicate_c == NULL, "only one predicate entry expected");
// Clone loop predicates to each path // Clone loop predicates to each path
@ -316,14 +316,14 @@ static Node* split_if(IfNode *iff, PhaseIterGVN *igvn) {
} }
// Merge the TRUE paths // Merge the TRUE paths
Node *region_s = new (igvn->C) RegionNode(3); Node *region_s = new RegionNode(3);
igvn->_worklist.push(region_s); igvn->_worklist.push(region_s);
region_s->init_req(1, iff_c_t); region_s->init_req(1, iff_c_t);
region_s->init_req(2, iff_x_t); region_s->init_req(2, iff_x_t);
igvn->register_new_node_with_optimizer( region_s ); igvn->register_new_node_with_optimizer( region_s );
// Merge the FALSE paths // Merge the FALSE paths
Node *region_f = new (igvn->C) RegionNode(3); Node *region_f = new RegionNode(3);
igvn->_worklist.push(region_f); igvn->_worklist.push(region_f);
region_f->init_req(1, iff_c_f); region_f->init_req(1, iff_c_f);
region_f->init_req(2, iff_x_f); region_f->init_req(2, iff_x_f);
@ -438,7 +438,7 @@ static Node* split_if(IfNode *iff, PhaseIterGVN *igvn) {
// Must return either the original node (now dead) or a new node // Must return either the original node (now dead) or a new node
// (Do not return a top here, since that would break the uniqueness of top.) // (Do not return a top here, since that would break the uniqueness of top.)
return new (igvn->C) ConINode(TypeInt::ZERO); return new ConINode(TypeInt::ZERO);
} }
//------------------------------is_range_check--------------------------------- //------------------------------is_range_check---------------------------------
@ -541,16 +541,16 @@ static void adjust_check(Node* proj, Node* range, Node* index,
// Compute a new check // Compute a new check
Node *new_add = gvn->intcon(off_lo); Node *new_add = gvn->intcon(off_lo);
if( index ) { if( index ) {
new_add = off_lo ? gvn->transform(new (gvn->C) AddINode( index, new_add )) : index; new_add = off_lo ? gvn->transform(new AddINode( index, new_add )) : index;
} }
Node *new_cmp = (flip == 1) Node *new_cmp = (flip == 1)
? new (gvn->C) CmpUNode( new_add, range ) ? new CmpUNode( new_add, range )
: new (gvn->C) CmpUNode( range, new_add ); : new CmpUNode( range, new_add );
new_cmp = gvn->transform(new_cmp); new_cmp = gvn->transform(new_cmp);
// See if no need to adjust the existing check // See if no need to adjust the existing check
if( new_cmp == cmp ) return; if( new_cmp == cmp ) return;
// Else, adjust existing check // Else, adjust existing check
Node *new_bol = gvn->transform( new (gvn->C) BoolNode( new_cmp, bol->as_Bool()->_test._test ) ); Node *new_bol = gvn->transform( new BoolNode( new_cmp, bol->as_Bool()->_test._test ) );
igvn->rehash_node_delayed( iff ); igvn->rehash_node_delayed( iff );
iff->set_req_X( 1, new_bol, igvn ); iff->set_req_X( 1, new_bol, igvn );
} }
@ -728,9 +728,9 @@ Node* IfNode::fold_compares(PhaseGVN* phase) {
if (failtype->_hi != max_jint && failtype->_lo != min_jint && bound > 1) { if (failtype->_hi != max_jint && failtype->_lo != min_jint && bound > 1) {
// Merge the two compares into a single unsigned compare by building (CmpU (n - lo) hi) // Merge the two compares into a single unsigned compare by building (CmpU (n - lo) hi)
BoolTest::mask cond = fail->as_Proj()->_con ? BoolTest::lt : BoolTest::ge; BoolTest::mask cond = fail->as_Proj()->_con ? BoolTest::lt : BoolTest::ge;
Node* adjusted = phase->transform(new (phase->C) SubINode(n, phase->intcon(failtype->_lo))); Node* adjusted = phase->transform(new SubINode(n, phase->intcon(failtype->_lo)));
Node* newcmp = phase->transform(new (phase->C) CmpUNode(adjusted, phase->intcon(bound))); Node* newcmp = phase->transform(new CmpUNode(adjusted, phase->intcon(bound)));
Node* newbool = phase->transform(new (phase->C) BoolNode(newcmp, cond)); Node* newbool = phase->transform(new BoolNode(newcmp, cond));
phase->is_IterGVN()->replace_input_of(dom_iff, 1, phase->intcon(ctrl->as_Proj()->_con)); phase->is_IterGVN()->replace_input_of(dom_iff, 1, phase->intcon(ctrl->as_Proj()->_con));
phase->hash_delete(this); phase->hash_delete(this);
set_req(1, newbool); set_req(1, newbool);
@ -1003,7 +1003,7 @@ Node *IfNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// Must return either the original node (now dead) or a new node // Must return either the original node (now dead) or a new node
// (Do not return a top here, since that would break the uniqueness of top.) // (Do not return a top here, since that would break the uniqueness of top.)
return new (phase->C) ConINode(TypeInt::ZERO); return new ConINode(TypeInt::ZERO);
} }
//------------------------------dominated_by----------------------------------- //------------------------------dominated_by-----------------------------------
@ -1099,7 +1099,7 @@ static IfNode* idealize_test(PhaseGVN* phase, IfNode* iff) {
// Flip test to be canonical. Requires flipping the IfFalse/IfTrue and // Flip test to be canonical. Requires flipping the IfFalse/IfTrue and
// cloning the IfNode. // cloning the IfNode.
Node* new_b = phase->transform( new (phase->C) BoolNode(b->in(1), bt.negate()) ); Node* new_b = phase->transform( new BoolNode(b->in(1), bt.negate()) );
if( !new_b->is_Bool() ) return NULL; if( !new_b->is_Bool() ) return NULL;
b = new_b->as_Bool(); b = new_b->as_Bool();
@ -1107,7 +1107,7 @@ static IfNode* idealize_test(PhaseGVN* phase, IfNode* iff) {
assert( igvn, "Test is not canonical in parser?" ); assert( igvn, "Test is not canonical in parser?" );
// The IF node never really changes, but it needs to be cloned // The IF node never really changes, but it needs to be cloned
iff = new (phase->C) IfNode( iff->in(0), b, 1.0-iff->_prob, iff->_fcnt); iff = new IfNode( iff->in(0), b, 1.0-iff->_prob, iff->_fcnt);
Node *prior = igvn->hash_find_insert(iff); Node *prior = igvn->hash_find_insert(iff);
if( prior ) { if( prior ) {
@ -1120,8 +1120,8 @@ static IfNode* idealize_test(PhaseGVN* phase, IfNode* iff) {
igvn->_worklist.push(iff); igvn->_worklist.push(iff);
// Now handle projections. Cloning not required. // Now handle projections. Cloning not required.
Node* new_if_f = (Node*)(new (phase->C) IfFalseNode( iff )); Node* new_if_f = (Node*)(new IfFalseNode( iff ));
Node* new_if_t = (Node*)(new (phase->C) IfTrueNode ( iff )); Node* new_if_t = (Node*)(new IfTrueNode ( iff ));
igvn->register_new_node_with_optimizer(new_if_f); igvn->register_new_node_with_optimizer(new_if_f);
igvn->register_new_node_with_optimizer(new_if_t); igvn->register_new_node_with_optimizer(new_if_t);

8
hotspot/src/share/vm/opto/lcm.cpp
View file

@ -419,7 +419,7 @@ void PhaseCFG::implicit_null_check(Block* block, Node *proj, Node *val, int allo
Node *tmp2 = block->get_node(block->end_idx()+2); Node *tmp2 = block->get_node(block->end_idx()+2);
block->map_node(tmp2, block->end_idx()+1); block->map_node(tmp2, block->end_idx()+1);
block->map_node(tmp1, block->end_idx()+2); block->map_node(tmp1, block->end_idx()+2);
Node *tmp = new (C) Node(C->top()); // Use not NULL input Node *tmp = new Node(C->top()); // Use not NULL input
tmp1->replace_by(tmp); tmp1->replace_by(tmp);
tmp2->replace_by(tmp1); tmp2->replace_by(tmp1);
tmp->replace_by(tmp2); tmp->replace_by(tmp2);
@ -430,7 +430,7 @@ void PhaseCFG::implicit_null_check(Block* block, Node *proj, Node *val, int allo
// Since schedule-local needs precise def-use info, we need to correct // Since schedule-local needs precise def-use info, we need to correct
// it as well. // it as well.
Node *old_tst = proj->in(0); Node *old_tst = proj->in(0);
MachNode *nul_chk = new (C) MachNullCheckNode(old_tst->in(0),best,bidx); MachNode *nul_chk = new MachNullCheckNode(old_tst->in(0),best,bidx);
block->map_node(nul_chk, block->end_idx()); block->map_node(nul_chk, block->end_idx());
map_node_to_block(nul_chk, block); map_node_to_block(nul_chk, block);
// Redirect users of old_test to nul_chk // Redirect users of old_test to nul_chk
@ -671,7 +671,7 @@ uint PhaseCFG::sched_call(Block* block, uint node_cnt, Node_List& worklist, Grow
// Set all registers killed and not already defined by the call. // Set all registers killed and not already defined by the call.
uint r_cnt = mcall->tf()->range()->cnt(); uint r_cnt = mcall->tf()->range()->cnt();
int op = mcall->ideal_Opcode(); int op = mcall->ideal_Opcode();
MachProjNode *proj = new (C) MachProjNode( mcall, r_cnt+1, RegMask::Empty, MachProjNode::fat_proj ); MachProjNode *proj = new MachProjNode( mcall, r_cnt+1, RegMask::Empty, MachProjNode::fat_proj );
map_node_to_block(proj, block); map_node_to_block(proj, block);
block->insert_node(proj, node_cnt++); block->insert_node(proj, node_cnt++);
@ -900,7 +900,7 @@ bool PhaseCFG::schedule_local(Block* block, GrowableArray<int>& ready_cnt, Vecto
regs.Insert(_matcher.c_frame_pointer()); regs.Insert(_matcher.c_frame_pointer());
regs.OR(n->out_RegMask()); regs.OR(n->out_RegMask());
MachProjNode *proj = new (C) MachProjNode( n, 1, RegMask::Empty, MachProjNode::fat_proj ); MachProjNode *proj = new MachProjNode( n, 1, RegMask::Empty, MachProjNode::fat_proj );
map_node_to_block(proj, block); map_node_to_block(proj, block);
block->insert_node(proj, phi_cnt++); block->insert_node(proj, phi_cnt++);

559
hotspot/src/share/vm/opto/library_call.cpp
View file

File diff suppressed because it is too large Load diff

30
hotspot/src/share/vm/opto/loopPredicate.cpp
View file

@ -104,7 +104,7 @@ ProjNode* PhaseIdealLoop::create_new_if_for_predicate(ProjNode* cont_proj, Node*
assert(rgn->is_Call(), "must be call uct"); assert(rgn->is_Call(), "must be call uct");
CallNode* call = rgn->as_Call(); CallNode* call = rgn->as_Call();
IdealLoopTree* loop = get_loop(call); IdealLoopTree* loop = get_loop(call);
rgn = new (C) RegionNode(1); rgn = new RegionNode(1);
rgn->add_req(uncommon_proj); rgn->add_req(uncommon_proj);
register_control(rgn, loop, uncommon_proj); register_control(rgn, loop, uncommon_proj);
_igvn.hash_delete(call); _igvn.hash_delete(call);
@ -130,8 +130,8 @@ ProjNode* PhaseIdealLoop::create_new_if_for_predicate(ProjNode* cont_proj, Node*
IfNode *new_iff = iff->clone()->as_If(); IfNode *new_iff = iff->clone()->as_If();
new_iff->set_req(0, entry); new_iff->set_req(0, entry);
register_control(new_iff, lp, entry); register_control(new_iff, lp, entry);
Node *if_cont = new (C) IfTrueNode(new_iff); Node *if_cont = new IfTrueNode(new_iff);
Node *if_uct = new (C) IfFalseNode(new_iff); Node *if_uct = new IfFalseNode(new_iff);
if (cont_proj->is_IfFalse()) { if (cont_proj->is_IfFalse()) {
// Swap // Swap
Node* tmp = if_uct; if_uct = if_cont; if_cont = tmp; Node* tmp = if_uct; if_uct = if_cont; if_cont = tmp;
@ -191,7 +191,7 @@ ProjNode* PhaseIterGVN::create_new_if_for_predicate(ProjNode* cont_proj, Node* n
if (!rgn->is_Region()) { // create a region to guard the call if (!rgn->is_Region()) { // create a region to guard the call
assert(rgn->is_Call(), "must be call uct"); assert(rgn->is_Call(), "must be call uct");
CallNode* call = rgn->as_Call(); CallNode* call = rgn->as_Call();
rgn = new (C) RegionNode(1); rgn = new RegionNode(1);
register_new_node_with_optimizer(rgn); register_new_node_with_optimizer(rgn);
rgn->add_req(uncommon_proj); rgn->add_req(uncommon_proj);
hash_delete(call); hash_delete(call);
@ -208,8 +208,8 @@ ProjNode* PhaseIterGVN::create_new_if_for_predicate(ProjNode* cont_proj, Node* n
new_iff->set_req(0, new_entry); new_iff->set_req(0, new_entry);
register_new_node_with_optimizer(new_iff); register_new_node_with_optimizer(new_iff);
Node *if_cont = new (C) IfTrueNode(new_iff); Node *if_cont = new IfTrueNode(new_iff);
Node *if_uct = new (C) IfFalseNode(new_iff); Node *if_uct = new IfFalseNode(new_iff);
if (cont_proj->is_IfFalse()) { if (cont_proj->is_IfFalse()) {
// Swap // Swap
Node* tmp = if_uct; if_uct = if_cont; if_cont = tmp; Node* tmp = if_uct; if_uct = if_cont; if_cont = tmp;
@ -254,10 +254,10 @@ ProjNode* PhaseIdealLoop::clone_predicate(ProjNode* predicate_proj, Node* new_en
// Match original condition since predicate's projections could be swapped. // Match original condition since predicate's projections could be swapped.
assert(predicate_proj->in(0)->in(1)->in(1)->Opcode()==Op_Opaque1, "must be"); assert(predicate_proj->in(0)->in(1)->in(1)->Opcode()==Op_Opaque1, "must be");
Node* opq = new (igvn->C) Opaque1Node(igvn->C, predicate_proj->in(0)->in(1)->in(1)->in(1)); Node* opq = new Opaque1Node(igvn->C, predicate_proj->in(0)->in(1)->in(1)->in(1));
igvn->C->add_predicate_opaq(opq); igvn->C->add_predicate_opaq(opq);
Node* bol = new (igvn->C) Conv2BNode(opq); Node* bol = new Conv2BNode(opq);
if (loop_phase != NULL) { if (loop_phase != NULL) {
loop_phase->register_new_node(opq, ctrl); loop_phase->register_new_node(opq, ctrl);
loop_phase->register_new_node(bol, ctrl); loop_phase->register_new_node(bol, ctrl);
@ -605,11 +605,11 @@ BoolNode* PhaseIdealLoop::rc_predicate(IdealLoopTree *loop, Node* ctrl,
// Calculate exact limit here. // Calculate exact limit here.
// Note, counted loop's test is '<' or '>'. // Note, counted loop's test is '<' or '>'.
limit = exact_limit(loop); limit = exact_limit(loop);
max_idx_expr = new (C) SubINode(limit, stride); max_idx_expr = new SubINode(limit, stride);
register_new_node(max_idx_expr, ctrl); register_new_node(max_idx_expr, ctrl);
if (TraceLoopPredicate) predString->print("(limit - stride) "); if (TraceLoopPredicate) predString->print("(limit - stride) ");
} else { } else {
max_idx_expr = new (C) SubINode(limit, stride); max_idx_expr = new SubINode(limit, stride);
register_new_node(max_idx_expr, ctrl); register_new_node(max_idx_expr, ctrl);
if (TraceLoopPredicate) predString->print("(limit - stride) "); if (TraceLoopPredicate) predString->print("(limit - stride) ");
} }
@ -619,22 +619,22 @@ BoolNode* PhaseIdealLoop::rc_predicate(IdealLoopTree *loop, Node* ctrl,
if (scale != 1) { if (scale != 1) {
ConNode* con_scale = _igvn.intcon(scale); ConNode* con_scale = _igvn.intcon(scale);
max_idx_expr = new (C) MulINode(max_idx_expr, con_scale); max_idx_expr = new MulINode(max_idx_expr, con_scale);
register_new_node(max_idx_expr, ctrl); register_new_node(max_idx_expr, ctrl);
if (TraceLoopPredicate) predString->print("* %d ", scale); if (TraceLoopPredicate) predString->print("* %d ", scale);
} }
if (offset && (!offset->is_Con() || offset->get_int() != 0)){ if (offset && (!offset->is_Con() || offset->get_int() != 0)){
max_idx_expr = new (C) AddINode(max_idx_expr, offset); max_idx_expr = new AddINode(max_idx_expr, offset);
register_new_node(max_idx_expr, ctrl); register_new_node(max_idx_expr, ctrl);
if (TraceLoopPredicate) if (TraceLoopPredicate)
if (offset->is_Con()) predString->print("+ %d ", offset->get_int()); if (offset->is_Con()) predString->print("+ %d ", offset->get_int());
else predString->print("+ offset "); else predString->print("+ offset ");
} }
CmpUNode* cmp = new (C) CmpUNode(max_idx_expr, range); CmpUNode* cmp = new CmpUNode(max_idx_expr, range);
register_new_node(cmp, ctrl); register_new_node(cmp, ctrl);
BoolNode* bol = new (C) BoolNode(cmp, BoolTest::lt); BoolNode* bol = new BoolNode(cmp, BoolTest::lt);
register_new_node(bol, ctrl); register_new_node(bol, ctrl);
if (TraceLoopPredicate) { if (TraceLoopPredicate) {
@ -750,7 +750,7 @@ bool PhaseIdealLoop::loop_predication_impl(IdealLoopTree *loop) {
// Negate test if necessary // Negate test if necessary
bool negated = false; bool negated = false;
if (proj->_con != predicate_proj->_con) { if (proj->_con != predicate_proj->_con) {
new_predicate_bol = new (C) BoolNode(new_predicate_bol->in(1), new_predicate_bol->_test.negate()); new_predicate_bol = new BoolNode(new_predicate_bol->in(1), new_predicate_bol->_test.negate());
register_new_node(new_predicate_bol, ctrl); register_new_node(new_predicate_bol, ctrl);
negated = true; negated = true;
} }

142
hotspot/src/share/vm/opto/loopTransform.cpp
View file

@ -227,24 +227,24 @@ Node* IdealLoopTree::reassociate_add_sub(Node* n1, PhaseIdealLoop *phase) {
if (neg_inv1) { if (neg_inv1) {
Node *zero = phase->_igvn.intcon(0); Node *zero = phase->_igvn.intcon(0);
phase->set_ctrl(zero, phase->C->root()); phase->set_ctrl(zero, phase->C->root());
n_inv1 = new (phase->C) SubINode(zero, inv1); n_inv1 = new SubINode(zero, inv1);
phase->register_new_node(n_inv1, inv1_c); phase->register_new_node(n_inv1, inv1_c);
} else { } else {
n_inv1 = inv1; n_inv1 = inv1;
} }
Node* inv; Node* inv;
if (neg_inv2) { if (neg_inv2) {
inv = new (phase->C) SubINode(n_inv1, inv2); inv = new SubINode(n_inv1, inv2);
} else { } else {
inv = new (phase->C) AddINode(n_inv1, inv2); inv = new AddINode(n_inv1, inv2);
} }
phase->register_new_node(inv, phase->get_early_ctrl(inv)); phase->register_new_node(inv, phase->get_early_ctrl(inv));
Node* addx; Node* addx;
if (neg_x) { if (neg_x) {
addx = new (phase->C) SubINode(inv, x); addx = new SubINode(inv, x);
} else { } else {
addx = new (phase->C) AddINode(x, inv); addx = new AddINode(x, inv);
} }
phase->register_new_node(addx, phase->get_ctrl(x)); phase->register_new_node(addx, phase->get_ctrl(x));
phase->_igvn.replace_node(n1, addx); phase->_igvn.replace_node(n1, addx);
@ -953,7 +953,7 @@ void PhaseIdealLoop::insert_pre_post_loops( IdealLoopTree *loop, Node_List &old_
post_end->_prob = PROB_FAIR; post_end->_prob = PROB_FAIR;
// Build the main-loop normal exit. // Build the main-loop normal exit.
IfFalseNode *new_main_exit = new (C) IfFalseNode(main_end); IfFalseNode *new_main_exit = new IfFalseNode(main_end);
_igvn.register_new_node_with_optimizer( new_main_exit ); _igvn.register_new_node_with_optimizer( new_main_exit );
set_idom(new_main_exit, main_end, dd_main_exit ); set_idom(new_main_exit, main_end, dd_main_exit );
set_loop(new_main_exit, loop->_parent); set_loop(new_main_exit, loop->_parent);
@ -963,15 +963,15 @@ void PhaseIdealLoop::insert_pre_post_loops( IdealLoopTree *loop, Node_List &old_
// (the main-loop trip-counter exit value) because we will be changing // (the main-loop trip-counter exit value) because we will be changing
// the exit value (via unrolling) so we cannot constant-fold away the zero // the exit value (via unrolling) so we cannot constant-fold away the zero
// trip guard until all unrolling is done. // trip guard until all unrolling is done.
Node *zer_opaq = new (C) Opaque1Node(C, incr); Node *zer_opaq = new Opaque1Node(C, incr);
Node *zer_cmp = new (C) CmpINode( zer_opaq, limit ); Node *zer_cmp = new CmpINode( zer_opaq, limit );
Node *zer_bol = new (C) BoolNode( zer_cmp, b_test ); Node *zer_bol = new BoolNode( zer_cmp, b_test );
register_new_node( zer_opaq, new_main_exit ); register_new_node( zer_opaq, new_main_exit );
register_new_node( zer_cmp , new_main_exit ); register_new_node( zer_cmp , new_main_exit );
register_new_node( zer_bol , new_main_exit ); register_new_node( zer_bol , new_main_exit );
// Build the IfNode // Build the IfNode
IfNode *zer_iff = new (C) IfNode( new_main_exit, zer_bol, PROB_FAIR, COUNT_UNKNOWN ); IfNode *zer_iff = new IfNode( new_main_exit, zer_bol, PROB_FAIR, COUNT_UNKNOWN );
_igvn.register_new_node_with_optimizer( zer_iff ); _igvn.register_new_node_with_optimizer( zer_iff );
set_idom(zer_iff, new_main_exit, dd_main_exit); set_idom(zer_iff, new_main_exit, dd_main_exit);
set_loop(zer_iff, loop->_parent); set_loop(zer_iff, loop->_parent);
@ -981,7 +981,7 @@ void PhaseIdealLoop::insert_pre_post_loops( IdealLoopTree *loop, Node_List &old_
set_idom(main_exit, zer_iff, dd_main_exit); set_idom(main_exit, zer_iff, dd_main_exit);
set_idom(main_exit->unique_out(), zer_iff, dd_main_exit); set_idom(main_exit->unique_out(), zer_iff, dd_main_exit);
// Make the true-path, must enter the post loop // Make the true-path, must enter the post loop
Node *zer_taken = new (C) IfTrueNode( zer_iff ); Node *zer_taken = new IfTrueNode( zer_iff );
_igvn.register_new_node_with_optimizer( zer_taken ); _igvn.register_new_node_with_optimizer( zer_taken );
set_idom(zer_taken, zer_iff, dd_main_exit); set_idom(zer_taken, zer_iff, dd_main_exit);
set_loop(zer_taken, loop->_parent); set_loop(zer_taken, loop->_parent);
@ -1029,7 +1029,7 @@ void PhaseIdealLoop::insert_pre_post_loops( IdealLoopTree *loop, Node_List &old_
// Find the pre-loop normal exit. // Find the pre-loop normal exit.
Node* pre_exit = pre_end->proj_out(false); Node* pre_exit = pre_end->proj_out(false);
assert( pre_exit->Opcode() == Op_IfFalse, "" ); assert( pre_exit->Opcode() == Op_IfFalse, "" );
IfFalseNode *new_pre_exit = new (C) IfFalseNode(pre_end); IfFalseNode *new_pre_exit = new IfFalseNode(pre_end);
_igvn.register_new_node_with_optimizer( new_pre_exit ); _igvn.register_new_node_with_optimizer( new_pre_exit );
set_idom(new_pre_exit, pre_end, dd_main_head); set_idom(new_pre_exit, pre_end, dd_main_head);
set_loop(new_pre_exit, loop->_parent); set_loop(new_pre_exit, loop->_parent);
@ -1038,15 +1038,15 @@ void PhaseIdealLoop::insert_pre_post_loops( IdealLoopTree *loop, Node_List &old_
// pre-loop, the main-loop may not execute at all. Later in life this // pre-loop, the main-loop may not execute at all. Later in life this
// zero-trip guard will become the minimum-trip guard when we unroll // zero-trip guard will become the minimum-trip guard when we unroll
// the main-loop. // the main-loop.
Node *min_opaq = new (C) Opaque1Node(C, limit); Node *min_opaq = new Opaque1Node(C, limit);
Node *min_cmp = new (C) CmpINode( pre_incr, min_opaq ); Node *min_cmp = new CmpINode( pre_incr, min_opaq );
Node *min_bol = new (C) BoolNode( min_cmp, b_test ); Node *min_bol = new BoolNode( min_cmp, b_test );
register_new_node( min_opaq, new_pre_exit ); register_new_node( min_opaq, new_pre_exit );
register_new_node( min_cmp , new_pre_exit ); register_new_node( min_cmp , new_pre_exit );
register_new_node( min_bol , new_pre_exit ); register_new_node( min_bol , new_pre_exit );
// Build the IfNode (assume the main-loop is executed always). // Build the IfNode (assume the main-loop is executed always).
IfNode *min_iff = new (C) IfNode( new_pre_exit, min_bol, PROB_ALWAYS, COUNT_UNKNOWN ); IfNode *min_iff = new IfNode( new_pre_exit, min_bol, PROB_ALWAYS, COUNT_UNKNOWN );
_igvn.register_new_node_with_optimizer( min_iff ); _igvn.register_new_node_with_optimizer( min_iff );
set_idom(min_iff, new_pre_exit, dd_main_head); set_idom(min_iff, new_pre_exit, dd_main_head);
set_loop(min_iff, loop->_parent); set_loop(min_iff, loop->_parent);
@ -1057,7 +1057,7 @@ void PhaseIdealLoop::insert_pre_post_loops( IdealLoopTree *loop, Node_List &old_
set_idom(pre_exit, min_iff, dd_main_head); set_idom(pre_exit, min_iff, dd_main_head);
set_idom(pre_exit->unique_out(), min_iff, dd_main_head); set_idom(pre_exit->unique_out(), min_iff, dd_main_head);
// Make the true-path, must enter the main loop // Make the true-path, must enter the main loop
Node *min_taken = new (C) IfTrueNode( min_iff ); Node *min_taken = new IfTrueNode( min_iff );
_igvn.register_new_node_with_optimizer( min_taken ); _igvn.register_new_node_with_optimizer( min_taken );
set_idom(min_taken, min_iff, dd_main_head); set_idom(min_taken, min_iff, dd_main_head);
set_loop(min_taken, loop->_parent); set_loop(min_taken, loop->_parent);
@ -1087,11 +1087,11 @@ void PhaseIdealLoop::insert_pre_post_loops( IdealLoopTree *loop, Node_List &old_
// RCE and alignment may change this later. // RCE and alignment may change this later.
Node *cmp_end = pre_end->cmp_node(); Node *cmp_end = pre_end->cmp_node();
assert( cmp_end->in(2) == limit, "" ); assert( cmp_end->in(2) == limit, "" );
Node *pre_limit = new (C) AddINode( init, stride ); Node *pre_limit = new AddINode( init, stride );
// Save the original loop limit in this Opaque1 node for // Save the original loop limit in this Opaque1 node for
// use by range check elimination. // use by range check elimination.
Node *pre_opaq = new (C) Opaque1Node(C, pre_limit, limit); Node *pre_opaq = new Opaque1Node(C, pre_limit, limit);
register_new_node( pre_limit, pre_head->in(0) ); register_new_node( pre_limit, pre_head->in(0) );
register_new_node( pre_opaq , pre_head->in(0) ); register_new_node( pre_opaq , pre_head->in(0) );
@ -1116,19 +1116,19 @@ void PhaseIdealLoop::insert_pre_post_loops( IdealLoopTree *loop, Node_List &old_
BoolTest::mask new_test = (main_end->stride_con() > 0) ? BoolTest::lt : BoolTest::gt; BoolTest::mask new_test = (main_end->stride_con() > 0) ? BoolTest::lt : BoolTest::gt;
// Modify pre loop end condition // Modify pre loop end condition
Node* pre_bol = pre_end->in(CountedLoopEndNode::TestValue)->as_Bool(); Node* pre_bol = pre_end->in(CountedLoopEndNode::TestValue)->as_Bool();
BoolNode* new_bol0 = new (C) BoolNode(pre_bol->in(1), new_test); BoolNode* new_bol0 = new BoolNode(pre_bol->in(1), new_test);
register_new_node( new_bol0, pre_head->in(0) ); register_new_node( new_bol0, pre_head->in(0) );
_igvn.hash_delete(pre_end); _igvn.hash_delete(pre_end);
pre_end->set_req(CountedLoopEndNode::TestValue, new_bol0); pre_end->set_req(CountedLoopEndNode::TestValue, new_bol0);
// Modify main loop guard condition // Modify main loop guard condition
assert(min_iff->in(CountedLoopEndNode::TestValue) == min_bol, "guard okay"); assert(min_iff->in(CountedLoopEndNode::TestValue) == min_bol, "guard okay");
BoolNode* new_bol1 = new (C) BoolNode(min_bol->in(1), new_test); BoolNode* new_bol1 = new BoolNode(min_bol->in(1), new_test);
register_new_node( new_bol1, new_pre_exit ); register_new_node( new_bol1, new_pre_exit );
_igvn.hash_delete(min_iff); _igvn.hash_delete(min_iff);
min_iff->set_req(CountedLoopEndNode::TestValue, new_bol1); min_iff->set_req(CountedLoopEndNode::TestValue, new_bol1);
// Modify main loop end condition // Modify main loop end condition
BoolNode* main_bol = main_end->in(CountedLoopEndNode::TestValue)->as_Bool(); BoolNode* main_bol = main_end->in(CountedLoopEndNode::TestValue)->as_Bool();
BoolNode* new_bol2 = new (C) BoolNode(main_bol->in(1), new_test); BoolNode* new_bol2 = new BoolNode(main_bol->in(1), new_test);
register_new_node( new_bol2, main_end->in(CountedLoopEndNode::TestControl) ); register_new_node( new_bol2, main_end->in(CountedLoopEndNode::TestControl) );
_igvn.hash_delete(main_end); _igvn.hash_delete(main_end);
main_end->set_req(CountedLoopEndNode::TestValue, new_bol2); main_end->set_req(CountedLoopEndNode::TestValue, new_bol2);
@ -1279,13 +1279,13 @@ void PhaseIdealLoop::do_unroll( IdealLoopTree *loop, Node_List &old_new, bool ad
// zero trip guard limit will be different from loop limit. // zero trip guard limit will be different from loop limit.
assert(has_ctrl(opaq), "should have it"); assert(has_ctrl(opaq), "should have it");
Node* opaq_ctrl = get_ctrl(opaq); Node* opaq_ctrl = get_ctrl(opaq);
limit = new (C) Opaque2Node( C, limit ); limit = new Opaque2Node( C, limit );
register_new_node( limit, opaq_ctrl ); register_new_node( limit, opaq_ctrl );
} }
if (stride_con > 0 && ((limit_type->_lo - stride_con) < limit_type->_lo) || if (stride_con > 0 && ((limit_type->_lo - stride_con) < limit_type->_lo) ||
stride_con < 0 && ((limit_type->_hi - stride_con) > limit_type->_hi)) { stride_con < 0 && ((limit_type->_hi - stride_con) > limit_type->_hi)) {
// No underflow. // No underflow.
new_limit = new (C) SubINode(limit, stride); new_limit = new SubINode(limit, stride);
} else { } else {
// (limit - stride) may underflow. // (limit - stride) may underflow.
// Clamp the adjustment value with MININT or MAXINT: // Clamp the adjustment value with MININT or MAXINT:
@ -1315,18 +1315,18 @@ void PhaseIdealLoop::do_unroll( IdealLoopTree *loop, Node_List &old_new, bool ad
old_limit = bol->in(1)->in(1); old_limit = bol->in(1)->in(1);
// Adjust previous adjusted limit. // Adjust previous adjusted limit.
adj_limit = limit->in(CMoveNode::IfFalse); adj_limit = limit->in(CMoveNode::IfFalse);
adj_limit = new (C) SubINode(adj_limit, stride); adj_limit = new SubINode(adj_limit, stride);
} else { } else {
old_limit = limit; old_limit = limit;
adj_limit = new (C) SubINode(limit, stride); adj_limit = new SubINode(limit, stride);
} }
assert(old_limit != NULL && adj_limit != NULL, ""); assert(old_limit != NULL && adj_limit != NULL, "");
register_new_node( adj_limit, ctrl ); // adjust amount register_new_node( adj_limit, ctrl ); // adjust amount
Node* adj_cmp = new (C) CmpINode(old_limit, adj_limit); Node* adj_cmp = new CmpINode(old_limit, adj_limit);
register_new_node( adj_cmp, ctrl ); register_new_node( adj_cmp, ctrl );
Node* adj_bool = new (C) BoolNode(adj_cmp, bt); Node* adj_bool = new BoolNode(adj_cmp, bt);
register_new_node( adj_bool, ctrl ); register_new_node( adj_bool, ctrl );
new_limit = new (C) CMoveINode(adj_bool, adj_limit, adj_max, TypeInt::INT); new_limit = new CMoveINode(adj_bool, adj_limit, adj_max, TypeInt::INT);
} }
register_new_node(new_limit, ctrl); register_new_node(new_limit, ctrl);
} }
@ -1388,24 +1388,24 @@ void PhaseIdealLoop::do_unroll( IdealLoopTree *loop, Node_List &old_new, bool ad
// CountedLoop this is exact (stride divides limit-init exactly). // CountedLoop this is exact (stride divides limit-init exactly).
// We are going to double the loop body, so we want to knock off any // We are going to double the loop body, so we want to knock off any
// odd iteration: (trip_cnt & ~1). Then back compute a new limit. // odd iteration: (trip_cnt & ~1). Then back compute a new limit.
Node *span = new (C) SubINode( limit, init ); Node *span = new SubINode( limit, init );
register_new_node( span, ctrl ); register_new_node( span, ctrl );
Node *trip = new (C) DivINode( 0, span, stride ); Node *trip = new DivINode( 0, span, stride );
register_new_node( trip, ctrl ); register_new_node( trip, ctrl );
Node *mtwo = _igvn.intcon(-2); Node *mtwo = _igvn.intcon(-2);
set_ctrl(mtwo, C->root()); set_ctrl(mtwo, C->root());
Node *rond = new (C) AndINode( trip, mtwo ); Node *rond = new AndINode( trip, mtwo );
register_new_node( rond, ctrl ); register_new_node( rond, ctrl );
Node *spn2 = new (C) MulINode( rond, stride ); Node *spn2 = new MulINode( rond, stride );
register_new_node( spn2, ctrl ); register_new_node( spn2, ctrl );
new_limit = new (C) AddINode( spn2, init ); new_limit = new AddINode( spn2, init );
register_new_node( new_limit, ctrl ); register_new_node( new_limit, ctrl );
// Hammer in the new limit // Hammer in the new limit
Node *ctrl2 = loop_end->in(0); Node *ctrl2 = loop_end->in(0);
Node *cmp2 = new (C) CmpINode( loop_head->incr(), new_limit ); Node *cmp2 = new CmpINode( loop_head->incr(), new_limit );
register_new_node( cmp2, ctrl2 ); register_new_node( cmp2, ctrl2 );
Node *bol2 = new (C) BoolNode( cmp2, loop_end->test_trip() ); Node *bol2 = new BoolNode( cmp2, loop_end->test_trip() );
register_new_node( bol2, ctrl2 ); register_new_node( bol2, ctrl2 );
_igvn.hash_delete(loop_end); _igvn.hash_delete(loop_end);
loop_end->set_req(CountedLoopEndNode::TestValue, bol2); loop_end->set_req(CountedLoopEndNode::TestValue, bol2);
@ -1511,15 +1511,15 @@ bool IdealLoopTree::dominates_backedge(Node* ctrl) {
// Helper function for add_constraint(). // Helper function for add_constraint().
Node* PhaseIdealLoop::adjust_limit(int stride_con, Node * scale, Node *offset, Node *rc_limit, Node *loop_limit, Node *pre_ctrl) { Node* PhaseIdealLoop::adjust_limit(int stride_con, Node * scale, Node *offset, Node *rc_limit, Node *loop_limit, Node *pre_ctrl) {
// Compute "I :: (limit-offset)/scale" // Compute "I :: (limit-offset)/scale"
Node *con = new (C) SubINode(rc_limit, offset); Node *con = new SubINode(rc_limit, offset);
register_new_node(con, pre_ctrl); register_new_node(con, pre_ctrl);
Node *X = new (C) DivINode(0, con, scale); Node *X = new DivINode(0, con, scale);
register_new_node(X, pre_ctrl); register_new_node(X, pre_ctrl);
// Adjust loop limit // Adjust loop limit
loop_limit = (stride_con > 0) loop_limit = (stride_con > 0)
? (Node*)(new (C) MinINode(loop_limit, X)) ? (Node*)(new MinINode(loop_limit, X))
: (Node*)(new (C) MaxINode(loop_limit, X)); : (Node*)(new MaxINode(loop_limit, X));
register_new_node(loop_limit, pre_ctrl); register_new_node(loop_limit, pre_ctrl);
return loop_limit; return loop_limit;
} }
@ -1580,9 +1580,9 @@ void PhaseIdealLoop::add_constraint( int stride_con, int scale_con, Node *offset
// to avoid problem with scale == -1 (min_int/(-1) == min_int). // to avoid problem with scale == -1 (min_int/(-1) == min_int).
Node* shift = _igvn.intcon(31); Node* shift = _igvn.intcon(31);
set_ctrl(shift, C->root()); set_ctrl(shift, C->root());
Node* sign = new (C) RShiftINode(offset, shift); Node* sign = new RShiftINode(offset, shift);
register_new_node(sign, pre_ctrl); register_new_node(sign, pre_ctrl);
offset = new (C) AndINode(offset, sign); offset = new AndINode(offset, sign);
register_new_node(offset, pre_ctrl); register_new_node(offset, pre_ctrl);
} else { } else {
assert(low_limit->get_int() == 0, "wrong low limit for range check"); assert(low_limit->get_int() == 0, "wrong low limit for range check");
@ -1615,7 +1615,7 @@ void PhaseIdealLoop::add_constraint( int stride_con, int scale_con, Node *offset
Node *one = _igvn.intcon(1); Node *one = _igvn.intcon(1);
set_ctrl(one, C->root()); set_ctrl(one, C->root());
Node *plus_one = new (C) AddINode(offset, one); Node *plus_one = new AddINode(offset, one);
register_new_node( plus_one, pre_ctrl ); register_new_node( plus_one, pre_ctrl );
// Pass (-stride) to indicate pre_loop_cond = NOT(main_loop_cond); // Pass (-stride) to indicate pre_loop_cond = NOT(main_loop_cond);
*pre_limit = adjust_limit((-stride_con), scale, plus_one, upper_limit, *pre_limit, pre_ctrl); *pre_limit = adjust_limit((-stride_con), scale, plus_one, upper_limit, *pre_limit, pre_ctrl);
@ -1633,9 +1633,9 @@ void PhaseIdealLoop::add_constraint( int stride_con, int scale_con, Node *offset
// to avoid problem with scale == -1 (min_int/(-1) == min_int). // to avoid problem with scale == -1 (min_int/(-1) == min_int).
Node* shift = _igvn.intcon(31); Node* shift = _igvn.intcon(31);
set_ctrl(shift, C->root()); set_ctrl(shift, C->root());
Node* sign = new (C) RShiftINode(plus_one, shift); Node* sign = new RShiftINode(plus_one, shift);
register_new_node(sign, pre_ctrl); register_new_node(sign, pre_ctrl);
plus_one = new (C) AndINode(plus_one, sign); plus_one = new AndINode(plus_one, sign);
register_new_node(plus_one, pre_ctrl); register_new_node(plus_one, pre_ctrl);
} else { } else {
assert(low_limit->get_int() == 0, "wrong low limit for range check"); assert(low_limit->get_int() == 0, "wrong low limit for range check");
@ -1718,7 +1718,7 @@ bool PhaseIdealLoop::is_scaled_iv_plus_offset(Node* exp, Node* iv, int* p_scale,
p_offset != NULL ? &offset2 : NULL, depth+1)) { p_offset != NULL ? &offset2 : NULL, depth+1)) {
if (p_offset != NULL) { if (p_offset != NULL) {
Node *ctrl_off2 = get_ctrl(offset2); Node *ctrl_off2 = get_ctrl(offset2);
Node* offset = new (C) AddINode(offset2, exp->in(2)); Node* offset = new AddINode(offset2, exp->in(2));
register_new_node(offset, ctrl_off2); register_new_node(offset, ctrl_off2);
*p_offset = offset; *p_offset = offset;
} }
@ -1731,7 +1731,7 @@ bool PhaseIdealLoop::is_scaled_iv_plus_offset(Node* exp, Node* iv, int* p_scale,
Node *zero = _igvn.intcon(0); Node *zero = _igvn.intcon(0);
set_ctrl(zero, C->root()); set_ctrl(zero, C->root());
Node *ctrl_off = get_ctrl(exp->in(2)); Node *ctrl_off = get_ctrl(exp->in(2));
Node* offset = new (C) SubINode(zero, exp->in(2)); Node* offset = new SubINode(zero, exp->in(2));
register_new_node(offset, ctrl_off); register_new_node(offset, ctrl_off);
*p_offset = offset; *p_offset = offset;
} }
@ -1934,15 +1934,15 @@ void PhaseIdealLoop::do_range_check( IdealLoopTree *loop, Node_List &old_new ) {
case BoolTest::ge: case BoolTest::ge:
// Convert (I*scale+offset) >= Limit to (I*(-scale)+(-offset)) <= -Limit // Convert (I*scale+offset) >= Limit to (I*(-scale)+(-offset)) <= -Limit
scale_con = -scale_con; scale_con = -scale_con;
offset = new (C) SubINode( zero, offset ); offset = new SubINode( zero, offset );
register_new_node( offset, pre_ctrl ); register_new_node( offset, pre_ctrl );
limit = new (C) SubINode( zero, limit ); limit = new SubINode( zero, limit );
register_new_node( limit, pre_ctrl ); register_new_node( limit, pre_ctrl );
// Fall into LE case // Fall into LE case
case BoolTest::le: case BoolTest::le:
if (b_test._test != BoolTest::gt) { if (b_test._test != BoolTest::gt) {
// Convert X <= Y to X < Y+1 // Convert X <= Y to X < Y+1
limit = new (C) AddINode( limit, one ); limit = new AddINode( limit, one );
register_new_node( limit, pre_ctrl ); register_new_node( limit, pre_ctrl );
} }
// Fall into LT case // Fall into LT case
@ -1993,8 +1993,8 @@ void PhaseIdealLoop::do_range_check( IdealLoopTree *loop, Node_List &old_new ) {
// Update loop limits // Update loop limits
if (conditional_rc) { if (conditional_rc) {
pre_limit = (stride_con > 0) ? (Node*)new (C) MinINode(pre_limit, orig_limit) pre_limit = (stride_con > 0) ? (Node*)new MinINode(pre_limit, orig_limit)
: (Node*)new (C) MaxINode(pre_limit, orig_limit); : (Node*)new MaxINode(pre_limit, orig_limit);
register_new_node(pre_limit, pre_ctrl); register_new_node(pre_limit, pre_ctrl);
} }
_igvn.hash_delete(pre_opaq); _igvn.hash_delete(pre_opaq);
@ -2009,16 +2009,16 @@ void PhaseIdealLoop::do_range_check( IdealLoopTree *loop, Node_List &old_new ) {
Node *ctrl = get_ctrl(main_limit); Node *ctrl = get_ctrl(main_limit);
Node *stride = cl->stride(); Node *stride = cl->stride();
Node *init = cl->init_trip(); Node *init = cl->init_trip();
Node *span = new (C) SubINode(main_limit,init); Node *span = new SubINode(main_limit,init);
register_new_node(span,ctrl); register_new_node(span,ctrl);
Node *rndup = _igvn.intcon(stride_con + ((stride_con>0)?-1:1)); Node *rndup = _igvn.intcon(stride_con + ((stride_con>0)?-1:1));
Node *add = new (C) AddINode(span,rndup); Node *add = new AddINode(span,rndup);
register_new_node(add,ctrl); register_new_node(add,ctrl);
Node *div = new (C) DivINode(0,add,stride); Node *div = new DivINode(0,add,stride);
register_new_node(div,ctrl); register_new_node(div,ctrl);
Node *mul = new (C) MulINode(div,stride); Node *mul = new MulINode(div,stride);
register_new_node(mul,ctrl); register_new_node(mul,ctrl);
Node *newlim = new (C) AddINode(mul,init); Node *newlim = new AddINode(mul,init);
register_new_node(newlim,ctrl); register_new_node(newlim,ctrl);
main_limit = newlim; main_limit = newlim;
} }
@ -2189,7 +2189,7 @@ bool IdealLoopTree::policy_do_remove_empty_loop( PhaseIdealLoop *phase ) {
} }
// Note: the final value after increment should not overflow since // Note: the final value after increment should not overflow since
// counted loop has limit check predicate. // counted loop has limit check predicate.
Node *final = new (phase->C) SubINode( exact_limit, cl->stride() ); Node *final = new SubINode( exact_limit, cl->stride() );
phase->register_new_node(final,cl->in(LoopNode::EntryControl)); phase->register_new_node(final,cl->in(LoopNode::EntryControl));
phase->_igvn.replace_node(phi,final); phase->_igvn.replace_node(phi,final);
phase->C->set_major_progress(); phase->C->set_major_progress();
@ -2676,20 +2676,20 @@ bool PhaseIdealLoop::intrinsify_fill(IdealLoopTree* lpt) {
// Build an expression for the beginning of the copy region // Build an expression for the beginning of the copy region
Node* index = head->init_trip(); Node* index = head->init_trip();
#ifdef _LP64 #ifdef _LP64
index = new (C) ConvI2LNode(index); index = new ConvI2LNode(index);
_igvn.register_new_node_with_optimizer(index); _igvn.register_new_node_with_optimizer(index);
#endif #endif
if (shift != NULL) { if (shift != NULL) {
// byte arrays don't require a shift but others do. // byte arrays don't require a shift but others do.
index = new (C) LShiftXNode(index, shift->in(2)); index = new LShiftXNode(index, shift->in(2));
_igvn.register_new_node_with_optimizer(index); _igvn.register_new_node_with_optimizer(index);
} }
index = new (C) AddPNode(base, base, index); index = new AddPNode(base, base, index);
_igvn.register_new_node_with_optimizer(index); _igvn.register_new_node_with_optimizer(index);
Node* from = new (C) AddPNode(base, index, offset); Node* from = new AddPNode(base, index, offset);
_igvn.register_new_node_with_optimizer(from); _igvn.register_new_node_with_optimizer(from);
// Compute the number of elements to copy // Compute the number of elements to copy
Node* len = new (C) SubINode(head->limit(), head->init_trip()); Node* len = new SubINode(head->limit(), head->init_trip());
_igvn.register_new_node_with_optimizer(len); _igvn.register_new_node_with_optimizer(len);
BasicType t = store->as_Mem()->memory_type(); BasicType t = store->as_Mem()->memory_type();
@ -2706,17 +2706,17 @@ bool PhaseIdealLoop::intrinsify_fill(IdealLoopTree* lpt) {
// Convert float/double to int/long for fill routines // Convert float/double to int/long for fill routines
if (t == T_FLOAT) { if (t == T_FLOAT) {
store_value = new (C) MoveF2INode(store_value); store_value = new MoveF2INode(store_value);
_igvn.register_new_node_with_optimizer(store_value); _igvn.register_new_node_with_optimizer(store_value);
} else if (t == T_DOUBLE) { } else if (t == T_DOUBLE) {
store_value = new (C) MoveD2LNode(store_value); store_value = new MoveD2LNode(store_value);
_igvn.register_new_node_with_optimizer(store_value); _igvn.register_new_node_with_optimizer(store_value);
} }
if (CCallingConventionRequiresIntsAsLongs && if (CCallingConventionRequiresIntsAsLongs &&
// See StubRoutines::select_fill_function for types. FLOAT has been converted to INT. // See StubRoutines::select_fill_function for types. FLOAT has been converted to INT.
(t == T_FLOAT || t == T_INT || is_subword_type(t))) { (t == T_FLOAT || t == T_INT || is_subword_type(t))) {
store_value = new (C) ConvI2LNode(store_value); store_value = new ConvI2LNode(store_value);
_igvn.register_new_node_with_optimizer(store_value); _igvn.register_new_node_with_optimizer(store_value);
} }
@ -2724,8 +2724,8 @@ bool PhaseIdealLoop::intrinsify_fill(IdealLoopTree* lpt) {
Node* result_ctrl; Node* result_ctrl;
Node* result_mem; Node* result_mem;
const TypeFunc* call_type = OptoRuntime::array_fill_Type(); const TypeFunc* call_type = OptoRuntime::array_fill_Type();
CallLeafNode *call = new (C) CallLeafNoFPNode(call_type, fill, CallLeafNode *call = new CallLeafNoFPNode(call_type, fill,
fill_name, TypeAryPtr::get_array_body_type(t)); fill_name, TypeAryPtr::get_array_body_type(t));
uint cnt = 0; uint cnt = 0;
call->init_req(TypeFunc::Parms + cnt++, from); call->init_req(TypeFunc::Parms + cnt++, from);
call->init_req(TypeFunc::Parms + cnt++, store_value); call->init_req(TypeFunc::Parms + cnt++, store_value);
@ -2733,7 +2733,7 @@ bool PhaseIdealLoop::intrinsify_fill(IdealLoopTree* lpt) {
call->init_req(TypeFunc::Parms + cnt++, C->top()); call->init_req(TypeFunc::Parms + cnt++, C->top());
} }
#ifdef _LP64 #ifdef _LP64
len = new (C) ConvI2LNode(len); len = new ConvI2LNode(len);
_igvn.register_new_node_with_optimizer(len); _igvn.register_new_node_with_optimizer(len);
#endif #endif
call->init_req(TypeFunc::Parms + cnt++, len); call->init_req(TypeFunc::Parms + cnt++, len);
@ -2746,9 +2746,9 @@ bool PhaseIdealLoop::intrinsify_fill(IdealLoopTree* lpt) {
call->init_req(TypeFunc::ReturnAdr, C->start()->proj_out(TypeFunc::ReturnAdr)); call->init_req(TypeFunc::ReturnAdr, C->start()->proj_out(TypeFunc::ReturnAdr));
call->init_req(TypeFunc::FramePtr, C->start()->proj_out(TypeFunc::FramePtr)); call->init_req(TypeFunc::FramePtr, C->start()->proj_out(TypeFunc::FramePtr));
_igvn.register_new_node_with_optimizer(call); _igvn.register_new_node_with_optimizer(call);
result_ctrl = new (C) ProjNode(call,TypeFunc::Control); result_ctrl = new ProjNode(call,TypeFunc::Control);
_igvn.register_new_node_with_optimizer(result_ctrl); _igvn.register_new_node_with_optimizer(result_ctrl);
result_mem = new (C) ProjNode(call,TypeFunc::Memory); result_mem = new ProjNode(call,TypeFunc::Memory);
_igvn.register_new_node_with_optimizer(result_mem); _igvn.register_new_node_with_optimizer(result_mem);
/* Disable following optimization until proper fix (add missing checks). /* Disable following optimization until proper fix (add missing checks).

10
hotspot/src/share/vm/opto/loopUnswitch.cpp
View file

@ -225,15 +225,15 @@ ProjNode* PhaseIdealLoop::create_slow_version_of_loop(IdealLoopTree *loop,
Node *cont = _igvn.intcon(1); Node *cont = _igvn.intcon(1);
set_ctrl(cont, C->root()); set_ctrl(cont, C->root());
Node* opq = new (C) Opaque1Node(C, cont); Node* opq = new Opaque1Node(C, cont);
register_node(opq, outer_loop, entry, dom_depth(entry)); register_node(opq, outer_loop, entry, dom_depth(entry));
Node *bol = new (C) Conv2BNode(opq); Node *bol = new Conv2BNode(opq);
register_node(bol, outer_loop, entry, dom_depth(entry)); register_node(bol, outer_loop, entry, dom_depth(entry));
IfNode* iff = new (C) IfNode(entry, bol, PROB_MAX, COUNT_UNKNOWN); IfNode* iff = new IfNode(entry, bol, PROB_MAX, COUNT_UNKNOWN);
register_node(iff, outer_loop, entry, dom_depth(entry)); register_node(iff, outer_loop, entry, dom_depth(entry));
ProjNode* iffast = new (C) IfTrueNode(iff); ProjNode* iffast = new IfTrueNode(iff);
register_node(iffast, outer_loop, iff, dom_depth(iff)); register_node(iffast, outer_loop, iff, dom_depth(iff));
ProjNode* ifslow = new (C) IfFalseNode(iff); ProjNode* ifslow = new IfFalseNode(iff);
register_node(ifslow, outer_loop, iff, dom_depth(iff)); register_node(ifslow, outer_loop, iff, dom_depth(iff));
// Clone the loop body. The clone becomes the fast loop. The // Clone the loop body. The clone becomes the fast loop. The

110
hotspot/src/share/vm/opto/loopnode.cpp
View file

@ -443,7 +443,7 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
assert(x->Opcode() == Op_Loop, "regular loops only"); assert(x->Opcode() == Op_Loop, "regular loops only");
C->print_method(PHASE_BEFORE_CLOOPS, 3); C->print_method(PHASE_BEFORE_CLOOPS, 3);
Node *hook = new (C) Node(6); Node *hook = new Node(6);
if (LoopLimitCheck) { if (LoopLimitCheck) {
@ -506,11 +506,11 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
Node* bol; Node* bol;
if (stride_con > 0) { if (stride_con > 0) {
cmp_limit = new (C) CmpINode(limit, _igvn.intcon(max_jint - stride_m)); cmp_limit = new CmpINode(limit, _igvn.intcon(max_jint - stride_m));
bol = new (C) BoolNode(cmp_limit, BoolTest::le); bol = new BoolNode(cmp_limit, BoolTest::le);
} else { } else {
cmp_limit = new (C) CmpINode(limit, _igvn.intcon(min_jint - stride_m)); cmp_limit = new CmpINode(limit, _igvn.intcon(min_jint - stride_m));
bol = new (C) BoolNode(cmp_limit, BoolTest::ge); bol = new BoolNode(cmp_limit, BoolTest::ge);
} }
cmp_limit = _igvn.register_new_node_with_optimizer(cmp_limit); cmp_limit = _igvn.register_new_node_with_optimizer(cmp_limit);
bol = _igvn.register_new_node_with_optimizer(bol); bol = _igvn.register_new_node_with_optimizer(bol);
@ -547,7 +547,7 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
// is converted to // is converted to
// i = init; do {} while(++i < limit+1); // i = init; do {} while(++i < limit+1);
// //
limit = gvn->transform(new (C) AddINode(limit, stride)); limit = gvn->transform(new AddINode(limit, stride));
} }
// Now we need to canonicalize loop condition. // Now we need to canonicalize loop condition.
@ -566,7 +566,7 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
// we can convert 'i <= limit' to 'i < limit+1' since stride != 0. // we can convert 'i <= limit' to 'i < limit+1' since stride != 0.
// //
Node* one = (stride_con > 0) ? gvn->intcon( 1) : gvn->intcon(-1); Node* one = (stride_con > 0) ? gvn->intcon( 1) : gvn->intcon(-1);
limit = gvn->transform(new (C) AddINode(limit, one)); limit = gvn->transform(new AddINode(limit, one));
if (bt == BoolTest::le) if (bt == BoolTest::le)
bt = BoolTest::lt; bt = BoolTest::lt;
else if (bt == BoolTest::ge) else if (bt == BoolTest::ge)
@ -582,7 +582,7 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
// can directly point to the phi; in this case adjust the compare so that // can directly point to the phi; in this case adjust the compare so that
// it points to the incr by adjusting the limit. // it points to the incr by adjusting the limit.
if (cmp->in(1) == phi || cmp->in(2) == phi) if (cmp->in(1) == phi || cmp->in(2) == phi)
limit = gvn->transform(new (C) AddINode(limit,stride)); limit = gvn->transform(new AddINode(limit,stride));
// trip-count for +-tive stride should be: (limit - init_trip + stride - 1)/stride. // trip-count for +-tive stride should be: (limit - init_trip + stride - 1)/stride.
// Final value for iterator should be: trip_count * stride + init_trip. // Final value for iterator should be: trip_count * stride + init_trip.
@ -595,16 +595,16 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
ShouldNotReachHere(); ShouldNotReachHere();
case BoolTest::ne: // Ahh, the case we desire case BoolTest::ne: // Ahh, the case we desire
if (stride_con == 1) if (stride_con == 1)
trip_count = gvn->transform(new (C) SubINode(limit,init_trip)); trip_count = gvn->transform(new SubINode(limit,init_trip));
else if (stride_con == -1) else if (stride_con == -1)
trip_count = gvn->transform(new (C) SubINode(init_trip,limit)); trip_count = gvn->transform(new SubINode(init_trip,limit));
else else
ShouldNotReachHere(); ShouldNotReachHere();
set_subtree_ctrl(trip_count); set_subtree_ctrl(trip_count);
//_loop.map(trip_count->_idx,loop(limit)); //_loop.map(trip_count->_idx,loop(limit));
break; break;
case BoolTest::le: // Maybe convert to '<' case case BoolTest::le: // Maybe convert to '<' case
limit = gvn->transform(new (C) AddINode(limit,one_p)); limit = gvn->transform(new AddINode(limit,one_p));
set_subtree_ctrl( limit ); set_subtree_ctrl( limit );
hook->init_req(4, limit); hook->init_req(4, limit);
@ -615,26 +615,26 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
case BoolTest::lt: { // Maybe convert to '!=' case case BoolTest::lt: { // Maybe convert to '!=' case
if (stride_con < 0) // Count down loop rolls through MAXINT if (stride_con < 0) // Count down loop rolls through MAXINT
ShouldNotReachHere(); ShouldNotReachHere();
Node *range = gvn->transform(new (C) SubINode(limit,init_trip)); Node *range = gvn->transform(new SubINode(limit,init_trip));
set_subtree_ctrl( range ); set_subtree_ctrl( range );
hook->init_req(0, range); hook->init_req(0, range);
Node *bias = gvn->transform(new (C) AddINode(range,stride)); Node *bias = gvn->transform(new AddINode(range,stride));
set_subtree_ctrl( bias ); set_subtree_ctrl( bias );
hook->init_req(1, bias); hook->init_req(1, bias);
Node *bias1 = gvn->transform(new (C) AddINode(bias,one_m)); Node *bias1 = gvn->transform(new AddINode(bias,one_m));
set_subtree_ctrl( bias1 ); set_subtree_ctrl( bias1 );
hook->init_req(2, bias1); hook->init_req(2, bias1);
trip_count = gvn->transform(new (C) DivINode(0,bias1,stride)); trip_count = gvn->transform(new DivINode(0,bias1,stride));
set_subtree_ctrl( trip_count ); set_subtree_ctrl( trip_count );
hook->init_req(3, trip_count); hook->init_req(3, trip_count);
break; break;
} }
case BoolTest::ge: // Maybe convert to '>' case case BoolTest::ge: // Maybe convert to '>' case
limit = gvn->transform(new (C) AddINode(limit,one_m)); limit = gvn->transform(new AddINode(limit,one_m));
set_subtree_ctrl( limit ); set_subtree_ctrl( limit );
hook->init_req(4 ,limit); hook->init_req(4 ,limit);
@ -645,30 +645,30 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
case BoolTest::gt: { // Maybe convert to '!=' case case BoolTest::gt: { // Maybe convert to '!=' case
if (stride_con > 0) // count up loop rolls through MININT if (stride_con > 0) // count up loop rolls through MININT
ShouldNotReachHere(); ShouldNotReachHere();
Node *range = gvn->transform(new (C) SubINode(limit,init_trip)); Node *range = gvn->transform(new SubINode(limit,init_trip));
set_subtree_ctrl( range ); set_subtree_ctrl( range );
hook->init_req(0, range); hook->init_req(0, range);
Node *bias = gvn->transform(new (C) AddINode(range,stride)); Node *bias = gvn->transform(new AddINode(range,stride));
set_subtree_ctrl( bias ); set_subtree_ctrl( bias );
hook->init_req(1, bias); hook->init_req(1, bias);
Node *bias1 = gvn->transform(new (C) AddINode(bias,one_p)); Node *bias1 = gvn->transform(new AddINode(bias,one_p));
set_subtree_ctrl( bias1 ); set_subtree_ctrl( bias1 );
hook->init_req(2, bias1); hook->init_req(2, bias1);
trip_count = gvn->transform(new (C) DivINode(0,bias1,stride)); trip_count = gvn->transform(new DivINode(0,bias1,stride));
set_subtree_ctrl( trip_count ); set_subtree_ctrl( trip_count );
hook->init_req(3, trip_count); hook->init_req(3, trip_count);
break; break;
} }
} // switch( bt ) } // switch( bt )
Node *span = gvn->transform(new (C) MulINode(trip_count,stride)); Node *span = gvn->transform(new MulINode(trip_count,stride));
set_subtree_ctrl( span ); set_subtree_ctrl( span );
hook->init_req(5, span); hook->init_req(5, span);
limit = gvn->transform(new (C) AddINode(span,init_trip)); limit = gvn->transform(new AddINode(span,init_trip));
set_subtree_ctrl( limit ); set_subtree_ctrl( limit );
} // LoopLimitCheck } // LoopLimitCheck
@ -717,7 +717,7 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
set_ctrl(test, iff->in(0)); set_ctrl(test, iff->in(0));
// Replace the old IfNode with a new LoopEndNode // Replace the old IfNode with a new LoopEndNode
Node *lex = _igvn.register_new_node_with_optimizer(new (C) CountedLoopEndNode( iff->in(0), test, cl_prob, iff->as_If()->_fcnt )); Node *lex = _igvn.register_new_node_with_optimizer(new CountedLoopEndNode( iff->in(0), test, cl_prob, iff->as_If()->_fcnt ));
IfNode *le = lex->as_If(); IfNode *le = lex->as_If();
uint dd = dom_depth(iff); uint dd = dom_depth(iff);
set_idom(le, le->in(0), dd); // Update dominance for loop exit set_idom(le, le->in(0), dd); // Update dominance for loop exit
@ -728,8 +728,8 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
// Need to swap loop-exit and loop-back control? // Need to swap loop-exit and loop-back control?
if (iftrue_op == Op_IfFalse) { if (iftrue_op == Op_IfFalse) {
Node *ift2=_igvn.register_new_node_with_optimizer(new (C) IfTrueNode (le)); Node *ift2=_igvn.register_new_node_with_optimizer(new IfTrueNode (le));
Node *iff2=_igvn.register_new_node_with_optimizer(new (C) IfFalseNode(le)); Node *iff2=_igvn.register_new_node_with_optimizer(new IfFalseNode(le));
loop->_tail = back_control = ift2; loop->_tail = back_control = ift2;
set_loop(ift2, loop); set_loop(ift2, loop);
@ -755,7 +755,7 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
lazy_replace( iff, le ); // fix 'get_ctrl' lazy_replace( iff, le ); // fix 'get_ctrl'
// Now setup a new CountedLoopNode to replace the existing LoopNode // Now setup a new CountedLoopNode to replace the existing LoopNode
CountedLoopNode *l = new (C) CountedLoopNode(init_control, back_control); CountedLoopNode *l = new CountedLoopNode(init_control, back_control);
l->set_unswitch_count(x->as_Loop()->unswitch_count()); // Preserve l->set_unswitch_count(x->as_Loop()->unswitch_count()); // Preserve
// The following assert is approximately true, and defines the intention // The following assert is approximately true, and defines the intention
// of can_be_counted_loop. It fails, however, because phase->type // of can_be_counted_loop. It fails, however, because phase->type
@ -829,7 +829,7 @@ Node* PhaseIdealLoop::exact_limit( IdealLoopTree *loop ) {
limit = _igvn.intcon(final_int); limit = _igvn.intcon(final_int);
} else { } else {
// Create new LoopLimit node to get exact limit (final iv value). // Create new LoopLimit node to get exact limit (final iv value).
limit = new (C) LoopLimitNode(C, cl->init_trip(), cl->limit(), cl->stride()); limit = new LoopLimitNode(C, cl->init_trip(), cl->limit(), cl->stride());
register_new_node(limit, cl->in(LoopNode::EntryControl)); register_new_node(limit, cl->in(LoopNode::EntryControl));
} }
assert(limit != NULL, "sanity"); assert(limit != NULL, "sanity");
@ -946,11 +946,11 @@ Node *LoopLimitNode::Ideal(PhaseGVN *phase, bool can_reshape) {
if (range <= max) { if (range <= max) {
// Convert to integer expression if it is not overflow. // Convert to integer expression if it is not overflow.
Node* stride_m = phase->intcon(stride_con - (stride_con > 0 ? 1 : -1)); Node* stride_m = phase->intcon(stride_con - (stride_con > 0 ? 1 : -1));
Node *range = phase->transform(new (phase->C) SubINode(in(Limit), in(Init))); Node *range = phase->transform(new SubINode(in(Limit), in(Init)));
Node *bias = phase->transform(new (phase->C) AddINode(range, stride_m)); Node *bias = phase->transform(new AddINode(range, stride_m));
Node *trip = phase->transform(new (phase->C) DivINode(0, bias, in(Stride))); Node *trip = phase->transform(new DivINode(0, bias, in(Stride)));
Node *span = phase->transform(new (phase->C) MulINode(trip, in(Stride))); Node *span = phase->transform(new MulINode(trip, in(Stride)));
return new (phase->C) AddINode(span, in(Init)); // exact limit return new AddINode(span, in(Init)); // exact limit
} }
if (is_power_of_2(stride_p) || // divisor is 2^n if (is_power_of_2(stride_p) || // divisor is 2^n
@ -958,13 +958,13 @@ Node *LoopLimitNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// Convert to long expression to avoid integer overflow // Convert to long expression to avoid integer overflow
// and let igvn optimizer convert this division. // and let igvn optimizer convert this division.
// //
Node* init = phase->transform( new (phase->C) ConvI2LNode(in(Init))); Node* init = phase->transform( new ConvI2LNode(in(Init)));
Node* limit = phase->transform( new (phase->C) ConvI2LNode(in(Limit))); Node* limit = phase->transform( new ConvI2LNode(in(Limit)));
Node* stride = phase->longcon(stride_con); Node* stride = phase->longcon(stride_con);
Node* stride_m = phase->longcon(stride_con - (stride_con > 0 ? 1 : -1)); Node* stride_m = phase->longcon(stride_con - (stride_con > 0 ? 1 : -1));
Node *range = phase->transform(new (phase->C) SubLNode(limit, init)); Node *range = phase->transform(new SubLNode(limit, init));
Node *bias = phase->transform(new (phase->C) AddLNode(range, stride_m)); Node *bias = phase->transform(new AddLNode(range, stride_m));
Node *span; Node *span;
if (stride_con > 0 && is_power_of_2(stride_p)) { if (stride_con > 0 && is_power_of_2(stride_p)) {
// bias >= 0 if stride >0, so if stride is 2^n we can use &(-stride) // bias >= 0 if stride >0, so if stride is 2^n we can use &(-stride)
@ -975,14 +975,14 @@ Node *LoopLimitNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// only RCE predicate where exact limit is used and the predicate // only RCE predicate where exact limit is used and the predicate
// will simply fail forcing recompilation. // will simply fail forcing recompilation.
Node* neg_stride = phase->longcon(-stride_con); Node* neg_stride = phase->longcon(-stride_con);
span = phase->transform(new (phase->C) AndLNode(bias, neg_stride)); span = phase->transform(new AndLNode(bias, neg_stride));
} else { } else {
Node *trip = phase->transform(new (phase->C) DivLNode(0, bias, stride)); Node *trip = phase->transform(new DivLNode(0, bias, stride));
span = phase->transform(new (phase->C) MulLNode(trip, stride)); span = phase->transform(new MulLNode(trip, stride));
} }
// Convert back to int // Convert back to int
Node *span_int = phase->transform(new (phase->C) ConvL2INode(span)); Node *span_int = phase->transform(new ConvL2INode(span));
return new (phase->C) AddINode(span_int, in(Init)); // exact limit return new AddINode(span_int, in(Init)); // exact limit
} }
return NULL; // No progress return NULL; // No progress
@ -1188,7 +1188,7 @@ void IdealLoopTree::split_fall_in( PhaseIdealLoop *phase, int fall_in_cnt ) {
uint i; uint i;
// Make a new RegionNode to be the landing pad. // Make a new RegionNode to be the landing pad.
Node *landing_pad = new (phase->C) RegionNode( fall_in_cnt+1 ); Node *landing_pad = new RegionNode( fall_in_cnt+1 );
phase->set_loop(landing_pad,_parent); phase->set_loop(landing_pad,_parent);
// Gather all the fall-in control paths into the landing pad // Gather all the fall-in control paths into the landing pad
uint icnt = fall_in_cnt; uint icnt = fall_in_cnt;
@ -1274,7 +1274,7 @@ void IdealLoopTree::split_outer_loop( PhaseIdealLoop *phase ) {
// Make a LoopNode for the outermost loop. // Make a LoopNode for the outermost loop.
Node *ctl = _head->in(LoopNode::EntryControl); Node *ctl = _head->in(LoopNode::EntryControl);
Node *outer = new (phase->C) LoopNode( ctl, _head->in(outer_idx) ); Node *outer = new LoopNode( ctl, _head->in(outer_idx) );
outer = igvn.register_new_node_with_optimizer(outer, _head); outer = igvn.register_new_node_with_optimizer(outer, _head);
phase->set_created_loop_node(); phase->set_created_loop_node();
@ -1388,7 +1388,7 @@ void IdealLoopTree::merge_many_backedges( PhaseIdealLoop *phase ) {
Node *hot_tail = NULL; Node *hot_tail = NULL;
// Make a Region for the merge point // Make a Region for the merge point
Node *r = new (phase->C) RegionNode(1); Node *r = new RegionNode(1);
for( i = 2; i < _head->req(); i++ ) { for( i = 2; i < _head->req(); i++ ) {
if( i != hot_idx ) if( i != hot_idx )
r->add_req( _head->in(i) ); r->add_req( _head->in(i) );
@ -1407,7 +1407,7 @@ void IdealLoopTree::merge_many_backedges( PhaseIdealLoop *phase ) {
PhiNode* n = out->as_Phi(); PhiNode* n = out->as_Phi();
igvn.hash_delete(n); // Delete from hash before hacking edges igvn.hash_delete(n); // Delete from hash before hacking edges
Node *hot_phi = NULL; Node *hot_phi = NULL;
Node *phi = new (phase->C) PhiNode(r, n->type(), n->adr_type()); Node *phi = new PhiNode(r, n->type(), n->adr_type());
// Check all inputs for the ones to peel out // Check all inputs for the ones to peel out
uint j = 1; uint j = 1;
for( uint i = 2; i < n->req(); i++ ) { for( uint i = 2; i < n->req(); i++ ) {
@ -1529,7 +1529,7 @@ bool IdealLoopTree::beautify_loops( PhaseIdealLoop *phase ) {
} else if (!_head->is_Loop() && !_irreducible) { } else if (!_head->is_Loop() && !_irreducible) {
// Make a new LoopNode to replace the old loop head // Make a new LoopNode to replace the old loop head
Node *l = new (phase->C) LoopNode( _head->in(1), _head->in(2) ); Node *l = new LoopNode( _head->in(1), _head->in(2) );
l = igvn.register_new_node_with_optimizer(l, _head); l = igvn.register_new_node_with_optimizer(l, _head);
phase->set_created_loop_node(); phase->set_created_loop_node();
// Go ahead and replace _head // Go ahead and replace _head
@ -1771,16 +1771,16 @@ void PhaseIdealLoop::replace_parallel_iv(IdealLoopTree *loop) {
// It is scaled by the 'ratio_con'. // It is scaled by the 'ratio_con'.
Node* ratio = _igvn.intcon(ratio_con); Node* ratio = _igvn.intcon(ratio_con);
set_ctrl(ratio, C->root()); set_ctrl(ratio, C->root());
Node* ratio_init = new (C) MulINode(init, ratio); Node* ratio_init = new MulINode(init, ratio);
_igvn.register_new_node_with_optimizer(ratio_init, init); _igvn.register_new_node_with_optimizer(ratio_init, init);
set_early_ctrl(ratio_init); set_early_ctrl(ratio_init);
Node* diff = new (C) SubINode(init2, ratio_init); Node* diff = new SubINode(init2, ratio_init);
_igvn.register_new_node_with_optimizer(diff, init2); _igvn.register_new_node_with_optimizer(diff, init2);
set_early_ctrl(diff); set_early_ctrl(diff);
Node* ratio_idx = new (C) MulINode(phi, ratio); Node* ratio_idx = new MulINode(phi, ratio);
_igvn.register_new_node_with_optimizer(ratio_idx, phi); _igvn.register_new_node_with_optimizer(ratio_idx, phi);
set_ctrl(ratio_idx, cl); set_ctrl(ratio_idx, cl);
Node* add = new (C) AddINode(ratio_idx, diff); Node* add = new AddINode(ratio_idx, diff);
_igvn.register_new_node_with_optimizer(add); _igvn.register_new_node_with_optimizer(add);
set_ctrl(add, cl); set_ctrl(add, cl);
_igvn.replace_node( phi2, add ); _igvn.replace_node( phi2, add );
@ -2888,10 +2888,10 @@ int PhaseIdealLoop::build_loop_tree_impl( Node *n, int pre_order ) {
if (!_verify_only) { if (!_verify_only) {
// Insert the NeverBranch between 'm' and it's control user. // Insert the NeverBranch between 'm' and it's control user.
NeverBranchNode *iff = new (C) NeverBranchNode( m ); NeverBranchNode *iff = new NeverBranchNode( m );
_igvn.register_new_node_with_optimizer(iff); _igvn.register_new_node_with_optimizer(iff);
set_loop(iff, l); set_loop(iff, l);
Node *if_t = new (C) CProjNode( iff, 0 ); Node *if_t = new CProjNode( iff, 0 );
_igvn.register_new_node_with_optimizer(if_t); _igvn.register_new_node_with_optimizer(if_t);
set_loop(if_t, l); set_loop(if_t, l);
@ -2907,16 +2907,16 @@ int PhaseIdealLoop::build_loop_tree_impl( Node *n, int pre_order ) {
cfg->set_req( k, if_t ); // Now point to NeverBranch cfg->set_req( k, if_t ); // Now point to NeverBranch
// Now create the never-taken loop exit // Now create the never-taken loop exit
Node *if_f = new (C) CProjNode( iff, 1 ); Node *if_f = new CProjNode( iff, 1 );
_igvn.register_new_node_with_optimizer(if_f); _igvn.register_new_node_with_optimizer(if_f);
set_loop(if_f, l); set_loop(if_f, l);
// Find frame ptr for Halt. Relies on the optimizer // Find frame ptr for Halt. Relies on the optimizer
// V-N'ing. Easier and quicker than searching through // V-N'ing. Easier and quicker than searching through
// the program structure. // the program structure.
Node *frame = new (C) ParmNode( C->start(), TypeFunc::FramePtr ); Node *frame = new ParmNode( C->start(), TypeFunc::FramePtr );
_igvn.register_new_node_with_optimizer(frame); _igvn.register_new_node_with_optimizer(frame);
// Halt & Catch Fire // Halt & Catch Fire
Node *halt = new (C) HaltNode( if_f, frame ); Node *halt = new HaltNode( if_f, frame );
_igvn.register_new_node_with_optimizer(halt); _igvn.register_new_node_with_optimizer(halt);
set_loop(halt, l); set_loop(halt, l);
C->root()->add_req(halt); C->root()->add_req(halt);

46
hotspot/src/share/vm/opto/loopopts.cpp
View file

@ -56,7 +56,7 @@ Node *PhaseIdealLoop::split_thru_phi( Node *n, Node *region, int policy ) {
int iid = t_oop->instance_id(); int iid = t_oop->instance_id();
int index = C->get_alias_index(t_oop); int index = C->get_alias_index(t_oop);
int offset = t_oop->offset(); int offset = t_oop->offset();
phi = new (C) PhiNode(region, type, NULL, iid, index, offset); phi = new PhiNode(region, type, NULL, iid, index, offset);
} else { } else {
phi = PhiNode::make_blank(region, n); phi = PhiNode::make_blank(region, n);
} }
@ -363,9 +363,9 @@ Node *PhaseIdealLoop::remix_address_expressions( Node *n ) {
_igvn.type( add->in(1) ) != TypeInt::ZERO ) { _igvn.type( add->in(1) ) != TypeInt::ZERO ) {
Node *zero = _igvn.intcon(0); Node *zero = _igvn.intcon(0);
set_ctrl(zero, C->root()); set_ctrl(zero, C->root());
Node *neg = new (C) SubINode( _igvn.intcon(0), add->in(2) ); Node *neg = new SubINode( _igvn.intcon(0), add->in(2) );
register_new_node( neg, get_ctrl(add->in(2) ) ); register_new_node( neg, get_ctrl(add->in(2) ) );
add = new (C) AddINode( add->in(1), neg ); add = new AddINode( add->in(1), neg );
register_new_node( add, add_ctrl ); register_new_node( add, add_ctrl );
} }
if( add->Opcode() != Op_AddI ) return NULL; if( add->Opcode() != Op_AddI ) return NULL;
@ -391,14 +391,14 @@ Node *PhaseIdealLoop::remix_address_expressions( Node *n ) {
return NULL; // No invariant part of the add? return NULL; // No invariant part of the add?
// Yes! Reshape address expression! // Yes! Reshape address expression!
Node *inv_scale = new (C) LShiftINode( add_invar, scale ); Node *inv_scale = new LShiftINode( add_invar, scale );
Node *inv_scale_ctrl = Node *inv_scale_ctrl =
dom_depth(add_invar_ctrl) > dom_depth(scale_ctrl) ? dom_depth(add_invar_ctrl) > dom_depth(scale_ctrl) ?
add_invar_ctrl : scale_ctrl; add_invar_ctrl : scale_ctrl;
register_new_node( inv_scale, inv_scale_ctrl ); register_new_node( inv_scale, inv_scale_ctrl );
Node *var_scale = new (C) LShiftINode( add_var, scale ); Node *var_scale = new LShiftINode( add_var, scale );
register_new_node( var_scale, n_ctrl ); register_new_node( var_scale, n_ctrl );
Node *var_add = new (C) AddINode( var_scale, inv_scale ); Node *var_add = new AddINode( var_scale, inv_scale );
register_new_node( var_add, n_ctrl ); register_new_node( var_add, n_ctrl );
_igvn.replace_node( n, var_add ); _igvn.replace_node( n, var_add );
return var_add; return var_add;
@ -430,10 +430,10 @@ Node *PhaseIdealLoop::remix_address_expressions( Node *n ) {
IdealLoopTree *n23_loop = get_loop( n23_ctrl ); IdealLoopTree *n23_loop = get_loop( n23_ctrl );
if( n22loop != n_loop && n22loop->is_member(n_loop) && if( n22loop != n_loop && n22loop->is_member(n_loop) &&
n23_loop == n_loop ) { n23_loop == n_loop ) {
Node *add1 = new (C) AddPNode( n->in(1), n->in(2)->in(2), n->in(3) ); Node *add1 = new AddPNode( n->in(1), n->in(2)->in(2), n->in(3) );
// Stuff new AddP in the loop preheader // Stuff new AddP in the loop preheader
register_new_node( add1, n_loop->_head->in(LoopNode::EntryControl) ); register_new_node( add1, n_loop->_head->in(LoopNode::EntryControl) );
Node *add2 = new (C) AddPNode( n->in(1), add1, n->in(2)->in(3) ); Node *add2 = new AddPNode( n->in(1), add1, n->in(2)->in(3) );
register_new_node( add2, n_ctrl ); register_new_node( add2, n_ctrl );
_igvn.replace_node( n, add2 ); _igvn.replace_node( n, add2 );
return add2; return add2;
@ -451,10 +451,10 @@ Node *PhaseIdealLoop::remix_address_expressions( Node *n ) {
Node *tmp = V; V = I; I = tmp; Node *tmp = V; V = I; I = tmp;
} }
if( !is_member(n_loop,get_ctrl(I)) ) { if( !is_member(n_loop,get_ctrl(I)) ) {
Node *add1 = new (C) AddPNode( n->in(1), n->in(2), I ); Node *add1 = new AddPNode( n->in(1), n->in(2), I );
// Stuff new AddP in the loop preheader // Stuff new AddP in the loop preheader
register_new_node( add1, n_loop->_head->in(LoopNode::EntryControl) ); register_new_node( add1, n_loop->_head->in(LoopNode::EntryControl) );
Node *add2 = new (C) AddPNode( n->in(1), add1, V ); Node *add2 = new AddPNode( n->in(1), add1, V );
register_new_node( add2, n_ctrl ); register_new_node( add2, n_ctrl );
_igvn.replace_node( n, add2 ); _igvn.replace_node( n, add2 );
return add2; return add2;
@ -1104,8 +1104,8 @@ BoolNode *PhaseIdealLoop::clone_iff( PhiNode *phi, IdealLoopTree *loop ) {
Node *sample_cmp = sample_bool->in(1); Node *sample_cmp = sample_bool->in(1);
// Make Phis to merge the Cmp's inputs. // Make Phis to merge the Cmp's inputs.
PhiNode *phi1 = new (C) PhiNode( phi->in(0), Type::TOP ); PhiNode *phi1 = new PhiNode( phi->in(0), Type::TOP );
PhiNode *phi2 = new (C) PhiNode( phi->in(0), Type::TOP ); PhiNode *phi2 = new PhiNode( phi->in(0), Type::TOP );
for( i = 1; i < phi->req(); i++ ) { for( i = 1; i < phi->req(); i++ ) {
Node *n1 = phi->in(i)->in(1)->in(1); Node *n1 = phi->in(i)->in(1)->in(1);
Node *n2 = phi->in(i)->in(1)->in(2); Node *n2 = phi->in(i)->in(1)->in(2);
@ -1172,8 +1172,8 @@ CmpNode *PhaseIdealLoop::clone_bool( PhiNode *phi, IdealLoopTree *loop ) {
Node *sample_cmp = phi->in(1); Node *sample_cmp = phi->in(1);
// Make Phis to merge the Cmp's inputs. // Make Phis to merge the Cmp's inputs.
PhiNode *phi1 = new (C) PhiNode( phi->in(0), Type::TOP ); PhiNode *phi1 = new PhiNode( phi->in(0), Type::TOP );
PhiNode *phi2 = new (C) PhiNode( phi->in(0), Type::TOP ); PhiNode *phi2 = new PhiNode( phi->in(0), Type::TOP );
for( uint j = 1; j < phi->req(); j++ ) { for( uint j = 1; j < phi->req(); j++ ) {
Node *cmp_top = phi->in(j); // Inputs are all Cmp or TOP Node *cmp_top = phi->in(j); // Inputs are all Cmp or TOP
Node *n1, *n2; Node *n1, *n2;
@ -1337,7 +1337,7 @@ void PhaseIdealLoop::clone_loop( IdealLoopTree *loop, Node_List &old_new, int dd
// We need a Region to merge the exit from the peeled body and the // We need a Region to merge the exit from the peeled body and the
// exit from the old loop body. // exit from the old loop body.
RegionNode *r = new (C) RegionNode(3); RegionNode *r = new RegionNode(3);
// Map the old use to the new merge point // Map the old use to the new merge point
old_new.map( use->_idx, r ); old_new.map( use->_idx, r );
uint dd_r = MIN2(dom_depth(newuse),dom_depth(use)); uint dd_r = MIN2(dom_depth(newuse),dom_depth(use));
@ -1684,13 +1684,13 @@ ProjNode* PhaseIdealLoop::insert_if_before_proj(Node* left, bool Signed, BoolTes
ProjNode* proj2 = proj_clone(proj, iff); ProjNode* proj2 = proj_clone(proj, iff);
register_node(proj2, loop, iff, ddepth); register_node(proj2, loop, iff, ddepth);
Node* cmp = Signed ? (Node*) new (C)CmpINode(left, right) : (Node*) new (C)CmpUNode(left, right); Node* cmp = Signed ? (Node*) new CmpINode(left, right) : (Node*) new CmpUNode(left, right);
register_node(cmp, loop, proj2, ddepth); register_node(cmp, loop, proj2, ddepth);
BoolNode* bol = new (C)BoolNode(cmp, relop); BoolNode* bol = new BoolNode(cmp, relop);
register_node(bol, loop, proj2, ddepth); register_node(bol, loop, proj2, ddepth);
IfNode* new_if = new (C)IfNode(proj2, bol, iff->_prob, iff->_fcnt); IfNode* new_if = new IfNode(proj2, bol, iff->_prob, iff->_fcnt);
register_node(new_if, loop, proj2, ddepth); register_node(new_if, loop, proj2, ddepth);
proj->set_req(0, new_if); // reattach proj->set_req(0, new_if); // reattach
@ -1742,11 +1742,11 @@ RegionNode* PhaseIdealLoop::insert_region_before_proj(ProjNode* proj) {
ProjNode* proj2 = proj_clone(proj, iff); ProjNode* proj2 = proj_clone(proj, iff);
register_node(proj2, loop, iff, ddepth); register_node(proj2, loop, iff, ddepth);
RegionNode* reg = new (C)RegionNode(2); RegionNode* reg = new RegionNode(2);
reg->set_req(1, proj2); reg->set_req(1, proj2);
register_node(reg, loop, iff, ddepth); register_node(reg, loop, iff, ddepth);
IfNode* dum_if = new (C)IfNode(reg, short_circuit_if(NULL, proj), iff->_prob, iff->_fcnt); IfNode* dum_if = new IfNode(reg, short_circuit_if(NULL, proj), iff->_prob, iff->_fcnt);
register_node(dum_if, loop, reg, ddepth); register_node(dum_if, loop, reg, ddepth);
proj->set_req(0, dum_if); // reattach proj->set_req(0, dum_if); // reattach
@ -2569,7 +2569,7 @@ bool PhaseIdealLoop::partial_peel( IdealLoopTree *loop, Node_List &old_new ) {
// Create new loop head for new phis and to hang // Create new loop head for new phis and to hang
// the nodes being moved (sinked) from the peel region. // the nodes being moved (sinked) from the peel region.
LoopNode* new_head = new (C) LoopNode(last_peel, last_peel); LoopNode* new_head = new LoopNode(last_peel, last_peel);
new_head->set_unswitch_count(head->unswitch_count()); // Preserve new_head->set_unswitch_count(head->unswitch_count()); // Preserve
_igvn.register_new_node_with_optimizer(new_head); _igvn.register_new_node_with_optimizer(new_head);
assert(first_not_peeled->in(0) == last_peel, "last_peel <- first_not_peeled"); assert(first_not_peeled->in(0) == last_peel, "last_peel <- first_not_peeled");
@ -2769,11 +2769,11 @@ void PhaseIdealLoop::reorg_offsets(IdealLoopTree *loop) {
if (dom_lca(exit, u_ctrl) != exit) continue; if (dom_lca(exit, u_ctrl) != exit) continue;
// Hit! Refactor use to use the post-incremented tripcounter. // Hit! Refactor use to use the post-incremented tripcounter.
// Compute a post-increment tripcounter. // Compute a post-increment tripcounter.
Node *opaq = new (C) Opaque2Node( C, cle->incr() ); Node *opaq = new Opaque2Node( C, cle->incr() );
register_new_node( opaq, u_ctrl ); register_new_node( opaq, u_ctrl );
Node *neg_stride = _igvn.intcon(-cle->stride_con()); Node *neg_stride = _igvn.intcon(-cle->stride_con());
set_ctrl(neg_stride, C->root()); set_ctrl(neg_stride, C->root());
Node *post = new (C) AddINode( opaq, neg_stride); Node *post = new AddINode( opaq, neg_stride);
register_new_node( post, u_ctrl ); register_new_node( post, u_ctrl );
_igvn.rehash_node_delayed(use); _igvn.rehash_node_delayed(use);
for (uint j = 1; j < use->req(); j++) { for (uint j = 1; j < use->req(); j++) {

5
hotspot/src/share/vm/opto/machnode.hpp
View file

@ -60,7 +60,10 @@ class State;
class MachOper : public ResourceObj { class MachOper : public ResourceObj {
public: public:
// Allocate right next to the MachNodes in the same arena // Allocate right next to the MachNodes in the same arena
void *operator new( size_t x, Compile* C ) throw() { return C->node_arena()->Amalloc_D(x); } void *operator new(size_t x) throw() {
Compile* C = Compile::current();
return C->node_arena()->Amalloc_D(x);
}
// Opcode // Opcode
virtual uint opcode() const = 0; virtual uint opcode() const = 0;

225
hotspot/src/share/vm/opto/macro.cpp
View file

@ -108,20 +108,20 @@ void PhaseMacroExpand::copy_call_debug_info(CallNode *oldcall, CallNode * newcal
Node* PhaseMacroExpand::opt_bits_test(Node* ctrl, Node* region, int edge, Node* word, int mask, int bits, bool return_fast_path) { Node* PhaseMacroExpand::opt_bits_test(Node* ctrl, Node* region, int edge, Node* word, int mask, int bits, bool return_fast_path) {
Node* cmp; Node* cmp;
if (mask != 0) { if (mask != 0) {
Node* and_node = transform_later(new (C) AndXNode(word, MakeConX(mask))); Node* and_node = transform_later(new AndXNode(word, MakeConX(mask)));
cmp = transform_later(new (C) CmpXNode(and_node, MakeConX(bits))); cmp = transform_later(new CmpXNode(and_node, MakeConX(bits)));
} else { } else {
cmp = word; cmp = word;
} }
Node* bol = transform_later(new (C) BoolNode(cmp, BoolTest::ne)); Node* bol = transform_later(new BoolNode(cmp, BoolTest::ne));
IfNode* iff = new (C) IfNode( ctrl, bol, PROB_MIN, COUNT_UNKNOWN ); IfNode* iff = new IfNode( ctrl, bol, PROB_MIN, COUNT_UNKNOWN );
transform_later(iff); transform_later(iff);
// Fast path taken. // Fast path taken.
Node *fast_taken = transform_later( new (C) IfFalseNode(iff) ); Node *fast_taken = transform_later(new IfFalseNode(iff));
// Fast path not-taken, i.e. slow path // Fast path not-taken, i.e. slow path
Node *slow_taken = transform_later( new (C) IfTrueNode(iff) ); Node *slow_taken = transform_later(new IfTrueNode(iff));
if (return_fast_path) { if (return_fast_path) {
region->init_req(edge, slow_taken); // Capture slow-control region->init_req(edge, slow_taken); // Capture slow-control
@ -147,8 +147,8 @@ CallNode* PhaseMacroExpand::make_slow_call(CallNode *oldcall, const TypeFunc* sl
// Slow-path call // Slow-path call
CallNode *call = leaf_name CallNode *call = leaf_name
? (CallNode*)new (C) CallLeafNode ( slow_call_type, slow_call, leaf_name, TypeRawPtr::BOTTOM ) ? (CallNode*)new CallLeafNode ( slow_call_type, slow_call, leaf_name, TypeRawPtr::BOTTOM )
: (CallNode*)new (C) CallStaticJavaNode( slow_call_type, slow_call, OptoRuntime::stub_name(slow_call), oldcall->jvms()->bci(), TypeRawPtr::BOTTOM ); : (CallNode*)new CallStaticJavaNode( slow_call_type, slow_call, OptoRuntime::stub_name(slow_call), oldcall->jvms()->bci(), TypeRawPtr::BOTTOM );
// Slow path call has no side-effects, uses few values // Slow path call has no side-effects, uses few values
copy_predefined_input_for_runtime_call(slow_path, oldcall, call ); copy_predefined_input_for_runtime_call(slow_path, oldcall, call );
@ -423,7 +423,7 @@ Node *PhaseMacroExpand::value_from_mem_phi(Node *mem, BasicType ft, const Type *
GrowableArray <Node *> values(length, length, NULL, false); GrowableArray <Node *> values(length, length, NULL, false);
// create a new Phi for the value // create a new Phi for the value
PhiNode *phi = new (C) PhiNode(mem->in(0), phi_type, NULL, instance_id, alias_idx, offset); PhiNode *phi = new PhiNode(mem->in(0), phi_type, NULL, instance_id, alias_idx, offset);
transform_later(phi); transform_later(phi);
value_phis->push(phi, mem->_idx); value_phis->push(phi, mem->_idx);
@ -735,7 +735,7 @@ bool PhaseMacroExpand::scalar_replacement(AllocateNode *alloc, GrowableArray <Sa
// of regular debuginfo at the last (youngest) JVMS. // of regular debuginfo at the last (youngest) JVMS.
// Record relative start index. // Record relative start index.
uint first_ind = (sfpt->req() - sfpt->jvms()->scloff()); uint first_ind = (sfpt->req() - sfpt->jvms()->scloff());
SafePointScalarObjectNode* sobj = new (C) SafePointScalarObjectNode(res_type, SafePointScalarObjectNode* sobj = new SafePointScalarObjectNode(res_type,
#ifdef ASSERT #ifdef ASSERT
alloc, alloc,
#endif #endif
@ -843,7 +843,7 @@ bool PhaseMacroExpand::scalar_replacement(AllocateNode *alloc, GrowableArray <Sa
if (field_val->is_EncodeP()) { if (field_val->is_EncodeP()) {
field_val = field_val->in(1); field_val = field_val->in(1);
} else { } else {
field_val = transform_later(new (C) DecodeNNode(field_val, field_val->get_ptr_type())); field_val = transform_later(new DecodeNNode(field_val, field_val->get_ptr_type()));
} }
} }
sfpt->add_req(field_val); sfpt->add_req(field_val);
@ -1069,7 +1069,7 @@ bool PhaseMacroExpand::eliminate_boxing_node(CallStaticJavaNode *boxing) {
//---------------------------set_eden_pointers------------------------- //---------------------------set_eden_pointers-------------------------
void PhaseMacroExpand::set_eden_pointers(Node* &eden_top_adr, Node* &eden_end_adr) { void PhaseMacroExpand::set_eden_pointers(Node* &eden_top_adr, Node* &eden_end_adr) {
if (UseTLAB) { // Private allocation: load from TLS if (UseTLAB) { // Private allocation: load from TLS
Node* thread = transform_later(new (C) ThreadLocalNode()); Node* thread = transform_later(new ThreadLocalNode());
int tlab_top_offset = in_bytes(JavaThread::tlab_top_offset()); int tlab_top_offset = in_bytes(JavaThread::tlab_top_offset());
int tlab_end_offset = in_bytes(JavaThread::tlab_end_offset()); int tlab_end_offset = in_bytes(JavaThread::tlab_end_offset());
eden_top_adr = basic_plus_adr(top()/*not oop*/, thread, tlab_top_offset); eden_top_adr = basic_plus_adr(top()/*not oop*/, thread, tlab_top_offset);
@ -1205,18 +1205,18 @@ void PhaseMacroExpand::expand_allocate_common(
assert (initial_slow_test == NULL || !always_slow, "arguments must be consistent"); assert (initial_slow_test == NULL || !always_slow, "arguments must be consistent");
// generate the initial test if necessary // generate the initial test if necessary
if (initial_slow_test != NULL ) { if (initial_slow_test != NULL ) {
slow_region = new (C) RegionNode(3); slow_region = new RegionNode(3);
// Now make the initial failure test. Usually a too-big test but // Now make the initial failure test. Usually a too-big test but
// might be a TRUE for finalizers or a fancy class check for // might be a TRUE for finalizers or a fancy class check for
// newInstance0. // newInstance0.
IfNode *toobig_iff = new (C) IfNode(ctrl, initial_slow_test, PROB_MIN, COUNT_UNKNOWN); IfNode *toobig_iff = new IfNode(ctrl, initial_slow_test, PROB_MIN, COUNT_UNKNOWN);
transform_later(toobig_iff); transform_later(toobig_iff);
// Plug the failing-too-big test into the slow-path region // Plug the failing-too-big test into the slow-path region
Node *toobig_true = new (C) IfTrueNode( toobig_iff ); Node *toobig_true = new IfTrueNode( toobig_iff );
transform_later(toobig_true); transform_later(toobig_true);
slow_region ->init_req( too_big_or_final_path, toobig_true ); slow_region ->init_req( too_big_or_final_path, toobig_true );
toobig_false = new (C) IfFalseNode( toobig_iff ); toobig_false = new IfFalseNode( toobig_iff );
transform_later(toobig_false); transform_later(toobig_false);
} else { // No initial test, just fall into next case } else { // No initial test, just fall into next case
toobig_false = ctrl; toobig_false = ctrl;
@ -1249,10 +1249,10 @@ void PhaseMacroExpand::expand_allocate_common(
Node *eden_end = make_load(ctrl, mem, eden_end_adr, 0, TypeRawPtr::BOTTOM, T_ADDRESS); Node *eden_end = make_load(ctrl, mem, eden_end_adr, 0, TypeRawPtr::BOTTOM, T_ADDRESS);
// allocate the Region and Phi nodes for the result // allocate the Region and Phi nodes for the result
result_region = new (C) RegionNode(3); result_region = new RegionNode(3);
result_phi_rawmem = new (C) PhiNode(result_region, Type::MEMORY, TypeRawPtr::BOTTOM); result_phi_rawmem = new PhiNode(result_region, Type::MEMORY, TypeRawPtr::BOTTOM);
result_phi_rawoop = new (C) PhiNode(result_region, TypeRawPtr::BOTTOM); result_phi_rawoop = new PhiNode(result_region, TypeRawPtr::BOTTOM);
result_phi_i_o = new (C) PhiNode(result_region, Type::ABIO); // I/O is used for Prefetch result_phi_i_o = new PhiNode(result_region, Type::ABIO); // I/O is used for Prefetch
// We need a Region for the loop-back contended case. // We need a Region for the loop-back contended case.
enum { fall_in_path = 1, contended_loopback_path = 2 }; enum { fall_in_path = 1, contended_loopback_path = 2 };
@ -1262,8 +1262,8 @@ void PhaseMacroExpand::expand_allocate_common(
contended_region = toobig_false; contended_region = toobig_false;
contended_phi_rawmem = mem; contended_phi_rawmem = mem;
} else { } else {
contended_region = new (C) RegionNode(3); contended_region = new RegionNode(3);
contended_phi_rawmem = new (C) PhiNode(contended_region, Type::MEMORY, TypeRawPtr::BOTTOM); contended_phi_rawmem = new PhiNode(contended_region, Type::MEMORY, TypeRawPtr::BOTTOM);
// Now handle the passing-too-big test. We fall into the contended // Now handle the passing-too-big test. We fall into the contended
// loop-back merge point. // loop-back merge point.
contended_region ->init_req(fall_in_path, toobig_false); contended_region ->init_req(fall_in_path, toobig_false);
@ -1275,23 +1275,23 @@ void PhaseMacroExpand::expand_allocate_common(
// Load(-locked) the heap top. // Load(-locked) the heap top.
// See note above concerning the control input when using a TLAB // See note above concerning the control input when using a TLAB
Node *old_eden_top = UseTLAB Node *old_eden_top = UseTLAB
? new (C) LoadPNode (ctrl, contended_phi_rawmem, eden_top_adr, TypeRawPtr::BOTTOM, TypeRawPtr::BOTTOM, MemNode::unordered) ? new LoadPNode (ctrl, contended_phi_rawmem, eden_top_adr, TypeRawPtr::BOTTOM, TypeRawPtr::BOTTOM, MemNode::unordered)
: new (C) LoadPLockedNode(contended_region, contended_phi_rawmem, eden_top_adr, MemNode::acquire); : new LoadPLockedNode(contended_region, contended_phi_rawmem, eden_top_adr, MemNode::acquire);
transform_later(old_eden_top); transform_later(old_eden_top);
// Add to heap top to get a new heap top // Add to heap top to get a new heap top
Node *new_eden_top = new (C) AddPNode(top(), old_eden_top, size_in_bytes); Node *new_eden_top = new AddPNode(top(), old_eden_top, size_in_bytes);
transform_later(new_eden_top); transform_later(new_eden_top);
// Check for needing a GC; compare against heap end // Check for needing a GC; compare against heap end
Node *needgc_cmp = new (C) CmpPNode(new_eden_top, eden_end); Node *needgc_cmp = new CmpPNode(new_eden_top, eden_end);
transform_later(needgc_cmp); transform_later(needgc_cmp);
Node *needgc_bol = new (C) BoolNode(needgc_cmp, BoolTest::ge); Node *needgc_bol = new BoolNode(needgc_cmp, BoolTest::ge);
transform_later(needgc_bol); transform_later(needgc_bol);
IfNode *needgc_iff = new (C) IfNode(contended_region, needgc_bol, PROB_UNLIKELY_MAG(4), COUNT_UNKNOWN); IfNode *needgc_iff = new IfNode(contended_region, needgc_bol, PROB_UNLIKELY_MAG(4), COUNT_UNKNOWN);
transform_later(needgc_iff); transform_later(needgc_iff);
// Plug the failing-heap-space-need-gc test into the slow-path region // Plug the failing-heap-space-need-gc test into the slow-path region
Node *needgc_true = new (C) IfTrueNode(needgc_iff); Node *needgc_true = new IfTrueNode(needgc_iff);
transform_later(needgc_true); transform_later(needgc_true);
if (initial_slow_test) { if (initial_slow_test) {
slow_region->init_req(need_gc_path, needgc_true); slow_region->init_req(need_gc_path, needgc_true);
@ -1302,7 +1302,7 @@ void PhaseMacroExpand::expand_allocate_common(
slow_region = needgc_true; slow_region = needgc_true;
} }
// No need for a GC. Setup for the Store-Conditional // No need for a GC. Setup for the Store-Conditional
Node *needgc_false = new (C) IfFalseNode(needgc_iff); Node *needgc_false = new IfFalseNode(needgc_iff);
transform_later(needgc_false); transform_later(needgc_false);
// Grab regular I/O before optional prefetch may change it. // Grab regular I/O before optional prefetch may change it.
@ -1322,37 +1322,37 @@ void PhaseMacroExpand::expand_allocate_common(
// memory state. // memory state.
if (UseTLAB) { if (UseTLAB) {
Node* store_eden_top = Node* store_eden_top =
new (C) StorePNode(needgc_false, contended_phi_rawmem, eden_top_adr, new StorePNode(needgc_false, contended_phi_rawmem, eden_top_adr,
TypeRawPtr::BOTTOM, new_eden_top, MemNode::unordered); TypeRawPtr::BOTTOM, new_eden_top, MemNode::unordered);
transform_later(store_eden_top); transform_later(store_eden_top);
fast_oop_ctrl = needgc_false; // No contention, so this is the fast path fast_oop_ctrl = needgc_false; // No contention, so this is the fast path
fast_oop_rawmem = store_eden_top; fast_oop_rawmem = store_eden_top;
} else { } else {
Node* store_eden_top = Node* store_eden_top =
new (C) StorePConditionalNode(needgc_false, contended_phi_rawmem, eden_top_adr, new StorePConditionalNode(needgc_false, contended_phi_rawmem, eden_top_adr,
new_eden_top, fast_oop/*old_eden_top*/); new_eden_top, fast_oop/*old_eden_top*/);
transform_later(store_eden_top); transform_later(store_eden_top);
Node *contention_check = new (C) BoolNode(store_eden_top, BoolTest::ne); Node *contention_check = new BoolNode(store_eden_top, BoolTest::ne);
transform_later(contention_check); transform_later(contention_check);
store_eden_top = new (C) SCMemProjNode(store_eden_top); store_eden_top = new SCMemProjNode(store_eden_top);
transform_later(store_eden_top); transform_later(store_eden_top);
// If not using TLABs, check to see if there was contention. // If not using TLABs, check to see if there was contention.
IfNode *contention_iff = new (C) IfNode (needgc_false, contention_check, PROB_MIN, COUNT_UNKNOWN); IfNode *contention_iff = new IfNode (needgc_false, contention_check, PROB_MIN, COUNT_UNKNOWN);
transform_later(contention_iff); transform_later(contention_iff);
Node *contention_true = new (C) IfTrueNode(contention_iff); Node *contention_true = new IfTrueNode(contention_iff);
transform_later(contention_true); transform_later(contention_true);
// If contention, loopback and try again. // If contention, loopback and try again.
contended_region->init_req(contended_loopback_path, contention_true); contended_region->init_req(contended_loopback_path, contention_true);
contended_phi_rawmem->init_req(contended_loopback_path, store_eden_top); contended_phi_rawmem->init_req(contended_loopback_path, store_eden_top);
// Fast-path succeeded with no contention! // Fast-path succeeded with no contention!
Node *contention_false = new (C) IfFalseNode(contention_iff); Node *contention_false = new IfFalseNode(contention_iff);
transform_later(contention_false); transform_later(contention_false);
fast_oop_ctrl = contention_false; fast_oop_ctrl = contention_false;
// Bump total allocated bytes for this thread // Bump total allocated bytes for this thread
Node* thread = new (C) ThreadLocalNode(); Node* thread = new ThreadLocalNode();
transform_later(thread); transform_later(thread);
Node* alloc_bytes_adr = basic_plus_adr(top()/*not oop*/, thread, Node* alloc_bytes_adr = basic_plus_adr(top()/*not oop*/, thread,
in_bytes(JavaThread::allocated_bytes_offset())); in_bytes(JavaThread::allocated_bytes_offset()));
@ -1361,10 +1361,10 @@ void PhaseMacroExpand::expand_allocate_common(
#ifdef _LP64 #ifdef _LP64
Node* alloc_size = size_in_bytes; Node* alloc_size = size_in_bytes;
#else #else
Node* alloc_size = new (C) ConvI2LNode(size_in_bytes); Node* alloc_size = new ConvI2LNode(size_in_bytes);
transform_later(alloc_size); transform_later(alloc_size);
#endif #endif
Node* new_alloc_bytes = new (C) AddLNode(alloc_bytes, alloc_size); Node* new_alloc_bytes = new AddLNode(alloc_bytes, alloc_size);
transform_later(new_alloc_bytes); transform_later(new_alloc_bytes);
fast_oop_rawmem = make_store(fast_oop_ctrl, store_eden_top, alloc_bytes_adr, fast_oop_rawmem = make_store(fast_oop_ctrl, store_eden_top, alloc_bytes_adr,
0, new_alloc_bytes, T_LONG); 0, new_alloc_bytes, T_LONG);
@ -1391,9 +1391,9 @@ void PhaseMacroExpand::expand_allocate_common(
mb->init_req(TypeFunc::Memory, fast_oop_rawmem); mb->init_req(TypeFunc::Memory, fast_oop_rawmem);
mb->init_req(TypeFunc::Control, fast_oop_ctrl); mb->init_req(TypeFunc::Control, fast_oop_ctrl);
fast_oop_ctrl = new (C) ProjNode(mb,TypeFunc::Control); fast_oop_ctrl = new ProjNode(mb,TypeFunc::Control);
transform_later(fast_oop_ctrl); transform_later(fast_oop_ctrl);
fast_oop_rawmem = new (C) ProjNode(mb,TypeFunc::Memory); fast_oop_rawmem = new ProjNode(mb,TypeFunc::Memory);
transform_later(fast_oop_rawmem); transform_later(fast_oop_rawmem);
} else { } else {
// Add the MemBarStoreStore after the InitializeNode so that // Add the MemBarStoreStore after the InitializeNode so that
@ -1407,9 +1407,9 @@ void PhaseMacroExpand::expand_allocate_common(
MemBarNode* mb = MemBarNode::make(C, Op_MemBarStoreStore, Compile::AliasIdxBot); MemBarNode* mb = MemBarNode::make(C, Op_MemBarStoreStore, Compile::AliasIdxBot);
transform_later(mb); transform_later(mb);
Node* ctrl = new (C) ProjNode(init,TypeFunc::Control); Node* ctrl = new ProjNode(init,TypeFunc::Control);
transform_later(ctrl); transform_later(ctrl);
Node* mem = new (C) ProjNode(init,TypeFunc::Memory); Node* mem = new ProjNode(init,TypeFunc::Memory);
transform_later(mem); transform_later(mem);
// The MemBarStoreStore depends on control and memory coming // The MemBarStoreStore depends on control and memory coming
@ -1417,9 +1417,9 @@ void PhaseMacroExpand::expand_allocate_common(
mb->init_req(TypeFunc::Memory, mem); mb->init_req(TypeFunc::Memory, mem);
mb->init_req(TypeFunc::Control, ctrl); mb->init_req(TypeFunc::Control, ctrl);
ctrl = new (C) ProjNode(mb,TypeFunc::Control); ctrl = new ProjNode(mb,TypeFunc::Control);
transform_later(ctrl); transform_later(ctrl);
mem = new (C) ProjNode(mb,TypeFunc::Memory); mem = new ProjNode(mb,TypeFunc::Memory);
transform_later(mem); transform_later(mem);
// All nodes that depended on the InitializeNode for control // All nodes that depended on the InitializeNode for control
@ -1433,13 +1433,13 @@ void PhaseMacroExpand::expand_allocate_common(
if (C->env()->dtrace_extended_probes()) { if (C->env()->dtrace_extended_probes()) {
// Slow-path call // Slow-path call
int size = TypeFunc::Parms + 2; int size = TypeFunc::Parms + 2;
CallLeafNode *call = new (C) CallLeafNode(OptoRuntime::dtrace_object_alloc_Type(), CallLeafNode *call = new CallLeafNode(OptoRuntime::dtrace_object_alloc_Type(),
CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_object_alloc_base), CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_object_alloc_base),
"dtrace_object_alloc", "dtrace_object_alloc",
TypeRawPtr::BOTTOM); TypeRawPtr::BOTTOM);
// Get base of thread-local storage area // Get base of thread-local storage area
Node* thread = new (C) ThreadLocalNode(); Node* thread = new ThreadLocalNode();
transform_later(thread); transform_later(thread);
call->init_req(TypeFunc::Parms+0, thread); call->init_req(TypeFunc::Parms+0, thread);
@ -1450,9 +1450,9 @@ void PhaseMacroExpand::expand_allocate_common(
call->init_req(TypeFunc::ReturnAdr, alloc->in(TypeFunc::ReturnAdr)); call->init_req(TypeFunc::ReturnAdr, alloc->in(TypeFunc::ReturnAdr));
call->init_req(TypeFunc::FramePtr, alloc->in(TypeFunc::FramePtr)); call->init_req(TypeFunc::FramePtr, alloc->in(TypeFunc::FramePtr));
transform_later(call); transform_later(call);
fast_oop_ctrl = new (C) ProjNode(call,TypeFunc::Control); fast_oop_ctrl = new ProjNode(call,TypeFunc::Control);
transform_later(fast_oop_ctrl); transform_later(fast_oop_ctrl);
fast_oop_rawmem = new (C) ProjNode(call,TypeFunc::Memory); fast_oop_rawmem = new ProjNode(call,TypeFunc::Memory);
transform_later(fast_oop_rawmem); transform_later(fast_oop_rawmem);
} }
@ -1467,7 +1467,7 @@ void PhaseMacroExpand::expand_allocate_common(
} }
// Generate slow-path call // Generate slow-path call
CallNode *call = new (C) CallStaticJavaNode(slow_call_type, slow_call_address, CallNode *call = new CallStaticJavaNode(slow_call_type, slow_call_address,
OptoRuntime::stub_name(slow_call_address), OptoRuntime::stub_name(slow_call_address),
alloc->jvms()->bci(), alloc->jvms()->bci(),
TypePtr::BOTTOM); TypePtr::BOTTOM);
@ -1524,7 +1524,7 @@ void PhaseMacroExpand::expand_allocate_common(
// _memproj_catchall so we end up with a call that has only 1 memory projection. // _memproj_catchall so we end up with a call that has only 1 memory projection.
if (_memproj_catchall != NULL ) { if (_memproj_catchall != NULL ) {
if (_memproj_fallthrough == NULL) { if (_memproj_fallthrough == NULL) {
_memproj_fallthrough = new (C) ProjNode(call, TypeFunc::Memory); _memproj_fallthrough = new ProjNode(call, TypeFunc::Memory);
transform_later(_memproj_fallthrough); transform_later(_memproj_fallthrough);
} }
for (DUIterator_Fast imax, i = _memproj_catchall->fast_outs(imax); i < imax; i++) { for (DUIterator_Fast imax, i = _memproj_catchall->fast_outs(imax); i < imax; i++) {
@ -1556,7 +1556,7 @@ void PhaseMacroExpand::expand_allocate_common(
// _ioproj_catchall so we end up with a call that has only 1 i_o projection. // _ioproj_catchall so we end up with a call that has only 1 i_o projection.
if (_ioproj_catchall != NULL ) { if (_ioproj_catchall != NULL ) {
if (_ioproj_fallthrough == NULL) { if (_ioproj_fallthrough == NULL) {
_ioproj_fallthrough = new (C) ProjNode(call, TypeFunc::I_O); _ioproj_fallthrough = new ProjNode(call, TypeFunc::I_O);
transform_later(_ioproj_fallthrough); transform_later(_ioproj_fallthrough);
} }
for (DUIterator_Fast imax, i = _ioproj_catchall->fast_outs(imax); i < imax; i++) { for (DUIterator_Fast imax, i = _ioproj_catchall->fast_outs(imax); i < imax; i++) {
@ -1690,47 +1690,47 @@ Node* PhaseMacroExpand::prefetch_allocation(Node* i_o, Node*& needgc_false,
// As an allocation hits the watermark, we will prefetch starting // As an allocation hits the watermark, we will prefetch starting
// at a "distance" away from watermark. // at a "distance" away from watermark.
Node *pf_region = new (C) RegionNode(3); Node *pf_region = new RegionNode(3);
Node *pf_phi_rawmem = new (C) PhiNode( pf_region, Type::MEMORY, Node *pf_phi_rawmem = new PhiNode( pf_region, Type::MEMORY,
TypeRawPtr::BOTTOM ); TypeRawPtr::BOTTOM );
// I/O is used for Prefetch // I/O is used for Prefetch
Node *pf_phi_abio = new (C) PhiNode( pf_region, Type::ABIO ); Node *pf_phi_abio = new PhiNode( pf_region, Type::ABIO );
Node *thread = new (C) ThreadLocalNode(); Node *thread = new ThreadLocalNode();
transform_later(thread); transform_later(thread);
Node *eden_pf_adr = new (C) AddPNode( top()/*not oop*/, thread, Node *eden_pf_adr = new AddPNode( top()/*not oop*/, thread,
_igvn.MakeConX(in_bytes(JavaThread::tlab_pf_top_offset())) ); _igvn.MakeConX(in_bytes(JavaThread::tlab_pf_top_offset())) );
transform_later(eden_pf_adr); transform_later(eden_pf_adr);
Node *old_pf_wm = new (C) LoadPNode(needgc_false, Node *old_pf_wm = new LoadPNode(needgc_false,
contended_phi_rawmem, eden_pf_adr, contended_phi_rawmem, eden_pf_adr,
TypeRawPtr::BOTTOM, TypeRawPtr::BOTTOM, TypeRawPtr::BOTTOM, TypeRawPtr::BOTTOM,
MemNode::unordered); MemNode::unordered);
transform_later(old_pf_wm); transform_later(old_pf_wm);
// check against new_eden_top // check against new_eden_top
Node *need_pf_cmp = new (C) CmpPNode( new_eden_top, old_pf_wm ); Node *need_pf_cmp = new CmpPNode( new_eden_top, old_pf_wm );
transform_later(need_pf_cmp); transform_later(need_pf_cmp);
Node *need_pf_bol = new (C) BoolNode( need_pf_cmp, BoolTest::ge ); Node *need_pf_bol = new BoolNode( need_pf_cmp, BoolTest::ge );
transform_later(need_pf_bol); transform_later(need_pf_bol);
IfNode *need_pf_iff = new (C) IfNode( needgc_false, need_pf_bol, IfNode *need_pf_iff = new IfNode( needgc_false, need_pf_bol,
PROB_UNLIKELY_MAG(4), COUNT_UNKNOWN ); PROB_UNLIKELY_MAG(4), COUNT_UNKNOWN );
transform_later(need_pf_iff); transform_later(need_pf_iff);
// true node, add prefetchdistance // true node, add prefetchdistance
Node *need_pf_true = new (C) IfTrueNode( need_pf_iff ); Node *need_pf_true = new IfTrueNode( need_pf_iff );
transform_later(need_pf_true); transform_later(need_pf_true);
Node *need_pf_false = new (C) IfFalseNode( need_pf_iff ); Node *need_pf_false = new IfFalseNode( need_pf_iff );
transform_later(need_pf_false); transform_later(need_pf_false);
Node *new_pf_wmt = new (C) AddPNode( top(), old_pf_wm, Node *new_pf_wmt = new AddPNode( top(), old_pf_wm,
_igvn.MakeConX(AllocatePrefetchDistance) ); _igvn.MakeConX(AllocatePrefetchDistance) );
transform_later(new_pf_wmt ); transform_later(new_pf_wmt );
new_pf_wmt->set_req(0, need_pf_true); new_pf_wmt->set_req(0, need_pf_true);
Node *store_new_wmt = new (C) StorePNode(need_pf_true, Node *store_new_wmt = new StorePNode(need_pf_true,
contended_phi_rawmem, eden_pf_adr, contended_phi_rawmem, eden_pf_adr,
TypeRawPtr::BOTTOM, new_pf_wmt, TypeRawPtr::BOTTOM, new_pf_wmt,
MemNode::unordered); MemNode::unordered);
@ -1746,10 +1746,10 @@ Node* PhaseMacroExpand::prefetch_allocation(Node* i_o, Node*& needgc_false,
uint distance = 0; uint distance = 0;
for ( uint i = 0; i < lines; i++ ) { for ( uint i = 0; i < lines; i++ ) {
prefetch_adr = new (C) AddPNode( old_pf_wm, new_pf_wmt, prefetch_adr = new AddPNode( old_pf_wm, new_pf_wmt,
_igvn.MakeConX(distance) ); _igvn.MakeConX(distance) );
transform_later(prefetch_adr); transform_later(prefetch_adr);
prefetch = new (C) PrefetchAllocationNode( i_o, prefetch_adr ); prefetch = new PrefetchAllocationNode( i_o, prefetch_adr );
transform_later(prefetch); transform_later(prefetch);
distance += step_size; distance += step_size;
i_o = prefetch; i_o = prefetch;
@ -1772,8 +1772,8 @@ Node* PhaseMacroExpand::prefetch_allocation(Node* i_o, Node*& needgc_false,
} else if( UseTLAB && AllocatePrefetchStyle == 3 ) { } else if( UseTLAB && AllocatePrefetchStyle == 3 ) {
// Insert a prefetch for each allocation. // Insert a prefetch for each allocation.
// This code is used for Sparc with BIS. // This code is used for Sparc with BIS.
Node *pf_region = new (C) RegionNode(3); Node *pf_region = new RegionNode(3);
Node *pf_phi_rawmem = new (C) PhiNode( pf_region, Type::MEMORY, Node *pf_phi_rawmem = new PhiNode( pf_region, Type::MEMORY,
TypeRawPtr::BOTTOM ); TypeRawPtr::BOTTOM );
// Generate several prefetch instructions. // Generate several prefetch instructions.
@ -1782,29 +1782,29 @@ Node* PhaseMacroExpand::prefetch_allocation(Node* i_o, Node*& needgc_false,
uint distance = AllocatePrefetchDistance; uint distance = AllocatePrefetchDistance;
// Next cache address. // Next cache address.
Node *cache_adr = new (C) AddPNode(old_eden_top, old_eden_top, Node *cache_adr = new AddPNode(old_eden_top, old_eden_top,
_igvn.MakeConX(distance)); _igvn.MakeConX(distance));
transform_later(cache_adr); transform_later(cache_adr);
cache_adr = new (C) CastP2XNode(needgc_false, cache_adr); cache_adr = new CastP2XNode(needgc_false, cache_adr);
transform_later(cache_adr); transform_later(cache_adr);
Node* mask = _igvn.MakeConX(~(intptr_t)(step_size-1)); Node* mask = _igvn.MakeConX(~(intptr_t)(step_size-1));
cache_adr = new (C) AndXNode(cache_adr, mask); cache_adr = new AndXNode(cache_adr, mask);
transform_later(cache_adr); transform_later(cache_adr);
cache_adr = new (C) CastX2PNode(cache_adr); cache_adr = new CastX2PNode(cache_adr);
transform_later(cache_adr); transform_later(cache_adr);
// Prefetch // Prefetch
Node *prefetch = new (C) PrefetchAllocationNode( contended_phi_rawmem, cache_adr ); Node *prefetch = new PrefetchAllocationNode( contended_phi_rawmem, cache_adr );
prefetch->set_req(0, needgc_false); prefetch->set_req(0, needgc_false);
transform_later(prefetch); transform_later(prefetch);
contended_phi_rawmem = prefetch; contended_phi_rawmem = prefetch;
Node *prefetch_adr; Node *prefetch_adr;
distance = step_size; distance = step_size;
for ( uint i = 1; i < lines; i++ ) { for ( uint i = 1; i < lines; i++ ) {
prefetch_adr = new (C) AddPNode( cache_adr, cache_adr, prefetch_adr = new AddPNode( cache_adr, cache_adr,
_igvn.MakeConX(distance) ); _igvn.MakeConX(distance) );
transform_later(prefetch_adr); transform_later(prefetch_adr);
prefetch = new (C) PrefetchAllocationNode( contended_phi_rawmem, prefetch_adr ); prefetch = new PrefetchAllocationNode( contended_phi_rawmem, prefetch_adr );
transform_later(prefetch); transform_later(prefetch);
distance += step_size; distance += step_size;
contended_phi_rawmem = prefetch; contended_phi_rawmem = prefetch;
@ -1818,10 +1818,10 @@ Node* PhaseMacroExpand::prefetch_allocation(Node* i_o, Node*& needgc_false,
uint step_size = AllocatePrefetchStepSize; uint step_size = AllocatePrefetchStepSize;
uint distance = AllocatePrefetchDistance; uint distance = AllocatePrefetchDistance;
for ( uint i = 0; i < lines; i++ ) { for ( uint i = 0; i < lines; i++ ) {
prefetch_adr = new (C) AddPNode( old_eden_top, new_eden_top, prefetch_adr = new AddPNode( old_eden_top, new_eden_top,
_igvn.MakeConX(distance) ); _igvn.MakeConX(distance) );
transform_later(prefetch_adr); transform_later(prefetch_adr);
prefetch = new (C) PrefetchAllocationNode( i_o, prefetch_adr ); prefetch = new PrefetchAllocationNode( i_o, prefetch_adr );
// Do not let it float too high, since if eden_top == eden_end, // Do not let it float too high, since if eden_top == eden_end,
// both might be null. // both might be null.
if( i == 0 ) { // Set control for first prefetch, next follows it if( i == 0 ) { // Set control for first prefetch, next follows it
@ -2170,12 +2170,12 @@ void PhaseMacroExpand::expand_lock_node(LockNode *lock) {
* } * }
*/ */
region = new (C) RegionNode(5); region = new RegionNode(5);
// create a Phi for the memory state // create a Phi for the memory state
mem_phi = new (C) PhiNode( region, Type::MEMORY, TypeRawPtr::BOTTOM); mem_phi = new PhiNode( region, Type::MEMORY, TypeRawPtr::BOTTOM);
Node* fast_lock_region = new (C) RegionNode(3); Node* fast_lock_region = new RegionNode(3);
Node* fast_lock_mem_phi = new (C) PhiNode( fast_lock_region, Type::MEMORY, TypeRawPtr::BOTTOM); Node* fast_lock_mem_phi = new PhiNode( fast_lock_region, Type::MEMORY, TypeRawPtr::BOTTOM);
// First, check mark word for the biased lock pattern. // First, check mark word for the biased lock pattern.
Node* mark_node = make_load(ctrl, mem, obj, oopDesc::mark_offset_in_bytes(), TypeX_X, TypeX_X->basic_type()); Node* mark_node = make_load(ctrl, mem, obj, oopDesc::mark_offset_in_bytes(), TypeX_X, TypeX_X->basic_type());
@ -2205,10 +2205,10 @@ void PhaseMacroExpand::expand_lock_node(LockNode *lock) {
} }
Node *proto_node = make_load(ctrl, mem, klass_node, in_bytes(Klass::prototype_header_offset()), TypeX_X, TypeX_X->basic_type()); Node *proto_node = make_load(ctrl, mem, klass_node, in_bytes(Klass::prototype_header_offset()), TypeX_X, TypeX_X->basic_type());
Node* thread = transform_later(new (C) ThreadLocalNode()); Node* thread = transform_later(new ThreadLocalNode());
Node* cast_thread = transform_later(new (C) CastP2XNode(ctrl, thread)); Node* cast_thread = transform_later(new CastP2XNode(ctrl, thread));
Node* o_node = transform_later(new (C) OrXNode(cast_thread, proto_node)); Node* o_node = transform_later(new OrXNode(cast_thread, proto_node));
Node* x_node = transform_later(new (C) XorXNode(o_node, mark_node)); Node* x_node = transform_later(new XorXNode(o_node, mark_node));
// Get slow path - mark word does NOT match the value. // Get slow path - mark word does NOT match the value.
Node* not_biased_ctrl = opt_bits_test(ctrl, region, 3, x_node, Node* not_biased_ctrl = opt_bits_test(ctrl, region, 3, x_node,
@ -2231,17 +2231,17 @@ void PhaseMacroExpand::expand_lock_node(LockNode *lock) {
// We are going to try to reset the mark of this object to the prototype // We are going to try to reset the mark of this object to the prototype
// value and fall through to the CAS-based locking scheme. // value and fall through to the CAS-based locking scheme.
Node* adr = basic_plus_adr(obj, oopDesc::mark_offset_in_bytes()); Node* adr = basic_plus_adr(obj, oopDesc::mark_offset_in_bytes());
Node* cas = new (C) StoreXConditionalNode(not_biased_ctrl, mem, adr, Node* cas = new StoreXConditionalNode(not_biased_ctrl, mem, adr,
proto_node, mark_node); proto_node, mark_node);
transform_later(cas); transform_later(cas);
Node* proj = transform_later( new (C) SCMemProjNode(cas)); Node* proj = transform_later(new SCMemProjNode(cas));
fast_lock_mem_phi->init_req(2, proj); fast_lock_mem_phi->init_req(2, proj);
// Second, check epoch bits. // Second, check epoch bits.
Node* rebiased_region = new (C) RegionNode(3); Node* rebiased_region = new RegionNode(3);
Node* old_phi = new (C) PhiNode( rebiased_region, TypeX_X); Node* old_phi = new PhiNode( rebiased_region, TypeX_X);
Node* new_phi = new (C) PhiNode( rebiased_region, TypeX_X); Node* new_phi = new PhiNode( rebiased_region, TypeX_X);
// Get slow path - mark word does NOT match epoch bits. // Get slow path - mark word does NOT match epoch bits.
Node* epoch_ctrl = opt_bits_test(ctrl, rebiased_region, 1, x_node, Node* epoch_ctrl = opt_bits_test(ctrl, rebiased_region, 1, x_node,
@ -2258,9 +2258,9 @@ void PhaseMacroExpand::expand_lock_node(LockNode *lock) {
Node* cmask = MakeConX(markOopDesc::biased_lock_mask_in_place | Node* cmask = MakeConX(markOopDesc::biased_lock_mask_in_place |
markOopDesc::age_mask_in_place | markOopDesc::age_mask_in_place |
markOopDesc::epoch_mask_in_place); markOopDesc::epoch_mask_in_place);
Node* old = transform_later(new (C) AndXNode(mark_node, cmask)); Node* old = transform_later(new AndXNode(mark_node, cmask));
cast_thread = transform_later(new (C) CastP2XNode(ctrl, thread)); cast_thread = transform_later(new CastP2XNode(ctrl, thread));
Node* new_mark = transform_later(new (C) OrXNode(cast_thread, old)); Node* new_mark = transform_later(new OrXNode(cast_thread, old));
old_phi->init_req(1, old); old_phi->init_req(1, old);
new_phi->init_req(1, new_mark); new_phi->init_req(1, new_mark);
@ -2270,10 +2270,9 @@ void PhaseMacroExpand::expand_lock_node(LockNode *lock) {
// Try to acquire the bias of the object using an atomic operation. // Try to acquire the bias of the object using an atomic operation.
// If this fails we will go in to the runtime to revoke the object's bias. // If this fails we will go in to the runtime to revoke the object's bias.
cas = new (C) StoreXConditionalNode(rebiased_region, mem, adr, cas = new StoreXConditionalNode(rebiased_region, mem, adr, new_phi, old_phi);
new_phi, old_phi);
transform_later(cas); transform_later(cas);
proj = transform_later( new (C) SCMemProjNode(cas)); proj = transform_later(new SCMemProjNode(cas));
// Get slow path - Failed to CAS. // Get slow path - Failed to CAS.
not_biased_ctrl = opt_bits_test(rebiased_region, region, 4, cas, 0, 0); not_biased_ctrl = opt_bits_test(rebiased_region, region, 4, cas, 0, 0);
@ -2281,8 +2280,8 @@ void PhaseMacroExpand::expand_lock_node(LockNode *lock) {
// region->in(4) is set to fast path - the object is rebiased to the current thread. // region->in(4) is set to fast path - the object is rebiased to the current thread.
// Failed to CAS. // Failed to CAS.
slow_path = new (C) RegionNode(3); slow_path = new RegionNode(3);
Node *slow_mem = new (C) PhiNode( slow_path, Type::MEMORY, TypeRawPtr::BOTTOM); Node *slow_mem = new PhiNode( slow_path, Type::MEMORY, TypeRawPtr::BOTTOM);
slow_path->init_req(1, not_biased_ctrl); // Capture slow-control slow_path->init_req(1, not_biased_ctrl); // Capture slow-control
slow_mem->init_req(1, proj); slow_mem->init_req(1, proj);
@ -2306,9 +2305,9 @@ void PhaseMacroExpand::expand_lock_node(LockNode *lock) {
lock->set_req(TypeFunc::Memory, slow_mem); lock->set_req(TypeFunc::Memory, slow_mem);
} else { } else {
region = new (C) RegionNode(3); region = new RegionNode(3);
// create a Phi for the memory state // create a Phi for the memory state
mem_phi = new (C) PhiNode( region, Type::MEMORY, TypeRawPtr::BOTTOM); mem_phi = new PhiNode( region, Type::MEMORY, TypeRawPtr::BOTTOM);
// Optimize test; set region slot 2 // Optimize test; set region slot 2
slow_path = opt_bits_test(ctrl, region, 2, flock, 0, 0); slow_path = opt_bits_test(ctrl, region, 2, flock, 0, 0);
@ -2339,7 +2338,7 @@ void PhaseMacroExpand::expand_lock_node(LockNode *lock) {
transform_later(region); transform_later(region);
_igvn.replace_node(_fallthroughproj, region); _igvn.replace_node(_fallthroughproj, region);
Node *memproj = transform_later( new(C) ProjNode(call, TypeFunc::Memory) ); Node *memproj = transform_later(new ProjNode(call, TypeFunc::Memory));
mem_phi->init_req(1, memproj ); mem_phi->init_req(1, memproj );
transform_later(mem_phi); transform_later(mem_phi);
_igvn.replace_node(_memproj_fallthrough, mem_phi); _igvn.replace_node(_memproj_fallthrough, mem_phi);
@ -2364,9 +2363,9 @@ void PhaseMacroExpand::expand_unlock_node(UnlockNode *unlock) {
if (UseOptoBiasInlining) { if (UseOptoBiasInlining) {
// Check for biased locking unlock case, which is a no-op. // Check for biased locking unlock case, which is a no-op.
// See the full description in MacroAssembler::biased_locking_exit(). // See the full description in MacroAssembler::biased_locking_exit().
region = new (C) RegionNode(4); region = new RegionNode(4);
// create a Phi for the memory state // create a Phi for the memory state
mem_phi = new (C) PhiNode( region, Type::MEMORY, TypeRawPtr::BOTTOM); mem_phi = new PhiNode( region, Type::MEMORY, TypeRawPtr::BOTTOM);
mem_phi->init_req(3, mem); mem_phi->init_req(3, mem);
Node* mark_node = make_load(ctrl, mem, obj, oopDesc::mark_offset_in_bytes(), TypeX_X, TypeX_X->basic_type()); Node* mark_node = make_load(ctrl, mem, obj, oopDesc::mark_offset_in_bytes(), TypeX_X, TypeX_X->basic_type());
@ -2374,12 +2373,12 @@ void PhaseMacroExpand::expand_unlock_node(UnlockNode *unlock) {
markOopDesc::biased_lock_mask_in_place, markOopDesc::biased_lock_mask_in_place,
markOopDesc::biased_lock_pattern); markOopDesc::biased_lock_pattern);
} else { } else {
region = new (C) RegionNode(3); region = new RegionNode(3);
// create a Phi for the memory state // create a Phi for the memory state
mem_phi = new (C) PhiNode( region, Type::MEMORY, TypeRawPtr::BOTTOM); mem_phi = new PhiNode( region, Type::MEMORY, TypeRawPtr::BOTTOM);
} }
FastUnlockNode *funlock = new (C) FastUnlockNode( ctrl, obj, box ); FastUnlockNode *funlock = new FastUnlockNode( ctrl, obj, box );
funlock = transform_later( funlock )->as_FastUnlock(); funlock = transform_later( funlock )->as_FastUnlock();
// Optimize test; set region slot 2 // Optimize test; set region slot 2
Node *slow_path = opt_bits_test(ctrl, region, 2, funlock, 0, 0); Node *slow_path = opt_bits_test(ctrl, region, 2, funlock, 0, 0);
@ -2404,7 +2403,7 @@ void PhaseMacroExpand::expand_unlock_node(UnlockNode *unlock) {
transform_later(region); transform_later(region);
_igvn.replace_node(_fallthroughproj, region); _igvn.replace_node(_fallthroughproj, region);
Node *memproj = transform_later( new(C) ProjNode(call, TypeFunc::Memory) ); Node *memproj = transform_later(new ProjNode(call, TypeFunc::Memory) );
mem_phi->init_req(1, memproj ); mem_phi->init_req(1, memproj );
mem_phi->init_req(2, mem); mem_phi->init_req(2, mem);
transform_later(mem_phi); transform_later(mem_phi);

2
hotspot/src/share/vm/opto/macro.hpp
View file

@ -52,7 +52,7 @@ private:
return basic_plus_adr(base, base, offset); return basic_plus_adr(base, base, offset);
} }
Node* basic_plus_adr(Node* base, Node* ptr, Node* offset) { Node* basic_plus_adr(Node* base, Node* ptr, Node* offset) {
Node* adr = new (C) AddPNode(base, ptr, offset); Node* adr = new AddPNode(base, ptr, offset);
return transform_later(adr); return transform_later(adr);
} }
Node* transform_later(Node* n) { Node* transform_later(Node* n) {

44
hotspot/src/share/vm/opto/matcher.cpp
View file

@ -751,7 +751,7 @@ void Matcher::Fixup_Save_On_Entry( ) {
tail_call_rms[tail_call_edge_cnt].Insert(OptoReg::Name(i+1)); tail_call_rms[tail_call_edge_cnt].Insert(OptoReg::Name(i+1));
tail_jump_rms[tail_jump_edge_cnt].Insert(OptoReg::Name(i+1)); tail_jump_rms[tail_jump_edge_cnt].Insert(OptoReg::Name(i+1));
halt_rms [ halt_edge_cnt].Insert(OptoReg::Name(i+1)); halt_rms [ halt_edge_cnt].Insert(OptoReg::Name(i+1));
mproj = new (C) MachProjNode( start, proj_cnt, ret_rms[ret_edge_cnt], Op_RegD ); mproj = new MachProjNode( start, proj_cnt, ret_rms[ret_edge_cnt], Op_RegD );
proj_cnt += 2; // Skip 2 for doubles proj_cnt += 2; // Skip 2 for doubles
} }
else if( (i&1) == 1 && // Else check for high half of double else if( (i&1) == 1 && // Else check for high half of double
@ -777,7 +777,7 @@ void Matcher::Fixup_Save_On_Entry( ) {
tail_call_rms[tail_call_edge_cnt].Insert(OptoReg::Name(i+1)); tail_call_rms[tail_call_edge_cnt].Insert(OptoReg::Name(i+1));
tail_jump_rms[tail_jump_edge_cnt].Insert(OptoReg::Name(i+1)); tail_jump_rms[tail_jump_edge_cnt].Insert(OptoReg::Name(i+1));
halt_rms [ halt_edge_cnt].Insert(OptoReg::Name(i+1)); halt_rms [ halt_edge_cnt].Insert(OptoReg::Name(i+1));
mproj = new (C) MachProjNode( start, proj_cnt, ret_rms[ret_edge_cnt], Op_RegL ); mproj = new MachProjNode( start, proj_cnt, ret_rms[ret_edge_cnt], Op_RegL );
proj_cnt += 2; // Skip 2 for longs proj_cnt += 2; // Skip 2 for longs
} }
else if( (i&1) == 1 && // Else check for high half of long else if( (i&1) == 1 && // Else check for high half of long
@ -792,7 +792,7 @@ void Matcher::Fixup_Save_On_Entry( ) {
mproj = C->top(); mproj = C->top();
} else { } else {
// Make a projection for it off the Start // Make a projection for it off the Start
mproj = new (C) MachProjNode( start, proj_cnt++, ret_rms[ret_edge_cnt], _register_save_type[i] ); mproj = new MachProjNode( start, proj_cnt++, ret_rms[ret_edge_cnt], _register_save_type[i] );
} }
ret_edge_cnt ++; ret_edge_cnt ++;
@ -845,13 +845,13 @@ void Matcher::init_spill_mask( Node *ret ) {
// Compute generic short-offset Loads // Compute generic short-offset Loads
#ifdef _LP64 #ifdef _LP64
MachNode *spillCP = match_tree(new (C) LoadNNode(NULL,mem,fp,atp,TypeInstPtr::BOTTOM,MemNode::unordered)); MachNode *spillCP = match_tree(new LoadNNode(NULL,mem,fp,atp,TypeInstPtr::BOTTOM,MemNode::unordered));
#endif #endif
MachNode *spillI = match_tree(new (C) LoadINode(NULL,mem,fp,atp,TypeInt::INT,MemNode::unordered)); MachNode *spillI = match_tree(new LoadINode(NULL,mem,fp,atp,TypeInt::INT,MemNode::unordered));
MachNode *spillL = match_tree(new (C) LoadLNode(NULL,mem,fp,atp,TypeLong::LONG,MemNode::unordered,false)); MachNode *spillL = match_tree(new LoadLNode(NULL,mem,fp,atp,TypeLong::LONG,MemNode::unordered,false));
MachNode *spillF = match_tree(new (C) LoadFNode(NULL,mem,fp,atp,Type::FLOAT,MemNode::unordered)); MachNode *spillF = match_tree(new LoadFNode(NULL,mem,fp,atp,Type::FLOAT,MemNode::unordered));
MachNode *spillD = match_tree(new (C) LoadDNode(NULL,mem,fp,atp,Type::DOUBLE,MemNode::unordered)); MachNode *spillD = match_tree(new LoadDNode(NULL,mem,fp,atp,Type::DOUBLE,MemNode::unordered));
MachNode *spillP = match_tree(new (C) LoadPNode(NULL,mem,fp,atp,TypeInstPtr::BOTTOM,MemNode::unordered)); MachNode *spillP = match_tree(new LoadPNode(NULL,mem,fp,atp,TypeInstPtr::BOTTOM,MemNode::unordered));
assert(spillI != NULL && spillL != NULL && spillF != NULL && assert(spillI != NULL && spillL != NULL && spillF != NULL &&
spillD != NULL && spillP != NULL, ""); spillD != NULL && spillP != NULL, "");
// Get the ADLC notion of the right regmask, for each basic type. // Get the ADLC notion of the right regmask, for each basic type.
@ -867,19 +867,19 @@ void Matcher::init_spill_mask( Node *ret ) {
// Vector regmasks. // Vector regmasks.
if (Matcher::vector_size_supported(T_BYTE,4)) { if (Matcher::vector_size_supported(T_BYTE,4)) {
TypeVect::VECTS = TypeVect::make(T_BYTE, 4); TypeVect::VECTS = TypeVect::make(T_BYTE, 4);
MachNode *spillVectS = match_tree(new (C) LoadVectorNode(NULL,mem,fp,atp,TypeVect::VECTS)); MachNode *spillVectS = match_tree(new LoadVectorNode(NULL,mem,fp,atp,TypeVect::VECTS));
idealreg2regmask[Op_VecS] = &spillVectS->out_RegMask(); idealreg2regmask[Op_VecS] = &spillVectS->out_RegMask();
} }
if (Matcher::vector_size_supported(T_FLOAT,2)) { if (Matcher::vector_size_supported(T_FLOAT,2)) {
MachNode *spillVectD = match_tree(new (C) LoadVectorNode(NULL,mem,fp,atp,TypeVect::VECTD)); MachNode *spillVectD = match_tree(new LoadVectorNode(NULL,mem,fp,atp,TypeVect::VECTD));
idealreg2regmask[Op_VecD] = &spillVectD->out_RegMask(); idealreg2regmask[Op_VecD] = &spillVectD->out_RegMask();
} }
if (Matcher::vector_size_supported(T_FLOAT,4)) { if (Matcher::vector_size_supported(T_FLOAT,4)) {
MachNode *spillVectX = match_tree(new (C) LoadVectorNode(NULL,mem,fp,atp,TypeVect::VECTX)); MachNode *spillVectX = match_tree(new LoadVectorNode(NULL,mem,fp,atp,TypeVect::VECTX));
idealreg2regmask[Op_VecX] = &spillVectX->out_RegMask(); idealreg2regmask[Op_VecX] = &spillVectX->out_RegMask();
} }
if (Matcher::vector_size_supported(T_FLOAT,8)) { if (Matcher::vector_size_supported(T_FLOAT,8)) {
MachNode *spillVectY = match_tree(new (C) LoadVectorNode(NULL,mem,fp,atp,TypeVect::VECTY)); MachNode *spillVectY = match_tree(new LoadVectorNode(NULL,mem,fp,atp,TypeVect::VECTY));
idealreg2regmask[Op_VecY] = &spillVectY->out_RegMask(); idealreg2regmask[Op_VecY] = &spillVectY->out_RegMask();
} }
} }
@ -1319,7 +1319,7 @@ MachNode *Matcher::match_sfpt( SafePointNode *sfpt ) {
// is excluded on the max-per-method basis, debug info cannot land in // is excluded on the max-per-method basis, debug info cannot land in
// this killed area. // this killed area.
uint r_cnt = mcall->tf()->range()->cnt(); uint r_cnt = mcall->tf()->range()->cnt();
MachProjNode *proj = new (C) MachProjNode( mcall, r_cnt+10000, RegMask::Empty, MachProjNode::fat_proj ); MachProjNode *proj = new MachProjNode( mcall, r_cnt+10000, RegMask::Empty, MachProjNode::fat_proj );
if (!RegMask::can_represent_arg(OptoReg::Name(out_arg_limit_per_call-1))) { if (!RegMask::can_represent_arg(OptoReg::Name(out_arg_limit_per_call-1))) {
C->record_method_not_compilable_all_tiers("unsupported outgoing calling sequence"); C->record_method_not_compilable_all_tiers("unsupported outgoing calling sequence");
} else { } else {
@ -2274,7 +2274,7 @@ void Matcher::find_shared( Node *n ) {
case Op_CompareAndSwapN: { // Convert trinary to binary-tree case Op_CompareAndSwapN: { // Convert trinary to binary-tree
Node *newval = n->in(MemNode::ValueIn ); Node *newval = n->in(MemNode::ValueIn );
Node *oldval = n->in(LoadStoreConditionalNode::ExpectedIn); Node *oldval = n->in(LoadStoreConditionalNode::ExpectedIn);
Node *pair = new (C) BinaryNode( oldval, newval ); Node *pair = new BinaryNode( oldval, newval );
n->set_req(MemNode::ValueIn,pair); n->set_req(MemNode::ValueIn,pair);
n->del_req(LoadStoreConditionalNode::ExpectedIn); n->del_req(LoadStoreConditionalNode::ExpectedIn);
break; break;
@ -2289,22 +2289,22 @@ void Matcher::find_shared( Node *n ) {
// we could move this code up next to the graph reshaping for IfNodes // we could move this code up next to the graph reshaping for IfNodes
// or vice-versa, but I do not want to debug this for Ladybird. // or vice-versa, but I do not want to debug this for Ladybird.
// 10/2/2000 CNC. // 10/2/2000 CNC.
Node *pair1 = new (C) BinaryNode(n->in(1),n->in(1)->in(1)); Node *pair1 = new BinaryNode(n->in(1),n->in(1)->in(1));
n->set_req(1,pair1); n->set_req(1,pair1);
Node *pair2 = new (C) BinaryNode(n->in(2),n->in(3)); Node *pair2 = new BinaryNode(n->in(2),n->in(3));
n->set_req(2,pair2); n->set_req(2,pair2);
n->del_req(3); n->del_req(3);
break; break;
} }
case Op_LoopLimit: { case Op_LoopLimit: {
Node *pair1 = new (C) BinaryNode(n->in(1),n->in(2)); Node *pair1 = new BinaryNode(n->in(1),n->in(2));
n->set_req(1,pair1); n->set_req(1,pair1);
n->set_req(2,n->in(3)); n->set_req(2,n->in(3));
n->del_req(3); n->del_req(3);
break; break;
} }
case Op_StrEquals: { case Op_StrEquals: {
Node *pair1 = new (C) BinaryNode(n->in(2),n->in(3)); Node *pair1 = new BinaryNode(n->in(2),n->in(3));
n->set_req(2,pair1); n->set_req(2,pair1);
n->set_req(3,n->in(4)); n->set_req(3,n->in(4));
n->del_req(4); n->del_req(4);
@ -2312,9 +2312,9 @@ void Matcher::find_shared( Node *n ) {
} }
case Op_StrComp: case Op_StrComp:
case Op_StrIndexOf: { case Op_StrIndexOf: {
Node *pair1 = new (C) BinaryNode(n->in(2),n->in(3)); Node *pair1 = new BinaryNode(n->in(2),n->in(3));
n->set_req(2,pair1); n->set_req(2,pair1);
Node *pair2 = new (C) BinaryNode(n->in(4),n->in(5)); Node *pair2 = new BinaryNode(n->in(4),n->in(5));
n->set_req(3,pair2); n->set_req(3,pair2);
n->del_req(5); n->del_req(5);
n->del_req(4); n->del_req(4);
@ -2322,7 +2322,7 @@ void Matcher::find_shared( Node *n ) {
} }
case Op_EncodeISOArray: { case Op_EncodeISOArray: {
// Restructure into a binary tree for Matching. // Restructure into a binary tree for Matching.
Node* pair = new (C) BinaryNode(n->in(3), n->in(4)); Node* pair = new BinaryNode(n->in(3), n->in(4));
n->set_req(3, pair); n->set_req(3, pair);
n->del_req(4); n->del_req(4);
break; break;

142
hotspot/src/share/vm/opto/memnode.cpp
View file

@ -908,25 +908,25 @@ Node *LoadNode::make(PhaseGVN& gvn, Node *ctl, Node *mem, Node *adr, const TypeP
rt->isa_oopptr() || is_immutable_value(adr), rt->isa_oopptr() || is_immutable_value(adr),
"raw memory operations should have control edge"); "raw memory operations should have control edge");
switch (bt) { switch (bt) {
case T_BOOLEAN: return new (C) LoadUBNode(ctl, mem, adr, adr_type, rt->is_int(), mo); case T_BOOLEAN: return new LoadUBNode(ctl, mem, adr, adr_type, rt->is_int(), mo);
case T_BYTE: return new (C) LoadBNode (ctl, mem, adr, adr_type, rt->is_int(), mo); case T_BYTE: return new LoadBNode (ctl, mem, adr, adr_type, rt->is_int(), mo);
case T_INT: return new (C) LoadINode (ctl, mem, adr, adr_type, rt->is_int(), mo); case T_INT: return new LoadINode (ctl, mem, adr, adr_type, rt->is_int(), mo);
case T_CHAR: return new (C) LoadUSNode(ctl, mem, adr, adr_type, rt->is_int(), mo); case T_CHAR: return new LoadUSNode(ctl, mem, adr, adr_type, rt->is_int(), mo);
case T_SHORT: return new (C) LoadSNode (ctl, mem, adr, adr_type, rt->is_int(), mo); case T_SHORT: return new LoadSNode (ctl, mem, adr, adr_type, rt->is_int(), mo);
case T_LONG: return new (C) LoadLNode (ctl, mem, adr, adr_type, rt->is_long(), mo); case T_LONG: return new LoadLNode (ctl, mem, adr, adr_type, rt->is_long(), mo);
case T_FLOAT: return new (C) LoadFNode (ctl, mem, adr, adr_type, rt, mo); case T_FLOAT: return new LoadFNode (ctl, mem, adr, adr_type, rt, mo);
case T_DOUBLE: return new (C) LoadDNode (ctl, mem, adr, adr_type, rt, mo); case T_DOUBLE: return new LoadDNode (ctl, mem, adr, adr_type, rt, mo);
case T_ADDRESS: return new (C) LoadPNode (ctl, mem, adr, adr_type, rt->is_ptr(), mo); case T_ADDRESS: return new LoadPNode (ctl, mem, adr, adr_type, rt->is_ptr(), mo);
case T_OBJECT: case T_OBJECT:
#ifdef _LP64 #ifdef _LP64
if (adr->bottom_type()->is_ptr_to_narrowoop()) { if (adr->bottom_type()->is_ptr_to_narrowoop()) {
Node* load = gvn.transform(new (C) LoadNNode(ctl, mem, adr, adr_type, rt->make_narrowoop(), mo)); Node* load = gvn.transform(new LoadNNode(ctl, mem, adr, adr_type, rt->make_narrowoop(), mo));
return new (C) DecodeNNode(load, load->bottom_type()->make_ptr()); return new DecodeNNode(load, load->bottom_type()->make_ptr());
} else } else
#endif #endif
{ {
assert(!adr->bottom_type()->is_ptr_to_narrowoop() && !adr->bottom_type()->is_ptr_to_narrowklass(), "should have got back a narrow oop"); assert(!adr->bottom_type()->is_ptr_to_narrowoop() && !adr->bottom_type()->is_ptr_to_narrowklass(), "should have got back a narrow oop");
return new (C) LoadPNode(ctl, mem, adr, adr_type, rt->is_oopptr(), mo); return new LoadPNode(ctl, mem, adr, adr_type, rt->is_oopptr(), mo);
} }
} }
ShouldNotReachHere(); ShouldNotReachHere();
@ -935,12 +935,12 @@ Node *LoadNode::make(PhaseGVN& gvn, Node *ctl, Node *mem, Node *adr, const TypeP
LoadLNode* LoadLNode::make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, const Type* rt, MemOrd mo) { 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; bool require_atomic = true;
return new (C) LoadLNode(ctl, mem, adr, adr_type, rt->is_long(), mo, require_atomic); 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) { 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; bool require_atomic = true;
return new (C) LoadDNode(ctl, mem, adr, adr_type, rt, mo, require_atomic); return new LoadDNode(ctl, mem, adr, adr_type, rt, mo, require_atomic);
} }
@ -1228,33 +1228,33 @@ Node* LoadNode::eliminate_autobox(PhaseGVN* phase) {
// Add up all the offsets making of the address of the load // Add up all the offsets making of the address of the load
Node* result = elements[0]; Node* result = elements[0];
for (int i = 1; i < count; i++) { for (int i = 1; i < count; i++) {
result = phase->transform(new (phase->C) AddXNode(result, elements[i])); result = phase->transform(new AddXNode(result, elements[i]));
} }
// Remove the constant offset from the address and then // Remove the constant offset from the address and then
result = phase->transform(new (phase->C) AddXNode(result, phase->MakeConX(-(int)offset))); result = phase->transform(new AddXNode(result, phase->MakeConX(-(int)offset)));
// remove the scaling of the offset to recover the original index. // remove the scaling of the offset to recover the original index.
if (result->Opcode() == Op_LShiftX && result->in(2) == phase->intcon(shift)) { if (result->Opcode() == Op_LShiftX && result->in(2) == phase->intcon(shift)) {
// Peel the shift off directly but wrap it in a dummy node // Peel the shift off directly but wrap it in a dummy node
// since Ideal can't return existing nodes // since Ideal can't return existing nodes
result = new (phase->C) RShiftXNode(result->in(1), phase->intcon(0)); result = new RShiftXNode(result->in(1), phase->intcon(0));
} else if (result->is_Add() && result->in(2)->is_Con() && } else if (result->is_Add() && result->in(2)->is_Con() &&
result->in(1)->Opcode() == Op_LShiftX && result->in(1)->Opcode() == Op_LShiftX &&
result->in(1)->in(2) == phase->intcon(shift)) { result->in(1)->in(2) == phase->intcon(shift)) {
// We can't do general optimization: ((X<<Z) + Y) >> Z ==> X + (Y>>Z) // We can't do general optimization: ((X<<Z) + Y) >> Z ==> X + (Y>>Z)
// but for boxing cache access we know that X<<Z will not overflow // but for boxing cache access we know that X<<Z will not overflow
// (there is range check) so we do this optimizatrion by hand here. // (there is range check) so we do this optimizatrion by hand here.
Node* add_con = new (phase->C) RShiftXNode(result->in(2), phase->intcon(shift)); Node* add_con = new RShiftXNode(result->in(2), phase->intcon(shift));
result = new (phase->C) AddXNode(result->in(1)->in(1), phase->transform(add_con)); result = new AddXNode(result->in(1)->in(1), phase->transform(add_con));
} else { } else {
result = new (phase->C) RShiftXNode(result, phase->intcon(shift)); result = new RShiftXNode(result, phase->intcon(shift));
} }
#ifdef _LP64 #ifdef _LP64
if (bt != T_LONG) { if (bt != T_LONG) {
result = new (phase->C) ConvL2INode(phase->transform(result)); result = new ConvL2INode(phase->transform(result));
} }
#else #else
if (bt == T_LONG) { if (bt == T_LONG) {
result = new (phase->C) ConvI2LNode(phase->transform(result)); result = new ConvI2LNode(phase->transform(result));
} }
#endif #endif
return result; return result;
@ -1385,7 +1385,7 @@ Node *LoadNode::split_through_phi(PhaseGVN *phase) {
this_iid = base->_idx; this_iid = base->_idx;
} }
PhaseIterGVN* igvn = phase->is_IterGVN(); PhaseIterGVN* igvn = phase->is_IterGVN();
Node* phi = new (C) PhiNode(region, this_type, NULL, this_iid, this_index, this_offset); Node* phi = new PhiNode(region, this_type, NULL, this_iid, this_index, this_offset);
for (uint i = 1; i < region->req(); i++) { for (uint i = 1; i < region->req(); i++) {
Node* x; Node* x;
Node* the_clone = NULL; Node* the_clone = NULL;
@ -1408,7 +1408,7 @@ Node *LoadNode::split_through_phi(PhaseGVN *phase) {
} }
if (base_is_phi && (base->in(0) == region)) { if (base_is_phi && (base->in(0) == region)) {
Node* base_x = base->in(i); // Clone address for loads from boxed objects. Node* base_x = base->in(i); // Clone address for loads from boxed objects.
Node* adr_x = phase->transform(new (C) AddPNode(base_x,base_x,address->in(AddPNode::Offset))); Node* adr_x = phase->transform(new AddPNode(base_x,base_x,address->in(AddPNode::Offset)));
x->set_req(Address, adr_x); x->set_req(Address, adr_x);
} }
} }
@ -1897,8 +1897,8 @@ Node *LoadBNode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node* mem = in(MemNode::Memory); Node* mem = in(MemNode::Memory);
Node* value = can_see_stored_value(mem,phase); Node* value = can_see_stored_value(mem,phase);
if( value && !phase->type(value)->higher_equal( _type ) ) { if( value && !phase->type(value)->higher_equal( _type ) ) {
Node *result = phase->transform( new (phase->C) LShiftINode(value, phase->intcon(24)) ); Node *result = phase->transform( new LShiftINode(value, phase->intcon(24)) );
return new (phase->C) RShiftINode(result, phase->intcon(24)); return new RShiftINode(result, phase->intcon(24));
} }
// Identity call will handle the case where truncation is not needed. // Identity call will handle the case where truncation is not needed.
return LoadNode::Ideal(phase, can_reshape); return LoadNode::Ideal(phase, can_reshape);
@ -1929,7 +1929,7 @@ Node* LoadUBNode::Ideal(PhaseGVN* phase, bool can_reshape) {
Node* mem = in(MemNode::Memory); Node* mem = in(MemNode::Memory);
Node* value = can_see_stored_value(mem, phase); Node* value = can_see_stored_value(mem, phase);
if (value && !phase->type(value)->higher_equal(_type)) if (value && !phase->type(value)->higher_equal(_type))
return new (phase->C) AndINode(value, phase->intcon(0xFF)); return new AndINode(value, phase->intcon(0xFF));
// Identity call will handle the case where truncation is not needed. // Identity call will handle the case where truncation is not needed.
return LoadNode::Ideal(phase, can_reshape); return LoadNode::Ideal(phase, can_reshape);
} }
@ -1959,7 +1959,7 @@ Node *LoadUSNode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node* mem = in(MemNode::Memory); Node* mem = in(MemNode::Memory);
Node* value = can_see_stored_value(mem,phase); Node* value = can_see_stored_value(mem,phase);
if( value && !phase->type(value)->higher_equal( _type ) ) if( value && !phase->type(value)->higher_equal( _type ) )
return new (phase->C) AndINode(value,phase->intcon(0xFFFF)); return new AndINode(value,phase->intcon(0xFFFF));
// Identity call will handle the case where truncation is not needed. // Identity call will handle the case where truncation is not needed.
return LoadNode::Ideal(phase, can_reshape); return LoadNode::Ideal(phase, can_reshape);
} }
@ -1989,8 +1989,8 @@ Node *LoadSNode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node* mem = in(MemNode::Memory); Node* mem = in(MemNode::Memory);
Node* value = can_see_stored_value(mem,phase); Node* value = can_see_stored_value(mem,phase);
if( value && !phase->type(value)->higher_equal( _type ) ) { if( value && !phase->type(value)->higher_equal( _type ) ) {
Node *result = phase->transform( new (phase->C) LShiftINode(value, phase->intcon(16)) ); Node *result = phase->transform( new LShiftINode(value, phase->intcon(16)) );
return new (phase->C) RShiftINode(result, phase->intcon(16)); return new RShiftINode(result, phase->intcon(16));
} }
// Identity call will handle the case where truncation is not needed. // Identity call will handle the case where truncation is not needed.
return LoadNode::Ideal(phase, can_reshape); return LoadNode::Ideal(phase, can_reshape);
@ -2022,12 +2022,12 @@ Node *LoadKlassNode::make( PhaseGVN& gvn, Node *mem, Node *adr, const TypePtr* a
#ifdef _LP64 #ifdef _LP64
if (adr_type->is_ptr_to_narrowklass()) { if (adr_type->is_ptr_to_narrowklass()) {
assert(UseCompressedClassPointers, "no compressed klasses"); assert(UseCompressedClassPointers, "no compressed klasses");
Node* load_klass = gvn.transform(new (C) LoadNKlassNode(ctl, mem, adr, at, tk->make_narrowklass(), MemNode::unordered)); Node* load_klass = gvn.transform(new LoadNKlassNode(ctl, mem, adr, at, tk->make_narrowklass(), MemNode::unordered));
return new (C) DecodeNKlassNode(load_klass, load_klass->bottom_type()->make_ptr()); return new DecodeNKlassNode(load_klass, load_klass->bottom_type()->make_ptr());
} }
#endif #endif
assert(!adr_type->is_ptr_to_narrowklass() && !adr_type->is_ptr_to_narrowoop(), "should have got back a narrow oop"); assert(!adr_type->is_ptr_to_narrowklass() && !adr_type->is_ptr_to_narrowoop(), "should have got back a narrow oop");
return new (C) LoadKlassNode(ctl, mem, adr, at, tk, MemNode::unordered); return new LoadKlassNode(ctl, mem, adr, at, tk, MemNode::unordered);
} }
//------------------------------Value------------------------------------------ //------------------------------Value------------------------------------------
@ -2255,7 +2255,7 @@ Node* LoadNKlassNode::Identity( PhaseTransform *phase ) {
if( t->isa_narrowklass()) return x; if( t->isa_narrowklass()) return x;
assert (!t->isa_narrowoop(), "no narrow oop here"); assert (!t->isa_narrowoop(), "no narrow oop here");
return phase->transform(new (phase->C) EncodePKlassNode(x, t->make_narrowklass())); return phase->transform(new EncodePKlassNode(x, t->make_narrowklass()));
} }
//------------------------------Value----------------------------------------- //------------------------------Value-----------------------------------------
@ -2350,29 +2350,29 @@ StoreNode* StoreNode::make(PhaseGVN& gvn, Node* ctl, Node* mem, Node* adr, const
switch (bt) { switch (bt) {
case T_BOOLEAN: case T_BOOLEAN:
case T_BYTE: return new (C) StoreBNode(ctl, mem, adr, adr_type, val, mo); case T_BYTE: return new StoreBNode(ctl, mem, adr, adr_type, val, mo);
case T_INT: return new (C) StoreINode(ctl, mem, adr, adr_type, val, mo); case T_INT: return new StoreINode(ctl, mem, adr, adr_type, val, mo);
case T_CHAR: case T_CHAR:
case T_SHORT: return new (C) StoreCNode(ctl, mem, adr, adr_type, val, mo); case T_SHORT: return new StoreCNode(ctl, mem, adr, adr_type, val, mo);
case T_LONG: return new (C) StoreLNode(ctl, mem, adr, adr_type, val, mo); case T_LONG: return new StoreLNode(ctl, mem, adr, adr_type, val, mo);
case T_FLOAT: return new (C) StoreFNode(ctl, mem, adr, adr_type, val, mo); case T_FLOAT: return new StoreFNode(ctl, mem, adr, adr_type, val, mo);
case T_DOUBLE: return new (C) StoreDNode(ctl, mem, adr, adr_type, val, mo); case T_DOUBLE: return new StoreDNode(ctl, mem, adr, adr_type, val, mo);
case T_METADATA: case T_METADATA:
case T_ADDRESS: case T_ADDRESS:
case T_OBJECT: case T_OBJECT:
#ifdef _LP64 #ifdef _LP64
if (adr->bottom_type()->is_ptr_to_narrowoop()) { if (adr->bottom_type()->is_ptr_to_narrowoop()) {
val = gvn.transform(new (C) EncodePNode(val, val->bottom_type()->make_narrowoop())); val = gvn.transform(new EncodePNode(val, val->bottom_type()->make_narrowoop()));
return new (C) StoreNNode(ctl, mem, adr, adr_type, val, mo); return new StoreNNode(ctl, mem, adr, adr_type, val, mo);
} else if (adr->bottom_type()->is_ptr_to_narrowklass() || } else if (adr->bottom_type()->is_ptr_to_narrowklass() ||
(UseCompressedClassPointers && val->bottom_type()->isa_klassptr() && (UseCompressedClassPointers && val->bottom_type()->isa_klassptr() &&
adr->bottom_type()->isa_rawptr())) { adr->bottom_type()->isa_rawptr())) {
val = gvn.transform(new (C) EncodePKlassNode(val, val->bottom_type()->make_narrowklass())); val = gvn.transform(new EncodePKlassNode(val, val->bottom_type()->make_narrowklass()));
return new (C) StoreNKlassNode(ctl, mem, adr, adr_type, val, mo); return new StoreNKlassNode(ctl, mem, adr, adr_type, val, mo);
} }
#endif #endif
{ {
return new (C) StorePNode(ctl, mem, adr, adr_type, val, mo); return new StorePNode(ctl, mem, adr, adr_type, val, mo);
} }
} }
ShouldNotReachHere(); ShouldNotReachHere();
@ -2381,12 +2381,12 @@ StoreNode* StoreNode::make(PhaseGVN& gvn, Node* ctl, Node* mem, Node* adr, const
StoreLNode* StoreLNode::make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val, MemOrd mo) { StoreLNode* StoreLNode::make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val, MemOrd mo) {
bool require_atomic = true; bool require_atomic = true;
return new (C) StoreLNode(ctl, mem, adr, adr_type, val, mo, require_atomic); 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) { StoreDNode* StoreDNode::make_atomic(Compile *C, Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val, MemOrd mo) {
bool require_atomic = true; bool require_atomic = true;
return new (C) StoreDNode(ctl, mem, adr, adr_type, val, mo, require_atomic); return new StoreDNode(ctl, mem, adr, adr_type, val, mo, require_atomic);
} }
@ -2779,12 +2779,12 @@ Node *ClearArrayNode::Ideal(PhaseGVN *phase, bool can_reshape){
Node *zero = phase->makecon(TypeLong::ZERO); Node *zero = phase->makecon(TypeLong::ZERO);
Node *off = phase->MakeConX(BytesPerLong); Node *off = phase->MakeConX(BytesPerLong);
mem = new (phase->C) StoreLNode(in(0),mem,adr,atp,zero,MemNode::unordered,false); mem = new StoreLNode(in(0),mem,adr,atp,zero,MemNode::unordered,false);
count--; count--;
while( count-- ) { while( count-- ) {
mem = phase->transform(mem); mem = phase->transform(mem);
adr = phase->transform(new (phase->C) AddPNode(base,adr,off)); adr = phase->transform(new AddPNode(base,adr,off));
mem = new (phase->C) StoreLNode(in(0),mem,adr,atp,zero,MemNode::unordered,false); mem = new StoreLNode(in(0),mem,adr,atp,zero,MemNode::unordered,false);
} }
return mem; return mem;
} }
@ -2825,7 +2825,7 @@ Node* ClearArrayNode::clear_memory(Node* ctl, Node* mem, Node* dest,
int unit = BytesPerLong; int unit = BytesPerLong;
if ((offset % unit) != 0) { if ((offset % unit) != 0) {
Node* adr = new (C) AddPNode(dest, dest, phase->MakeConX(offset)); Node* adr = new AddPNode(dest, dest, phase->MakeConX(offset));
adr = phase->transform(adr); adr = phase->transform(adr);
const TypePtr* atp = TypeRawPtr::BOTTOM; const TypePtr* atp = TypeRawPtr::BOTTOM;
mem = StoreNode::make(*phase, ctl, mem, adr, atp, phase->zerocon(T_INT), T_INT, MemNode::unordered); mem = StoreNode::make(*phase, ctl, mem, adr, atp, phase->zerocon(T_INT), T_INT, MemNode::unordered);
@ -2855,14 +2855,14 @@ Node* ClearArrayNode::clear_memory(Node* ctl, Node* mem, Node* dest,
// Scale to the unit required by the CPU: // Scale to the unit required by the CPU:
if (!Matcher::init_array_count_is_in_bytes) { if (!Matcher::init_array_count_is_in_bytes) {
Node* shift = phase->intcon(exact_log2(unit)); Node* shift = phase->intcon(exact_log2(unit));
zbase = phase->transform( new(C) URShiftXNode(zbase, shift) ); zbase = phase->transform(new URShiftXNode(zbase, shift) );
zend = phase->transform( new(C) URShiftXNode(zend, shift) ); zend = phase->transform(new URShiftXNode(zend, shift) );
} }
// Bulk clear double-words // Bulk clear double-words
Node* zsize = phase->transform( new(C) SubXNode(zend, zbase) ); Node* zsize = phase->transform(new SubXNode(zend, zbase) );
Node* adr = phase->transform( new(C) AddPNode(dest, dest, start_offset) ); Node* adr = phase->transform(new AddPNode(dest, dest, start_offset) );
mem = new (C) ClearArrayNode(ctl, mem, zsize, adr); mem = new ClearArrayNode(ctl, mem, zsize, adr);
return phase->transform(mem); return phase->transform(mem);
} }
@ -2886,7 +2886,7 @@ Node* ClearArrayNode::clear_memory(Node* ctl, Node* mem, Node* dest,
start_offset, phase->MakeConX(done_offset), phase); start_offset, phase->MakeConX(done_offset), phase);
} }
if (done_offset < end_offset) { // emit the final 32-bit store if (done_offset < end_offset) { // emit the final 32-bit store
Node* adr = new (C) AddPNode(dest, dest, phase->MakeConX(done_offset)); Node* adr = new AddPNode(dest, dest, phase->MakeConX(done_offset));
adr = phase->transform(adr); adr = phase->transform(adr);
const TypePtr* atp = TypeRawPtr::BOTTOM; const TypePtr* atp = TypeRawPtr::BOTTOM;
mem = StoreNode::make(*phase, ctl, mem, adr, atp, phase->zerocon(T_INT), T_INT, MemNode::unordered); mem = StoreNode::make(*phase, ctl, mem, adr, atp, phase->zerocon(T_INT), T_INT, MemNode::unordered);
@ -2920,16 +2920,16 @@ uint MemBarNode::cmp( const Node &n ) const {
//------------------------------make------------------------------------------- //------------------------------make-------------------------------------------
MemBarNode* MemBarNode::make(Compile* C, int opcode, int atp, Node* pn) { MemBarNode* MemBarNode::make(Compile* C, int opcode, int atp, Node* pn) {
switch (opcode) { switch (opcode) {
case Op_MemBarAcquire: return new(C) MemBarAcquireNode(C, atp, pn); case Op_MemBarAcquire: return new MemBarAcquireNode(C, atp, pn);
case Op_LoadFence: return new(C) LoadFenceNode(C, atp, pn); case Op_LoadFence: return new LoadFenceNode(C, atp, pn);
case Op_MemBarRelease: return new(C) MemBarReleaseNode(C, atp, pn); case Op_MemBarRelease: return new MemBarReleaseNode(C, atp, pn);
case Op_StoreFence: return new(C) StoreFenceNode(C, atp, pn); case Op_StoreFence: return new StoreFenceNode(C, atp, pn);
case Op_MemBarAcquireLock: return new(C) MemBarAcquireLockNode(C, atp, pn); case Op_MemBarAcquireLock: return new MemBarAcquireLockNode(C, atp, pn);
case Op_MemBarReleaseLock: return new(C) MemBarReleaseLockNode(C, atp, pn); case Op_MemBarReleaseLock: return new MemBarReleaseLockNode(C, atp, pn);
case Op_MemBarVolatile: return new(C) MemBarVolatileNode(C, atp, pn); case Op_MemBarVolatile: return new MemBarVolatileNode(C, atp, pn);
case Op_MemBarCPUOrder: return new(C) MemBarCPUOrderNode(C, atp, pn); case Op_MemBarCPUOrder: return new MemBarCPUOrderNode(C, atp, pn);
case Op_Initialize: return new(C) InitializeNode(C, atp, pn); case Op_Initialize: return new InitializeNode(C, atp, pn);
case Op_MemBarStoreStore: return new(C) MemBarStoreStoreNode(C, atp, pn); case Op_MemBarStoreStore: return new MemBarStoreStoreNode(C, atp, pn);
default: ShouldNotReachHere(); return NULL; default: ShouldNotReachHere(); return NULL;
} }
} }
@ -2992,7 +2992,7 @@ Node *MemBarNode::Ideal(PhaseGVN *phase, bool can_reshape) {
igvn->replace_node(proj_out(TypeFunc::Control), in(TypeFunc::Control)); igvn->replace_node(proj_out(TypeFunc::Control), in(TypeFunc::Control));
// Must return either the original node (now dead) or a new node // Must return either the original node (now dead) or a new node
// (Do not return a top here, since that would break the uniqueness of top.) // (Do not return a top here, since that would break the uniqueness of top.)
return new (phase->C) ConINode(TypeInt::ZERO); return new ConINode(TypeInt::ZERO);
} }
} }
return NULL; return NULL;
@ -3012,7 +3012,7 @@ Node *MemBarNode::match( const ProjNode *proj, const Matcher *m ) {
switch (proj->_con) { switch (proj->_con) {
case TypeFunc::Control: case TypeFunc::Control:
case TypeFunc::Memory: case TypeFunc::Memory:
return new (m->C) MachProjNode(this,proj->_con,RegMask::Empty,MachProjNode::unmatched_proj); return new MachProjNode(this,proj->_con,RegMask::Empty,MachProjNode::unmatched_proj);
} }
ShouldNotReachHere(); ShouldNotReachHere();
return NULL; return NULL;
@ -3438,7 +3438,7 @@ Node* InitializeNode::make_raw_address(intptr_t offset,
Node* addr = in(RawAddress); Node* addr = in(RawAddress);
if (offset != 0) { if (offset != 0) {
Compile* C = phase->C; Compile* C = phase->C;
addr = phase->transform( new (C) AddPNode(C->top(), addr, addr = phase->transform( new AddPNode(C->top(), addr,
phase->MakeConX(offset)) ); phase->MakeConX(offset)) );
} }
return addr; return addr;
@ -4127,7 +4127,7 @@ MergeMemNode::MergeMemNode(Node *new_base) : Node(1+Compile::AliasIdxRaw) {
// Make a new, untransformed MergeMem with the same base as 'mem'. // Make a new, untransformed MergeMem with the same base as 'mem'.
// If mem is itself a MergeMem, populate the result with the same edges. // If mem is itself a MergeMem, populate the result with the same edges.
MergeMemNode* MergeMemNode::make(Compile* C, Node* mem) { MergeMemNode* MergeMemNode::make(Compile* C, Node* mem) {
return new(C) MergeMemNode(mem); return new MergeMemNode(mem);
} }
//------------------------------cmp-------------------------------------------- //------------------------------cmp--------------------------------------------

26
hotspot/src/share/vm/opto/movenode.cpp
View file

@ -160,13 +160,13 @@ const Type *CMoveNode::Value( PhaseTransform *phase ) const {
// from the inputs we do not need to specify it here. // from the inputs we do not need to specify it here.
CMoveNode *CMoveNode::make( Compile *C, Node *c, Node *bol, Node *left, Node *right, const Type *t ) { CMoveNode *CMoveNode::make( Compile *C, Node *c, Node *bol, Node *left, Node *right, const Type *t ) {
switch( t->basic_type() ) { switch( t->basic_type() ) {
case T_INT: return new (C) CMoveINode( bol, left, right, t->is_int() ); case T_INT: return new CMoveINode( bol, left, right, t->is_int() );
case T_FLOAT: return new (C) CMoveFNode( bol, left, right, t ); case T_FLOAT: return new CMoveFNode( bol, left, right, t );
case T_DOUBLE: return new (C) CMoveDNode( bol, left, right, t ); case T_DOUBLE: return new CMoveDNode( bol, left, right, t );
case T_LONG: return new (C) CMoveLNode( bol, left, right, t->is_long() ); case T_LONG: return new CMoveLNode( bol, left, right, t->is_long() );
case T_OBJECT: return new (C) CMovePNode( c, bol, left, right, t->is_oopptr() ); case T_OBJECT: return new CMovePNode( c, bol, left, right, t->is_oopptr() );
case T_ADDRESS: return new (C) CMovePNode( c, bol, left, right, t->is_ptr() ); case T_ADDRESS: return new CMovePNode( c, bol, left, right, t->is_ptr() );
case T_NARROWOOP: return new (C) CMoveNNode( c, bol, left, right, t ); case T_NARROWOOP: return new CMoveNNode( c, bol, left, right, t );
default: default:
ShouldNotReachHere(); ShouldNotReachHere();
return NULL; return NULL;
@ -233,9 +233,9 @@ Node *CMoveINode::Ideal(PhaseGVN *phase, bool can_reshape) {
#ifndef PRODUCT #ifndef PRODUCT
if( PrintOpto ) tty->print_cr("CMOV to I2B"); if( PrintOpto ) tty->print_cr("CMOV to I2B");
#endif #endif
Node *n = new (phase->C) Conv2BNode( cmp->in(1) ); Node *n = new Conv2BNode( cmp->in(1) );
if( flip ) if( flip )
n = new (phase->C) XorINode( phase->transform(n), phase->intcon(1) ); n = new XorINode( phase->transform(n), phase->intcon(1) );
return n; return n;
} }
@ -289,9 +289,9 @@ Node *CMoveFNode::Ideal(PhaseGVN *phase, bool can_reshape) {
sub->in(2) != X || sub->in(2) != X ||
phase->type(sub->in(1)) != TypeF::ZERO ) return NULL; phase->type(sub->in(1)) != TypeF::ZERO ) return NULL;
Node *abs = new (phase->C) AbsFNode( X ); Node *abs = new AbsFNode( X );
if( flip ) if( flip )
abs = new (phase->C) SubFNode(sub->in(1), phase->transform(abs)); abs = new SubFNode(sub->in(1), phase->transform(abs));
return abs; return abs;
} }
@ -345,9 +345,9 @@ Node *CMoveDNode::Ideal(PhaseGVN *phase, bool can_reshape) {
sub->in(2) != X || sub->in(2) != X ||
phase->type(sub->in(1)) != TypeD::ZERO ) return NULL; phase->type(sub->in(1)) != TypeD::ZERO ) return NULL;
Node *abs = new (phase->C) AbsDNode( X ); Node *abs = new AbsDNode( X );
if( flip ) if( flip )
abs = new (phase->C) SubDNode(sub->in(1), phase->transform(abs)); abs = new SubDNode(sub->in(1), phase->transform(abs));
return abs; return abs;
} }

132
hotspot/src/share/vm/opto/mulnode.cpp
View file

@ -199,22 +199,22 @@ Node *MulINode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node *res = NULL; Node *res = NULL;
jint bit1 = con & -con; // Extract low bit jint bit1 = con & -con; // Extract low bit
if( bit1 == con ) { // Found a power of 2? if( bit1 == con ) { // Found a power of 2?
res = new (phase->C) LShiftINode( in(1), phase->intcon(log2_intptr(bit1)) ); res = new LShiftINode( in(1), phase->intcon(log2_intptr(bit1)) );
} else { } else {
// Check for constant with 2 bits set // Check for constant with 2 bits set
jint bit2 = con-bit1; jint bit2 = con-bit1;
bit2 = bit2 & -bit2; // Extract 2nd bit bit2 = bit2 & -bit2; // Extract 2nd bit
if( bit2 + bit1 == con ) { // Found all bits in con? if( bit2 + bit1 == con ) { // Found all bits in con?
Node *n1 = phase->transform( new (phase->C) LShiftINode( in(1), phase->intcon(log2_intptr(bit1)) ) ); Node *n1 = phase->transform( new LShiftINode( in(1), phase->intcon(log2_intptr(bit1)) ) );
Node *n2 = phase->transform( new (phase->C) LShiftINode( in(1), phase->intcon(log2_intptr(bit2)) ) ); Node *n2 = phase->transform( new LShiftINode( in(1), phase->intcon(log2_intptr(bit2)) ) );
res = new (phase->C) AddINode( n2, n1 ); res = new AddINode( n2, n1 );
} else if (is_power_of_2(con+1)) { } else if (is_power_of_2(con+1)) {
// Sleezy: power-of-2 -1. Next time be generic. // Sleezy: power-of-2 -1. Next time be generic.
jint temp = (jint) (con + 1); jint temp = (jint) (con + 1);
Node *n1 = phase->transform( new (phase->C) LShiftINode( in(1), phase->intcon(log2_intptr(temp)) ) ); Node *n1 = phase->transform( new LShiftINode( in(1), phase->intcon(log2_intptr(temp)) ) );
res = new (phase->C) SubINode( n1, in(1) ); res = new SubINode( n1, in(1) );
} else { } else {
return MulNode::Ideal(phase, can_reshape); return MulNode::Ideal(phase, can_reshape);
} }
@ -222,7 +222,7 @@ Node *MulINode::Ideal(PhaseGVN *phase, bool can_reshape) {
if( sign_flip ) { // Need to negate result? if( sign_flip ) { // Need to negate result?
res = phase->transform(res);// Transform, before making the zero con res = phase->transform(res);// Transform, before making the zero con
res = new (phase->C) SubINode(phase->intcon(0),res); res = new SubINode(phase->intcon(0),res);
} }
return res; // Return final result return res; // Return final result
@ -295,22 +295,22 @@ Node *MulLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node *res = NULL; Node *res = NULL;
jlong bit1 = con & -con; // Extract low bit jlong bit1 = con & -con; // Extract low bit
if( bit1 == con ) { // Found a power of 2? if( bit1 == con ) { // Found a power of 2?
res = new (phase->C) LShiftLNode( in(1), phase->intcon(log2_long(bit1)) ); res = new LShiftLNode( in(1), phase->intcon(log2_long(bit1)) );
} else { } else {
// Check for constant with 2 bits set // Check for constant with 2 bits set
jlong bit2 = con-bit1; jlong bit2 = con-bit1;
bit2 = bit2 & -bit2; // Extract 2nd bit bit2 = bit2 & -bit2; // Extract 2nd bit
if( bit2 + bit1 == con ) { // Found all bits in con? if( bit2 + bit1 == con ) { // Found all bits in con?
Node *n1 = phase->transform( new (phase->C) LShiftLNode( in(1), phase->intcon(log2_long(bit1)) ) ); Node *n1 = phase->transform( new LShiftLNode( in(1), phase->intcon(log2_long(bit1)) ) );
Node *n2 = phase->transform( new (phase->C) LShiftLNode( in(1), phase->intcon(log2_long(bit2)) ) ); Node *n2 = phase->transform( new LShiftLNode( in(1), phase->intcon(log2_long(bit2)) ) );
res = new (phase->C) AddLNode( n2, n1 ); res = new AddLNode( n2, n1 );
} else if (is_power_of_2_long(con+1)) { } else if (is_power_of_2_long(con+1)) {
// Sleezy: power-of-2 -1. Next time be generic. // Sleezy: power-of-2 -1. Next time be generic.
jlong temp = (jlong) (con + 1); jlong temp = (jlong) (con + 1);
Node *n1 = phase->transform( new (phase->C) LShiftLNode( in(1), phase->intcon(log2_long(temp)) ) ); Node *n1 = phase->transform( new LShiftLNode( in(1), phase->intcon(log2_long(temp)) ) );
res = new (phase->C) SubLNode( n1, in(1) ); res = new SubLNode( n1, in(1) );
} else { } else {
return MulNode::Ideal(phase, can_reshape); return MulNode::Ideal(phase, can_reshape);
} }
@ -318,7 +318,7 @@ Node *MulLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
if( sign_flip ) { // Need to negate result? if( sign_flip ) { // Need to negate result?
res = phase->transform(res);// Transform, before making the zero con res = phase->transform(res);// Transform, before making the zero con
res = new (phase->C) SubLNode(phase->longcon(0),res); res = new SubLNode(phase->longcon(0),res);
} }
return res; // Return final result return res; // Return final result
@ -477,31 +477,31 @@ Node *AndINode::Ideal(PhaseGVN *phase, bool can_reshape) {
// Masking bits off of a Character? Hi bits are already zero. // Masking bits off of a Character? Hi bits are already zero.
if( lop == Op_LoadUS && if( lop == Op_LoadUS &&
(mask & 0xFFFF0000) ) // Can we make a smaller mask? (mask & 0xFFFF0000) ) // Can we make a smaller mask?
return new (phase->C) AndINode(load,phase->intcon(mask&0xFFFF)); return new AndINode(load,phase->intcon(mask&0xFFFF));
// Masking bits off of a Short? Loading a Character does some masking // Masking bits off of a Short? Loading a Character does some masking
if (can_reshape && if (can_reshape &&
load->outcnt() == 1 && load->unique_out() == this) { load->outcnt() == 1 && load->unique_out() == this) {
if (lop == Op_LoadS && (mask & 0xFFFF0000) == 0 ) { if (lop == Op_LoadS && (mask & 0xFFFF0000) == 0 ) {
Node *ldus = new (phase->C) LoadUSNode(load->in(MemNode::Control), Node *ldus = new LoadUSNode(load->in(MemNode::Control),
load->in(MemNode::Memory), load->in(MemNode::Memory),
load->in(MemNode::Address), load->in(MemNode::Address),
load->adr_type(), load->adr_type(),
TypeInt::CHAR, MemNode::unordered); TypeInt::CHAR, MemNode::unordered);
ldus = phase->transform(ldus); ldus = phase->transform(ldus);
return new (phase->C) AndINode(ldus, phase->intcon(mask & 0xFFFF)); return new AndINode(ldus, phase->intcon(mask & 0xFFFF));
} }
// Masking sign bits off of a Byte? Do an unsigned byte load plus // Masking sign bits off of a Byte? Do an unsigned byte load plus
// an and. // an and.
if (lop == Op_LoadB && (mask & 0xFFFFFF00) == 0) { if (lop == Op_LoadB && (mask & 0xFFFFFF00) == 0) {
Node* ldub = new (phase->C) LoadUBNode(load->in(MemNode::Control), Node* ldub = new LoadUBNode(load->in(MemNode::Control),
load->in(MemNode::Memory), load->in(MemNode::Memory),
load->in(MemNode::Address), load->in(MemNode::Address),
load->adr_type(), load->adr_type(),
TypeInt::UBYTE, MemNode::unordered); TypeInt::UBYTE, MemNode::unordered);
ldub = phase->transform(ldub); ldub = phase->transform(ldub);
return new (phase->C) AndINode(ldub, phase->intcon(mask)); return new AndINode(ldub, phase->intcon(mask));
} }
} }
@ -516,8 +516,8 @@ Node *AndINode::Ideal(PhaseGVN *phase, bool can_reshape) {
// bits survive. NO sign-extension bits survive the maskings. // bits survive. NO sign-extension bits survive the maskings.
if( (sign_bits_mask & mask) == 0 ) { if( (sign_bits_mask & mask) == 0 ) {
// Use zero-fill shift instead // Use zero-fill shift instead
Node *zshift = phase->transform(new (phase->C) URShiftINode(load->in(1),load->in(2))); Node *zshift = phase->transform(new URShiftINode(load->in(1),load->in(2)));
return new (phase->C) AndINode( zshift, in(2) ); return new AndINode( zshift, in(2) );
} }
} }
} }
@ -527,7 +527,7 @@ Node *AndINode::Ideal(PhaseGVN *phase, bool can_reshape) {
// plus 1) and the mask is of the low order bit. Skip the negate. // plus 1) and the mask is of the low order bit. Skip the negate.
if( lop == Op_SubI && mask == 1 && load->in(1) && if( lop == Op_SubI && mask == 1 && load->in(1) &&
phase->type(load->in(1)) == TypeInt::ZERO ) phase->type(load->in(1)) == TypeInt::ZERO )
return new (phase->C) AndINode( load->in(2), in(2) ); return new AndINode( load->in(2), in(2) );
return MulNode::Ideal(phase, can_reshape); return MulNode::Ideal(phase, can_reshape);
} }
@ -611,9 +611,9 @@ Node *AndLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// value. This check includes UI2L masks (0x00000000FFFFFFFF) which // value. This check includes UI2L masks (0x00000000FFFFFFFF) which
// would be optimized away later in Identity. // would be optimized away later in Identity.
if (op == Op_ConvI2L && (mask & CONST64(0xFFFFFFFF80000000)) == 0) { if (op == Op_ConvI2L && (mask & CONST64(0xFFFFFFFF80000000)) == 0) {
Node* andi = new (phase->C) AndINode(in1->in(1), phase->intcon(mask)); Node* andi = new AndINode(in1->in(1), phase->intcon(mask));
andi = phase->transform(andi); andi = phase->transform(andi);
return new (phase->C) ConvI2LNode(andi); return new ConvI2LNode(andi);
} }
// Masking off sign bits? Dont make them! // Masking off sign bits? Dont make them!
@ -627,8 +627,8 @@ Node *AndLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// bits survive. NO sign-extension bits survive the maskings. // bits survive. NO sign-extension bits survive the maskings.
if( (sign_bits_mask & mask) == 0 ) { if( (sign_bits_mask & mask) == 0 ) {
// Use zero-fill shift instead // Use zero-fill shift instead
Node *zshift = phase->transform(new (phase->C) URShiftLNode(in1->in(1), in1->in(2))); Node *zshift = phase->transform(new URShiftLNode(in1->in(1), in1->in(2)));
return new (phase->C) AndLNode(zshift, in(2)); return new AndLNode(zshift, in(2));
} }
} }
} }
@ -666,9 +666,9 @@ Node *LShiftINode::Ideal(PhaseGVN *phase, bool can_reshape) {
// and 'i2b' patterns which typically fold into 'StoreC/StoreB'. // and 'i2b' patterns which typically fold into 'StoreC/StoreB'.
if( con < 16 ) { if( con < 16 ) {
// Compute X << con0 // Compute X << con0
Node *lsh = phase->transform( new (phase->C) LShiftINode( add1->in(1), in(2) ) ); Node *lsh = phase->transform( new LShiftINode( add1->in(1), in(2) ) );
// Compute X<<con0 + (con1<<con0) // Compute X<<con0 + (con1<<con0)
return new (phase->C) AddINode( lsh, phase->intcon(t12->get_con() << con)); return new AddINode( lsh, phase->intcon(t12->get_con() << con));
} }
} }
} }
@ -677,7 +677,7 @@ Node *LShiftINode::Ideal(PhaseGVN *phase, bool can_reshape) {
if( (add1_op == Op_RShiftI || add1_op == Op_URShiftI ) && if( (add1_op == Op_RShiftI || add1_op == Op_URShiftI ) &&
add1->in(2) == in(2) ) add1->in(2) == in(2) )
// Convert to "(x & -(1<<c0))" // Convert to "(x & -(1<<c0))"
return new (phase->C) AndINode(add1->in(1),phase->intcon( -(1<<con))); return new AndINode(add1->in(1),phase->intcon( -(1<<con)));
// Check for "((x>>c0) & Y)<<c0" which just masks off more low bits // Check for "((x>>c0) & Y)<<c0" which just masks off more low bits
if( add1_op == Op_AndI ) { if( add1_op == Op_AndI ) {
@ -686,8 +686,8 @@ Node *LShiftINode::Ideal(PhaseGVN *phase, bool can_reshape) {
if( (add2_op == Op_RShiftI || add2_op == Op_URShiftI ) && if( (add2_op == Op_RShiftI || add2_op == Op_URShiftI ) &&
add2->in(2) == in(2) ) { add2->in(2) == in(2) ) {
// Convert to "(x & (Y<<c0))" // Convert to "(x & (Y<<c0))"
Node *y_sh = phase->transform( new (phase->C) LShiftINode( add1->in(2), in(2) ) ); Node *y_sh = phase->transform( new LShiftINode( add1->in(2), in(2) ) );
return new (phase->C) AndINode( add2->in(1), y_sh ); return new AndINode( add2->in(1), y_sh );
} }
} }
@ -696,7 +696,7 @@ Node *LShiftINode::Ideal(PhaseGVN *phase, bool can_reshape) {
const jint bits_mask = right_n_bits(BitsPerJavaInteger-con); const jint bits_mask = right_n_bits(BitsPerJavaInteger-con);
if( add1_op == Op_AndI && if( add1_op == Op_AndI &&
phase->type(add1->in(2)) == TypeInt::make( bits_mask ) ) phase->type(add1->in(2)) == TypeInt::make( bits_mask ) )
return new (phase->C) LShiftINode( add1->in(1), in(2) ); return new LShiftINode( add1->in(1), in(2) );
return NULL; return NULL;
} }
@ -776,9 +776,9 @@ Node *LShiftLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
const TypeLong *t12 = phase->type(add1->in(2))->isa_long(); const TypeLong *t12 = phase->type(add1->in(2))->isa_long();
if( t12 && t12->is_con() ){ // Left input is an add of a con? if( t12 && t12->is_con() ){ // Left input is an add of a con?
// Compute X << con0 // Compute X << con0
Node *lsh = phase->transform( new (phase->C) LShiftLNode( add1->in(1), in(2) ) ); Node *lsh = phase->transform( new LShiftLNode( add1->in(1), in(2) ) );
// Compute X<<con0 + (con1<<con0) // Compute X<<con0 + (con1<<con0)
return new (phase->C) AddLNode( lsh, phase->longcon(t12->get_con() << con)); return new AddLNode( lsh, phase->longcon(t12->get_con() << con));
} }
} }
@ -786,7 +786,7 @@ Node *LShiftLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
if( (add1_op == Op_RShiftL || add1_op == Op_URShiftL ) && if( (add1_op == Op_RShiftL || add1_op == Op_URShiftL ) &&
add1->in(2) == in(2) ) add1->in(2) == in(2) )
// Convert to "(x & -(1<<c0))" // Convert to "(x & -(1<<c0))"
return new (phase->C) AndLNode(add1->in(1),phase->longcon( -(CONST64(1)<<con))); return new AndLNode(add1->in(1),phase->longcon( -(CONST64(1)<<con)));
// Check for "((x>>c0) & Y)<<c0" which just masks off more low bits // Check for "((x>>c0) & Y)<<c0" which just masks off more low bits
if( add1_op == Op_AndL ) { if( add1_op == Op_AndL ) {
@ -795,8 +795,8 @@ Node *LShiftLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
if( (add2_op == Op_RShiftL || add2_op == Op_URShiftL ) && if( (add2_op == Op_RShiftL || add2_op == Op_URShiftL ) &&
add2->in(2) == in(2) ) { add2->in(2) == in(2) ) {
// Convert to "(x & (Y<<c0))" // Convert to "(x & (Y<<c0))"
Node *y_sh = phase->transform( new (phase->C) LShiftLNode( add1->in(2), in(2) ) ); Node *y_sh = phase->transform( new LShiftLNode( add1->in(2), in(2) ) );
return new (phase->C) AndLNode( add2->in(1), y_sh ); return new AndLNode( add2->in(1), y_sh );
} }
} }
@ -805,7 +805,7 @@ Node *LShiftLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
const jlong bits_mask = ((jlong)CONST64(1) << (jlong)(BitsPerJavaLong - con)) - CONST64(1); const jlong bits_mask = ((jlong)CONST64(1) << (jlong)(BitsPerJavaLong - con)) - CONST64(1);
if( add1_op == Op_AndL && if( add1_op == Op_AndL &&
phase->type(add1->in(2)) == TypeLong::make( bits_mask ) ) phase->type(add1->in(2)) == TypeLong::make( bits_mask ) )
return new (phase->C) LShiftLNode( add1->in(1), in(2) ); return new LShiftLNode( add1->in(1), in(2) );
return NULL; return NULL;
} }
@ -907,8 +907,8 @@ Node *RShiftINode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node *x = mask->in(1); Node *x = mask->in(1);
jint maskbits = t3->get_con(); jint maskbits = t3->get_con();
// Convert to "(x >> shift) & (mask >> shift)" // Convert to "(x >> shift) & (mask >> shift)"
Node *shr_nomask = phase->transform( new (phase->C) RShiftINode(mask->in(1), in(2)) ); Node *shr_nomask = phase->transform( new RShiftINode(mask->in(1), in(2)) );
return new (phase->C) AndINode(shr_nomask, phase->intcon( maskbits >> shift)); return new AndINode(shr_nomask, phase->intcon( maskbits >> shift));
} }
// Check for "(short[i] <<16)>>16" which simply sign-extends // Check for "(short[i] <<16)>>16" which simply sign-extends
@ -933,11 +933,11 @@ Node *RShiftINode::Ideal(PhaseGVN *phase, bool can_reshape) {
ld->Opcode() == Op_LoadUS && ld->Opcode() == Op_LoadUS &&
ld->outcnt() == 1 && ld->unique_out() == shl) ld->outcnt() == 1 && ld->unique_out() == shl)
// Replace zero-extension-load with sign-extension-load // Replace zero-extension-load with sign-extension-load
return new (phase->C) LoadSNode( ld->in(MemNode::Control), return new LoadSNode( ld->in(MemNode::Control),
ld->in(MemNode::Memory), ld->in(MemNode::Memory),
ld->in(MemNode::Address), ld->in(MemNode::Address),
ld->adr_type(), TypeInt::SHORT, ld->adr_type(), TypeInt::SHORT,
MemNode::unordered); MemNode::unordered);
} }
// Check for "(byte[i] <<24)>>24" which simply sign-extends // Check for "(byte[i] <<24)>>24" which simply sign-extends
@ -1119,7 +1119,7 @@ Node *URShiftINode::Ideal(PhaseGVN *phase, bool can_reshape) {
const int con2 = t12->get_con() & 31; // Shift count is always masked const int con2 = t12->get_con() & 31; // Shift count is always masked
const int con3 = con+con2; const int con3 = con+con2;
if( con3 < 32 ) // Only merge shifts if total is < 32 if( con3 < 32 ) // Only merge shifts if total is < 32
return new (phase->C) URShiftINode( in(1)->in(1), phase->intcon(con3) ); return new URShiftINode( in(1)->in(1), phase->intcon(con3) );
} }
} }
@ -1132,9 +1132,9 @@ Node *URShiftINode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node *lshl = add->in(1); Node *lshl = add->in(1);
if( lshl->Opcode() == Op_LShiftI && if( lshl->Opcode() == Op_LShiftI &&
phase->type(lshl->in(2)) == t2 ) { phase->type(lshl->in(2)) == t2 ) {
Node *y_z = phase->transform( new (phase->C) URShiftINode(add->in(2),in(2)) ); Node *y_z = phase->transform( new URShiftINode(add->in(2),in(2)) );
Node *sum = phase->transform( new (phase->C) AddINode( lshl->in(1), y_z ) ); Node *sum = phase->transform( new AddINode( lshl->in(1), y_z ) );
return new (phase->C) AndINode( sum, phase->intcon(mask) ); return new AndINode( sum, phase->intcon(mask) );
} }
} }
@ -1147,8 +1147,8 @@ Node *URShiftINode::Ideal(PhaseGVN *phase, bool can_reshape) {
if( t3 && t3->is_con() ) { // Right input is a constant if( t3 && t3->is_con() ) { // Right input is a constant
jint mask2 = t3->get_con(); jint mask2 = t3->get_con();
mask2 >>= con; // *signed* shift downward (high-order zeroes do not help) mask2 >>= con; // *signed* shift downward (high-order zeroes do not help)
Node *newshr = phase->transform( new (phase->C) URShiftINode(andi->in(1), in(2)) ); Node *newshr = phase->transform( new URShiftINode(andi->in(1), in(2)) );
return new (phase->C) AndINode(newshr, phase->intcon(mask2)); return new AndINode(newshr, phase->intcon(mask2));
// The negative values are easier to materialize than positive ones. // The negative values are easier to materialize than positive ones.
// A typical case from address arithmetic is ((x & ~15) >> 4). // A typical case from address arithmetic is ((x & ~15) >> 4).
// It's better to change that to ((x >> 4) & ~0) versus // It's better to change that to ((x >> 4) & ~0) versus
@ -1160,7 +1160,7 @@ Node *URShiftINode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node *shl = in(1); Node *shl = in(1);
if( in1_op == Op_LShiftI && if( in1_op == Op_LShiftI &&
phase->type(shl->in(2)) == t2 ) phase->type(shl->in(2)) == t2 )
return new (phase->C) AndINode( shl->in(1), phase->intcon(mask) ); return new AndINode( shl->in(1), phase->intcon(mask) );
return NULL; return NULL;
} }
@ -1265,9 +1265,9 @@ Node *URShiftLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node *lshl = add->in(1); Node *lshl = add->in(1);
if( lshl->Opcode() == Op_LShiftL && if( lshl->Opcode() == Op_LShiftL &&
phase->type(lshl->in(2)) == t2 ) { phase->type(lshl->in(2)) == t2 ) {
Node *y_z = phase->transform( new (phase->C) URShiftLNode(add->in(2),in(2)) ); Node *y_z = phase->transform( new URShiftLNode(add->in(2),in(2)) );
Node *sum = phase->transform( new (phase->C) AddLNode( lshl->in(1), y_z ) ); Node *sum = phase->transform( new AddLNode( lshl->in(1), y_z ) );
return new (phase->C) AndLNode( sum, phase->longcon(mask) ); return new AndLNode( sum, phase->longcon(mask) );
} }
} }
@ -1280,8 +1280,8 @@ Node *URShiftLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
if( t3 && t3->is_con() ) { // Right input is a constant if( t3 && t3->is_con() ) { // Right input is a constant
jlong mask2 = t3->get_con(); jlong mask2 = t3->get_con();
mask2 >>= con; // *signed* shift downward (high-order zeroes do not help) mask2 >>= con; // *signed* shift downward (high-order zeroes do not help)
Node *newshr = phase->transform( new (phase->C) URShiftLNode(andi->in(1), in(2)) ); Node *newshr = phase->transform( new URShiftLNode(andi->in(1), in(2)) );
return new (phase->C) AndLNode(newshr, phase->longcon(mask2)); return new AndLNode(newshr, phase->longcon(mask2));
} }
} }
@ -1289,7 +1289,7 @@ Node *URShiftLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node *shl = in(1); Node *shl = in(1);
if( shl->Opcode() == Op_LShiftL && if( shl->Opcode() == Op_LShiftL &&
phase->type(shl->in(2)) == t2 ) phase->type(shl->in(2)) == t2 )
return new (phase->C) AndLNode( shl->in(1), phase->longcon(mask) ); return new AndLNode( shl->in(1), phase->longcon(mask) );
return NULL; return NULL;
} }

45
hotspot/src/share/vm/opto/node.cpp
View file

@ -274,23 +274,6 @@ void DUIterator_Last::verify_step(uint num_edges) {
// The value NULL is reserved for the top node only. // The value NULL is reserved for the top node only.
#define NO_OUT_ARRAY ((Node**)-1) #define NO_OUT_ARRAY ((Node**)-1)
// This funny expression handshakes with Node::operator new
// to pull Compile::current out of the new node's _out field,
// and then calls a subroutine which manages most field
// initializations. The only one which is tricky is the
// _idx field, which is const, and so must be initialized
// by a return value, not an assignment.
//
// (Aren't you thankful that Java finals don't require so many tricks?)
#define IDX_INIT(req) this->Init((req), (Compile*) this->_out)
#ifdef _MSC_VER // the IDX_INIT hack falls foul of warning C4355
#pragma warning( disable:4355 ) // 'this' : used in base member initializer list
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma GCC diagnostic ignored "-Wuninitialized"
#endif
// Out-of-line code from node constructors. // Out-of-line code from node constructors.
// Executed only when extra debug info. is being passed around. // Executed only when extra debug info. is being passed around.
static void init_node_notes(Compile* C, int idx, Node_Notes* nn) { static void init_node_notes(Compile* C, int idx, Node_Notes* nn) {
@ -298,8 +281,8 @@ static void init_node_notes(Compile* C, int idx, Node_Notes* nn) {
} }
// Shared initialization code. // Shared initialization code.
inline int Node::Init(int req, Compile* C) { inline int Node::Init(int req) {
assert(Compile::current() == C, "must use operator new(Compile*)"); Compile* C = Compile::current();
int idx = C->next_unique(); int idx = C->next_unique();
// Allocate memory for the necessary number of edges. // Allocate memory for the necessary number of edges.
@ -328,7 +311,7 @@ inline int Node::Init(int req, Compile* C) {
//------------------------------Node------------------------------------------- //------------------------------Node-------------------------------------------
// Create a Node, with a given number of required edges. // Create a Node, with a given number of required edges.
Node::Node(uint req) Node::Node(uint req)
: _idx(IDX_INIT(req)) : _idx(Init(req))
{ {
assert( req < (uint)(MaxNodeLimit - NodeLimitFudgeFactor), "Input limit exceeded" ); assert( req < (uint)(MaxNodeLimit - NodeLimitFudgeFactor), "Input limit exceeded" );
debug_only( verify_construction() ); debug_only( verify_construction() );
@ -347,7 +330,7 @@ Node::Node(uint req)
//------------------------------Node------------------------------------------- //------------------------------Node-------------------------------------------
Node::Node(Node *n0) Node::Node(Node *n0)
: _idx(IDX_INIT(1)) : _idx(Init(1))
{ {
debug_only( verify_construction() ); debug_only( verify_construction() );
NOT_PRODUCT(nodes_created++); NOT_PRODUCT(nodes_created++);
@ -359,7 +342,7 @@ Node::Node(Node *n0)
//------------------------------Node------------------------------------------- //------------------------------Node-------------------------------------------
Node::Node(Node *n0, Node *n1) Node::Node(Node *n0, Node *n1)
: _idx(IDX_INIT(2)) : _idx(Init(2))
{ {
debug_only( verify_construction() ); debug_only( verify_construction() );
NOT_PRODUCT(nodes_created++); NOT_PRODUCT(nodes_created++);
@ -373,7 +356,7 @@ Node::Node(Node *n0, Node *n1)
//------------------------------Node------------------------------------------- //------------------------------Node-------------------------------------------
Node::Node(Node *n0, Node *n1, Node *n2) Node::Node(Node *n0, Node *n1, Node *n2)
: _idx(IDX_INIT(3)) : _idx(Init(3))
{ {
debug_only( verify_construction() ); debug_only( verify_construction() );
NOT_PRODUCT(nodes_created++); NOT_PRODUCT(nodes_created++);
@ -389,7 +372,7 @@ Node::Node(Node *n0, Node *n1, Node *n2)
//------------------------------Node------------------------------------------- //------------------------------Node-------------------------------------------
Node::Node(Node *n0, Node *n1, Node *n2, Node *n3) Node::Node(Node *n0, Node *n1, Node *n2, Node *n3)
: _idx(IDX_INIT(4)) : _idx(Init(4))
{ {
debug_only( verify_construction() ); debug_only( verify_construction() );
NOT_PRODUCT(nodes_created++); NOT_PRODUCT(nodes_created++);
@ -407,7 +390,7 @@ Node::Node(Node *n0, Node *n1, Node *n2, Node *n3)
//------------------------------Node------------------------------------------- //------------------------------Node-------------------------------------------
Node::Node(Node *n0, Node *n1, Node *n2, Node *n3, Node *n4) Node::Node(Node *n0, Node *n1, Node *n2, Node *n3, Node *n4)
: _idx(IDX_INIT(5)) : _idx(Init(5))
{ {
debug_only( verify_construction() ); debug_only( verify_construction() );
NOT_PRODUCT(nodes_created++); NOT_PRODUCT(nodes_created++);
@ -428,7 +411,7 @@ Node::Node(Node *n0, Node *n1, Node *n2, Node *n3, Node *n4)
//------------------------------Node------------------------------------------- //------------------------------Node-------------------------------------------
Node::Node(Node *n0, Node *n1, Node *n2, Node *n3, Node::Node(Node *n0, Node *n1, Node *n2, Node *n3,
Node *n4, Node *n5) Node *n4, Node *n5)
: _idx(IDX_INIT(6)) : _idx(Init(6))
{ {
debug_only( verify_construction() ); debug_only( verify_construction() );
NOT_PRODUCT(nodes_created++); NOT_PRODUCT(nodes_created++);
@ -451,7 +434,7 @@ Node::Node(Node *n0, Node *n1, Node *n2, Node *n3,
//------------------------------Node------------------------------------------- //------------------------------Node-------------------------------------------
Node::Node(Node *n0, Node *n1, Node *n2, Node *n3, Node::Node(Node *n0, Node *n1, Node *n2, Node *n3,
Node *n4, Node *n5, Node *n6) Node *n4, Node *n5, Node *n6)
: _idx(IDX_INIT(7)) : _idx(Init(7))
{ {
debug_only( verify_construction() ); debug_only( verify_construction() );
NOT_PRODUCT(nodes_created++); NOT_PRODUCT(nodes_created++);
@ -1066,15 +1049,15 @@ const Type *Node::Value( PhaseTransform * ) const {
// set_req(2, phase->intcon(7)); // set_req(2, phase->intcon(7));
// return this; // return this;
// Example: reshape "X*4" into "X<<2" // Example: reshape "X*4" into "X<<2"
// return new (C) LShiftINode(in(1), phase->intcon(2)); // return new LShiftINode(in(1), phase->intcon(2));
// //
// You must call 'phase->transform(X)' on any new Nodes X you make, except // You must call 'phase->transform(X)' on any new Nodes X you make, except
// for the returned root node. Example: reshape "X*31" with "(X<<5)-X". // for the returned root node. Example: reshape "X*31" with "(X<<5)-X".
// Node *shift=phase->transform(new(C)LShiftINode(in(1),phase->intcon(5))); // Node *shift=phase->transform(new LShiftINode(in(1),phase->intcon(5)));
// return new (C) AddINode(shift, in(1)); // return new AddINode(shift, in(1));
// //
// When making a Node for a constant use 'phase->makecon' or 'phase->intcon'. // When making a Node for a constant use 'phase->makecon' or 'phase->intcon'.
// These forms are faster than 'phase->transform(new (C) ConNode())' and Do // These forms are faster than 'phase->transform(new ConNode())' and Do
// The Right Thing with def-use info. // The Right Thing with def-use info.
// //
// You cannot bury the 'this' Node inside of a graph reshape. If the reshaped // You cannot bury the 'this' Node inside of a graph reshape. If the reshaped

8
hotspot/src/share/vm/opto/node.hpp
View file

@ -208,14 +208,12 @@ public:
// field is a local cache of a value defined in some "program fragment" for // field is a local cache of a value defined in some "program fragment" for
// which these Nodes are just a part of. // which these Nodes are just a part of.
// New Operator that takes a Compile pointer, this will eventually inline void* operator new(size_t x) throw() {
// be the "new" New operator. Compile* C = Compile::current();
inline void* operator new( size_t x, Compile* C) throw() {
Node* n = (Node*)C->node_arena()->Amalloc_D(x); Node* n = (Node*)C->node_arena()->Amalloc_D(x);
#ifdef ASSERT #ifdef ASSERT
n->_in = (Node**)n; // magic cookie for assertion check n->_in = (Node**)n; // magic cookie for assertion check
#endif #endif
n->_out = (Node**)C;
return (void*)n; return (void*)n;
} }
@ -259,7 +257,7 @@ private:
// Puts initial values in all Node fields except _idx. // Puts initial values in all Node fields except _idx.
// Returns the initial value for _idx, which cannot // Returns the initial value for _idx, which cannot
// be initialized by assignment. // be initialized by assignment.
inline int Init(int req, Compile* C); inline int Init(int req);
//----------------- input edge handling //----------------- input edge handling
protected: protected:

26
hotspot/src/share/vm/opto/output.cpp
View file

@ -67,7 +67,7 @@ void Compile::Output() {
const StartNode *start = entry->head()->as_Start(); const StartNode *start = entry->head()->as_Start();
// Replace StartNode with prolog // Replace StartNode with prolog
MachPrologNode *prolog = new (this) MachPrologNode(); MachPrologNode *prolog = new MachPrologNode();
entry->map_node(prolog, 0); entry->map_node(prolog, 0);
_cfg->map_node_to_block(prolog, entry); _cfg->map_node_to_block(prolog, entry);
_cfg->unmap_node_from_block(start); // start is no longer in any block _cfg->unmap_node_from_block(start); // start is no longer in any block
@ -77,12 +77,12 @@ void Compile::Output() {
if( is_osr_compilation() ) { if( is_osr_compilation() ) {
if( PoisonOSREntry ) { if( PoisonOSREntry ) {
// TODO: Should use a ShouldNotReachHereNode... // TODO: Should use a ShouldNotReachHereNode...
_cfg->insert( broot, 0, new (this) MachBreakpointNode() ); _cfg->insert( broot, 0, new MachBreakpointNode() );
} }
} else { } else {
if( _method && !_method->flags().is_static() ) { if( _method && !_method->flags().is_static() ) {
// Insert unvalidated entry point // Insert unvalidated entry point
_cfg->insert( broot, 0, new (this) MachUEPNode() ); _cfg->insert( broot, 0, new MachUEPNode() );
} }
} }
@ -98,7 +98,7 @@ void Compile::Output() {
) { ) {
// checking for _method means that OptoBreakpoint does not apply to // checking for _method means that OptoBreakpoint does not apply to
// runtime stubs or frame converters // runtime stubs or frame converters
_cfg->insert( entry, 1, new (this) MachBreakpointNode() ); _cfg->insert( entry, 1, new MachBreakpointNode() );
} }
// Insert epilogs before every return // Insert epilogs before every return
@ -107,7 +107,7 @@ void Compile::Output() {
if (!block->is_connector() && block->non_connector_successor(0) == _cfg->get_root_block()) { // Found a program exit point? if (!block->is_connector() && block->non_connector_successor(0) == _cfg->get_root_block()) { // Found a program exit point?
Node* m = block->end(); Node* m = block->end();
if (m->is_Mach() && m->as_Mach()->ideal_Opcode() != Op_Halt) { if (m->is_Mach() && m->as_Mach()->ideal_Opcode() != Op_Halt) {
MachEpilogNode* epilog = new (this) MachEpilogNode(m->as_Mach()->ideal_Opcode() == Op_Return); MachEpilogNode* epilog = new MachEpilogNode(m->as_Mach()->ideal_Opcode() == Op_Return);
block->add_inst(epilog); block->add_inst(epilog);
_cfg->map_node_to_block(epilog, block); _cfg->map_node_to_block(epilog, block);
} }
@ -268,7 +268,7 @@ void Compile::Insert_zap_nodes() {
Node* Compile::call_zap_node(MachSafePointNode* node_to_check, int block_no) { Node* Compile::call_zap_node(MachSafePointNode* node_to_check, int block_no) {
const TypeFunc *tf = OptoRuntime::zap_dead_locals_Type(); const TypeFunc *tf = OptoRuntime::zap_dead_locals_Type();
CallStaticJavaNode* ideal_node = CallStaticJavaNode* ideal_node =
new (this) CallStaticJavaNode( tf, new CallStaticJavaNode( tf,
OptoRuntime::zap_dead_locals_stub(_method->flags().is_native()), OptoRuntime::zap_dead_locals_stub(_method->flags().is_native()),
"call zap dead locals stub", 0, TypePtr::BOTTOM); "call zap dead locals stub", 0, TypePtr::BOTTOM);
// We need to copy the OopMap from the site we're zapping at. // We need to copy the OopMap from the site we're zapping at.
@ -368,7 +368,7 @@ void Compile::shorten_branches(uint* blk_starts, int& code_size, int& reloc_size
// Step one, perform a pessimistic sizing pass. // Step one, perform a pessimistic sizing pass.
uint last_call_adr = max_juint; uint last_call_adr = max_juint;
uint last_avoid_back_to_back_adr = max_juint; uint last_avoid_back_to_back_adr = max_juint;
uint nop_size = (new (this) MachNopNode())->size(_regalloc); uint nop_size = (new MachNopNode())->size(_regalloc);
for (uint i = 0; i < nblocks; i++) { // For all blocks for (uint i = 0; i < nblocks; i++) { // For all blocks
Block* block = _cfg->get_block(i); Block* block = _cfg->get_block(i);
@ -1201,7 +1201,7 @@ void Compile::fill_buffer(CodeBuffer* cb, uint* blk_starts) {
uint *call_returns = NEW_RESOURCE_ARRAY(uint, nblocks+1); uint *call_returns = NEW_RESOURCE_ARRAY(uint, nblocks+1);
uint return_offset = 0; uint return_offset = 0;
int nop_size = (new (this) MachNopNode())->size(_regalloc); int nop_size = (new MachNopNode())->size(_regalloc);
int previous_offset = 0; int previous_offset = 0;
int current_offset = 0; int current_offset = 0;
@ -1327,7 +1327,7 @@ void Compile::fill_buffer(CodeBuffer* cb, uint* blk_starts) {
if(padding > 0) { if(padding > 0) {
assert((padding % nop_size) == 0, "padding is not a multiple of NOP size"); assert((padding % nop_size) == 0, "padding is not a multiple of NOP size");
int nops_cnt = padding / nop_size; int nops_cnt = padding / nop_size;
MachNode *nop = new (this) MachNopNode(nops_cnt); MachNode *nop = new MachNopNode(nops_cnt);
block->insert_node(nop, j++); block->insert_node(nop, j++);
last_inst++; last_inst++;
_cfg->map_node_to_block(nop, block); _cfg->map_node_to_block(nop, block);
@ -1413,7 +1413,7 @@ void Compile::fill_buffer(CodeBuffer* cb, uint* blk_starts) {
assert((br_size - new_size) >= (int)nop_size, "short_branch size should be smaller"); assert((br_size - new_size) >= (int)nop_size, "short_branch size should be smaller");
// Insert padding between avoid_back_to_back branches. // Insert padding between avoid_back_to_back branches.
if (needs_padding && replacement->avoid_back_to_back(MachNode::AVOID_BEFORE)) { if (needs_padding && replacement->avoid_back_to_back(MachNode::AVOID_BEFORE)) {
MachNode *nop = new (this) MachNopNode(); MachNode *nop = new MachNopNode();
block->insert_node(nop, j++); block->insert_node(nop, j++);
_cfg->map_node_to_block(nop, block); _cfg->map_node_to_block(nop, block);
last_inst++; last_inst++;
@ -1573,7 +1573,7 @@ void Compile::fill_buffer(CodeBuffer* cb, uint* blk_starts) {
Block *nb = _cfg->get_block(i + 1); Block *nb = _cfg->get_block(i + 1);
int padding = nb->alignment_padding(current_offset); int padding = nb->alignment_padding(current_offset);
if( padding > 0 ) { if( padding > 0 ) {
MachNode *nop = new (this) MachNopNode(padding / nop_size); MachNode *nop = new MachNopNode(padding / nop_size);
block->insert_node(nop, block->number_of_nodes()); block->insert_node(nop, block->number_of_nodes());
_cfg->map_node_to_block(nop, block); _cfg->map_node_to_block(nop, block);
nop->emit(*cb, _regalloc); nop->emit(*cb, _regalloc);
@ -1786,7 +1786,7 @@ Scheduling::Scheduling(Arena *arena, Compile &compile)
#endif #endif
{ {
// Create a MachNopNode // Create a MachNopNode
_nop = new (&compile) MachNopNode(); _nop = new MachNopNode();
// Now that the nops are in the array, save the count // Now that the nops are in the array, save the count
// (but allow entries for the nops) // (but allow entries for the nops)
@ -2688,7 +2688,7 @@ void Scheduling::anti_do_def( Block *b, Node *def, OptoReg::Name def_reg, int is
if ( _pinch_free_list.size() > 0) { if ( _pinch_free_list.size() > 0) {
pinch = _pinch_free_list.pop(); pinch = _pinch_free_list.pop();
} else { } else {
pinch = new (_cfg->C) Node(1); // Pinch point to-be pinch = new Node(1); // Pinch point to-be
} }
if (pinch->_idx >= _regalloc->node_regs_max_index()) { if (pinch->_idx >= _regalloc->node_regs_max_index()) {
_cfg->C->record_method_not_compilable("too many D-U pinch points"); _cfg->C->record_method_not_compilable("too many D-U pinch points");

80
hotspot/src/share/vm/opto/parse1.cpp
View file

@ -109,10 +109,10 @@ Node *Parse::fetch_interpreter_state(int index,
// doubles on Sparc. Intel can handle them just fine directly. // doubles on Sparc. Intel can handle them just fine directly.
Node *l; Node *l;
switch (bt) { // Signature is flattened switch (bt) { // Signature is flattened
case T_INT: l = new (C) LoadINode(ctl, mem, adr, TypeRawPtr::BOTTOM, TypeInt::INT, MemNode::unordered); break; case T_INT: l = new LoadINode(ctl, mem, adr, TypeRawPtr::BOTTOM, TypeInt::INT, MemNode::unordered); break;
case T_FLOAT: l = new (C) LoadFNode(ctl, mem, adr, TypeRawPtr::BOTTOM, Type::FLOAT, MemNode::unordered); break; case T_FLOAT: l = new LoadFNode(ctl, mem, adr, TypeRawPtr::BOTTOM, Type::FLOAT, MemNode::unordered); break;
case T_ADDRESS: l = new (C) LoadPNode(ctl, mem, adr, TypeRawPtr::BOTTOM, TypeRawPtr::BOTTOM, MemNode::unordered); break; case T_ADDRESS: l = new LoadPNode(ctl, mem, adr, TypeRawPtr::BOTTOM, TypeRawPtr::BOTTOM, MemNode::unordered); break;
case T_OBJECT: l = new (C) LoadPNode(ctl, mem, adr, TypeRawPtr::BOTTOM, TypeInstPtr::BOTTOM, MemNode::unordered); break; case T_OBJECT: l = new LoadPNode(ctl, mem, adr, TypeRawPtr::BOTTOM, TypeInstPtr::BOTTOM, MemNode::unordered); break;
case T_LONG: case T_LONG:
case T_DOUBLE: { case T_DOUBLE: {
// Since arguments are in reverse order, the argument address 'adr' // Since arguments are in reverse order, the argument address 'adr'
@ -120,12 +120,12 @@ Node *Parse::fetch_interpreter_state(int index,
adr = basic_plus_adr(local_addrs_base, local_addrs, -(index+1)*wordSize); adr = basic_plus_adr(local_addrs_base, local_addrs, -(index+1)*wordSize);
if (Matcher::misaligned_doubles_ok) { if (Matcher::misaligned_doubles_ok) {
l = (bt == T_DOUBLE) l = (bt == T_DOUBLE)
? (Node*)new (C) LoadDNode(ctl, mem, adr, TypeRawPtr::BOTTOM, Type::DOUBLE, MemNode::unordered) ? (Node*)new LoadDNode(ctl, mem, adr, TypeRawPtr::BOTTOM, Type::DOUBLE, MemNode::unordered)
: (Node*)new (C) LoadLNode(ctl, mem, adr, TypeRawPtr::BOTTOM, TypeLong::LONG, MemNode::unordered); : (Node*)new LoadLNode(ctl, mem, adr, TypeRawPtr::BOTTOM, TypeLong::LONG, MemNode::unordered);
} else { } else {
l = (bt == T_DOUBLE) l = (bt == T_DOUBLE)
? (Node*)new (C) LoadD_unalignedNode(ctl, mem, adr, TypeRawPtr::BOTTOM, MemNode::unordered) ? (Node*)new LoadD_unalignedNode(ctl, mem, adr, TypeRawPtr::BOTTOM, MemNode::unordered)
: (Node*)new (C) LoadL_unalignedNode(ctl, mem, adr, TypeRawPtr::BOTTOM, MemNode::unordered); : (Node*)new LoadL_unalignedNode(ctl, mem, adr, TypeRawPtr::BOTTOM, MemNode::unordered);
} }
break; break;
} }
@ -149,11 +149,11 @@ Node* Parse::check_interpreter_type(Node* l, const Type* type,
if (type == TypePtr::NULL_PTR || if (type == TypePtr::NULL_PTR ||
(tp != NULL && !tp->klass()->is_loaded())) { (tp != NULL && !tp->klass()->is_loaded())) {
// Value must be null, not a real oop. // Value must be null, not a real oop.
Node* chk = _gvn.transform( new (C) CmpPNode(l, null()) ); Node* chk = _gvn.transform( new CmpPNode(l, null()) );
Node* tst = _gvn.transform( new (C) BoolNode(chk, BoolTest::eq) ); Node* tst = _gvn.transform( new BoolNode(chk, BoolTest::eq) );
IfNode* iff = create_and_map_if(control(), tst, PROB_MAX, COUNT_UNKNOWN); IfNode* iff = create_and_map_if(control(), tst, PROB_MAX, COUNT_UNKNOWN);
set_control(_gvn.transform( new (C) IfTrueNode(iff) )); set_control(_gvn.transform( new IfTrueNode(iff) ));
Node* bad_type = _gvn.transform( new (C) IfFalseNode(iff) ); Node* bad_type = _gvn.transform( new IfFalseNode(iff) );
bad_type_exit->control()->add_req(bad_type); bad_type_exit->control()->add_req(bad_type);
l = null(); l = null();
} }
@ -220,7 +220,7 @@ void Parse::load_interpreter_state(Node* osr_buf) {
Node *monitors_addr = basic_plus_adr(osr_buf, osr_buf, (max_locals+mcnt*2-1)*wordSize); Node *monitors_addr = basic_plus_adr(osr_buf, osr_buf, (max_locals+mcnt*2-1)*wordSize);
for (index = 0; index < mcnt; index++) { for (index = 0; index < mcnt; index++) {
// Make a BoxLockNode for the monitor. // Make a BoxLockNode for the monitor.
Node *box = _gvn.transform(new (C) BoxLockNode(next_monitor())); Node *box = _gvn.transform(new BoxLockNode(next_monitor()));
// Displaced headers and locked objects are interleaved in the // Displaced headers and locked objects are interleaved in the
@ -235,7 +235,7 @@ void Parse::load_interpreter_state(Node* osr_buf) {
// Build a bogus FastLockNode (no code will be generated) and push the // Build a bogus FastLockNode (no code will be generated) and push the
// monitor into our debug info. // monitor into our debug info.
const FastLockNode *flock = _gvn.transform(new (C) FastLockNode( 0, lock_object, box ))->as_FastLock(); const FastLockNode *flock = _gvn.transform(new FastLockNode( 0, lock_object, box ))->as_FastLock();
map()->push_monitor(flock); map()->push_monitor(flock);
// If the lock is our method synchronization lock, tuck it away in // If the lock is our method synchronization lock, tuck it away in
@ -325,7 +325,7 @@ void Parse::load_interpreter_state(Node* osr_buf) {
// Now that the interpreter state is loaded, make sure it will match // Now that the interpreter state is loaded, make sure it will match
// at execution time what the compiler is expecting now: // at execution time what the compiler is expecting now:
SafePointNode* bad_type_exit = clone_map(); SafePointNode* bad_type_exit = clone_map();
bad_type_exit->set_control(new (C) RegionNode(1)); bad_type_exit->set_control(new RegionNode(1));
assert(osr_block->flow()->jsrs()->size() == 0, "should be no jsrs live at osr point"); assert(osr_block->flow()->jsrs()->size() == 0, "should be no jsrs live at osr point");
for (index = 0; index < max_locals; index++) { for (index = 0; index < max_locals; index++) {
@ -661,7 +661,7 @@ void Parse::do_all_blocks() {
add_predicate(); add_predicate();
// Add new region for back branches. // Add new region for back branches.
int edges = block->pred_count() - block->preds_parsed() + 1; // +1 for original region int edges = block->pred_count() - block->preds_parsed() + 1; // +1 for original region
RegionNode *r = new (C) RegionNode(edges+1); RegionNode *r = new RegionNode(edges+1);
_gvn.set_type(r, Type::CONTROL); _gvn.set_type(r, Type::CONTROL);
record_for_igvn(r); record_for_igvn(r);
r->init_req(edges, control()); r->init_req(edges, control());
@ -728,14 +728,14 @@ void Parse::build_exits() {
_exits.clean_stack(_exits.sp()); _exits.clean_stack(_exits.sp());
_exits.sync_jvms(); _exits.sync_jvms();
RegionNode* region = new (C) RegionNode(1); RegionNode* region = new RegionNode(1);
record_for_igvn(region); record_for_igvn(region);
gvn().set_type_bottom(region); gvn().set_type_bottom(region);
_exits.set_control(region); _exits.set_control(region);
// Note: iophi and memphi are not transformed until do_exits. // Note: iophi and memphi are not transformed until do_exits.
Node* iophi = new (C) PhiNode(region, Type::ABIO); Node* iophi = new PhiNode(region, Type::ABIO);
Node* memphi = new (C) PhiNode(region, Type::MEMORY, TypePtr::BOTTOM); Node* memphi = new PhiNode(region, Type::MEMORY, TypePtr::BOTTOM);
gvn().set_type_bottom(iophi); gvn().set_type_bottom(iophi);
gvn().set_type_bottom(memphi); gvn().set_type_bottom(memphi);
_exits.set_i_o(iophi); _exits.set_i_o(iophi);
@ -752,7 +752,7 @@ void Parse::build_exits() {
ret_type = TypeOopPtr::BOTTOM; ret_type = TypeOopPtr::BOTTOM;
} }
int ret_size = type2size[ret_type->basic_type()]; int ret_size = type2size[ret_type->basic_type()];
Node* ret_phi = new (C) PhiNode(region, ret_type); Node* ret_phi = new PhiNode(region, ret_type);
gvn().set_type_bottom(ret_phi); gvn().set_type_bottom(ret_phi);
_exits.ensure_stack(ret_size); _exits.ensure_stack(ret_size);
assert((int)(tf()->range()->cnt() - TypeFunc::Parms) == ret_size, "good tf range"); assert((int)(tf()->range()->cnt() - TypeFunc::Parms) == ret_size, "good tf range");
@ -770,7 +770,7 @@ JVMState* Compile::build_start_state(StartNode* start, const TypeFunc* tf) {
int arg_size = tf->domain()->cnt(); int arg_size = tf->domain()->cnt();
int max_size = MAX2(arg_size, (int)tf->range()->cnt()); int max_size = MAX2(arg_size, (int)tf->range()->cnt());
JVMState* jvms = new (this) JVMState(max_size - TypeFunc::Parms); JVMState* jvms = new (this) JVMState(max_size - TypeFunc::Parms);
SafePointNode* map = new (this) SafePointNode(max_size, NULL); SafePointNode* map = new SafePointNode(max_size, NULL);
record_for_igvn(map); record_for_igvn(map);
assert(arg_size == TypeFunc::Parms + (is_osr_compilation() ? 1 : method()->arg_size()), "correct arg_size"); assert(arg_size == TypeFunc::Parms + (is_osr_compilation() ? 1 : method()->arg_size()), "correct arg_size");
Node_Notes* old_nn = default_node_notes(); Node_Notes* old_nn = default_node_notes();
@ -784,7 +784,7 @@ JVMState* Compile::build_start_state(StartNode* start, const TypeFunc* tf) {
} }
uint i; uint i;
for (i = 0; i < (uint)arg_size; i++) { for (i = 0; i < (uint)arg_size; i++) {
Node* parm = initial_gvn()->transform(new (this) ParmNode(start, i)); Node* parm = initial_gvn()->transform(new ParmNode(start, i));
map->init_req(i, parm); map->init_req(i, parm);
// Record all these guys for later GVN. // Record all these guys for later GVN.
record_for_igvn(parm); record_for_igvn(parm);
@ -815,7 +815,7 @@ Node_Notes* Parse::make_node_notes(Node_Notes* caller_nn) {
//--------------------------return_values-------------------------------------- //--------------------------return_values--------------------------------------
void Compile::return_values(JVMState* jvms) { void Compile::return_values(JVMState* jvms) {
GraphKit kit(jvms); GraphKit kit(jvms);
Node* ret = new (this) ReturnNode(TypeFunc::Parms, Node* ret = new ReturnNode(TypeFunc::Parms,
kit.control(), kit.control(),
kit.i_o(), kit.i_o(),
kit.reset_memory(), kit.reset_memory(),
@ -843,7 +843,7 @@ void Compile::rethrow_exceptions(JVMState* jvms) {
// Load my combined exception state into the kit, with all phis transformed: // Load my combined exception state into the kit, with all phis transformed:
SafePointNode* ex_map = kit.combine_and_pop_all_exception_states(); SafePointNode* ex_map = kit.combine_and_pop_all_exception_states();
Node* ex_oop = kit.use_exception_state(ex_map); Node* ex_oop = kit.use_exception_state(ex_map);
RethrowNode* exit = new (this) RethrowNode(kit.control(), RethrowNode* exit = new RethrowNode(kit.control(),
kit.i_o(), kit.reset_memory(), kit.i_o(), kit.reset_memory(),
kit.frameptr(), kit.returnadr(), kit.frameptr(), kit.returnadr(),
// like a return but with exception input // like a return but with exception input
@ -1065,7 +1065,7 @@ SafePointNode* Parse::create_entry_map() {
// Create an initial safepoint to hold JVM state during parsing // Create an initial safepoint to hold JVM state during parsing
JVMState* jvms = new (C) JVMState(method(), _caller->has_method() ? _caller : NULL); JVMState* jvms = new (C) JVMState(method(), _caller->has_method() ? _caller : NULL);
set_map(new (C) SafePointNode(len, jvms)); set_map(new SafePointNode(len, jvms));
jvms->set_map(map()); jvms->set_map(map());
record_for_igvn(map()); record_for_igvn(map());
assert(jvms->endoff() == len, "correct jvms sizing"); assert(jvms->endoff() == len, "correct jvms sizing");
@ -1578,7 +1578,7 @@ void Parse::merge_common(Parse::Block* target, int pnum) {
// later lazily. // later lazily.
int edges = target->pred_count(); int edges = target->pred_count();
if (edges < pnum) edges = pnum; // might be a new path! if (edges < pnum) edges = pnum; // might be a new path!
RegionNode *r = new (C) RegionNode(edges+1); RegionNode *r = new RegionNode(edges+1);
gvn().set_type(r, Type::CONTROL); gvn().set_type(r, Type::CONTROL);
record_for_igvn(r); record_for_igvn(r);
// zap all inputs to NULL for debugging (done in Node(uint) constructor) // zap all inputs to NULL for debugging (done in Node(uint) constructor)
@ -1973,19 +1973,19 @@ void Parse::call_register_finalizer() {
Node* access_flags_addr = basic_plus_adr(klass, klass, in_bytes(Klass::access_flags_offset())); Node* access_flags_addr = basic_plus_adr(klass, klass, in_bytes(Klass::access_flags_offset()));
Node* access_flags = make_load(NULL, access_flags_addr, TypeInt::INT, T_INT, MemNode::unordered); Node* access_flags = make_load(NULL, access_flags_addr, TypeInt::INT, T_INT, MemNode::unordered);
Node* mask = _gvn.transform(new (C) AndINode(access_flags, intcon(JVM_ACC_HAS_FINALIZER))); Node* mask = _gvn.transform(new AndINode(access_flags, intcon(JVM_ACC_HAS_FINALIZER)));
Node* check = _gvn.transform(new (C) CmpINode(mask, intcon(0))); Node* check = _gvn.transform(new CmpINode(mask, intcon(0)));
Node* test = _gvn.transform(new (C) BoolNode(check, BoolTest::ne)); Node* test = _gvn.transform(new BoolNode(check, BoolTest::ne));
IfNode* iff = create_and_map_if(control(), test, PROB_MAX, COUNT_UNKNOWN); IfNode* iff = create_and_map_if(control(), test, PROB_MAX, COUNT_UNKNOWN);
RegionNode* result_rgn = new (C) RegionNode(3); RegionNode* result_rgn = new RegionNode(3);
record_for_igvn(result_rgn); record_for_igvn(result_rgn);
Node *skip_register = _gvn.transform(new (C) IfFalseNode(iff)); Node *skip_register = _gvn.transform(new IfFalseNode(iff));
result_rgn->init_req(1, skip_register); result_rgn->init_req(1, skip_register);
Node *needs_register = _gvn.transform(new (C) IfTrueNode(iff)); Node *needs_register = _gvn.transform(new IfTrueNode(iff));
set_control(needs_register); set_control(needs_register);
if (stopped()) { if (stopped()) {
// There is no slow path. // There is no slow path.
@ -2039,9 +2039,9 @@ void Parse::rtm_deopt() {
// or with ProfileRTM (cmp->in(2)) otherwise so that // or with ProfileRTM (cmp->in(2)) otherwise so that
// the check will fold. // the check will fold.
Node* profile_state = makecon(TypeInt::make(ProfileRTM)); Node* profile_state = makecon(TypeInt::make(ProfileRTM));
Node* opq = _gvn.transform( new (C) Opaque3Node(C, rtm_state, Opaque3Node::RTM_OPT) ); Node* opq = _gvn.transform( new Opaque3Node(C, rtm_state, Opaque3Node::RTM_OPT) );
Node* chk = _gvn.transform( new (C) CmpINode(opq, profile_state) ); Node* chk = _gvn.transform( new CmpINode(opq, profile_state) );
Node* tst = _gvn.transform( new (C) BoolNode(chk, BoolTest::eq) ); Node* tst = _gvn.transform( new BoolNode(chk, BoolTest::eq) );
// Branch to failure if state was changed // Branch to failure if state was changed
{ BuildCutout unless(this, tst, PROB_ALWAYS); { BuildCutout unless(this, tst, PROB_ALWAYS);
uncommon_trap(Deoptimization::Reason_rtm_state_change, uncommon_trap(Deoptimization::Reason_rtm_state_change,
@ -2066,10 +2066,10 @@ void Parse::decrement_age() {
Node* mc_adr = makecon(adr_type); Node* mc_adr = makecon(adr_type);
Node* cnt_adr = basic_plus_adr(mc_adr, mc_adr, in_bytes(MethodCounters::nmethod_age_offset())); Node* cnt_adr = basic_plus_adr(mc_adr, mc_adr, in_bytes(MethodCounters::nmethod_age_offset()));
Node* cnt = make_load(control(), cnt_adr, TypeInt::INT, T_INT, adr_type, MemNode::unordered); Node* cnt = make_load(control(), cnt_adr, TypeInt::INT, T_INT, adr_type, MemNode::unordered);
Node* decr = _gvn.transform(new (C) SubINode(cnt, makecon(TypeInt::ONE))); Node* decr = _gvn.transform(new SubINode(cnt, makecon(TypeInt::ONE)));
store_to_memory(control(), cnt_adr, decr, T_INT, adr_type, MemNode::unordered); store_to_memory(control(), cnt_adr, decr, T_INT, adr_type, MemNode::unordered);
Node *chk = _gvn.transform(new (C) CmpINode(decr, makecon(TypeInt::ZERO))); Node *chk = _gvn.transform(new CmpINode(decr, makecon(TypeInt::ZERO)));
Node* tst = _gvn.transform(new (C) BoolNode(chk, BoolTest::gt)); Node* tst = _gvn.transform(new BoolNode(chk, BoolTest::gt));
{ BuildCutout unless(this, tst, PROB_ALWAYS); { BuildCutout unless(this, tst, PROB_ALWAYS);
uncommon_trap(Deoptimization::Reason_tenured, uncommon_trap(Deoptimization::Reason_tenured,
Deoptimization::Action_make_not_entrant); Deoptimization::Action_make_not_entrant);
@ -2124,7 +2124,7 @@ void Parse::return_current(Node* value) {
// sharpen the type eagerly; this eases certain assert checking // sharpen the type eagerly; this eases certain assert checking
if (tp->higher_equal(TypeInstPtr::NOTNULL)) if (tp->higher_equal(TypeInstPtr::NOTNULL))
tr = tr->join_speculative(TypeInstPtr::NOTNULL)->is_instptr(); tr = tr->join_speculative(TypeInstPtr::NOTNULL)->is_instptr();
value = _gvn.transform(new (C) CheckCastPPNode(0,value,tr)); value = _gvn.transform(new CheckCastPPNode(0,value,tr));
} }
} }
phi->add_req(value); phi->add_req(value);
@ -2159,7 +2159,7 @@ void Parse::add_safepoint() {
kill_dead_locals(); kill_dead_locals();
// Clone the JVM State // Clone the JVM State
SafePointNode *sfpnt = new (C) SafePointNode(parms, NULL); SafePointNode *sfpnt = new SafePointNode(parms, NULL);
// Capture memory state BEFORE a SafePoint. Since we can block at a // Capture memory state BEFORE a SafePoint. Since we can block at a
// SafePoint we need our GC state to be safe; i.e. we need all our current // SafePoint we need our GC state to be safe; i.e. we need all our current

210
hotspot/src/share/vm/opto/parse2.cpp
View file

@ -130,9 +130,9 @@ Node* Parse::array_addressing(BasicType type, int vals, const Type* *result2) {
Node* len = load_array_length(ary); Node* len = load_array_length(ary);
// Test length vs index (standard trick using unsigned compare) // Test length vs index (standard trick using unsigned compare)
Node* chk = _gvn.transform( new (C) CmpUNode(idx, len) ); Node* chk = _gvn.transform( new CmpUNode(idx, len) );
BoolTest::mask btest = BoolTest::lt; BoolTest::mask btest = BoolTest::lt;
tst = _gvn.transform( new (C) BoolNode(chk, btest) ); tst = _gvn.transform( new BoolNode(chk, btest) );
} }
// Branch to failure if out of bounds // Branch to failure if out of bounds
{ BuildCutout unless(this, tst, PROB_MAX); { BuildCutout unless(this, tst, PROB_MAX);
@ -168,15 +168,15 @@ Node* Parse::array_addressing(BasicType type, int vals, const Type* *result2) {
// returns IfNode // returns IfNode
IfNode* Parse::jump_if_fork_int(Node* a, Node* b, BoolTest::mask mask) { IfNode* Parse::jump_if_fork_int(Node* a, Node* b, BoolTest::mask mask) {
Node *cmp = _gvn.transform( new (C) CmpINode( a, b)); // two cases: shiftcount > 32 and shiftcount <= 32 Node *cmp = _gvn.transform( new CmpINode( a, b)); // two cases: shiftcount > 32 and shiftcount <= 32
Node *tst = _gvn.transform( new (C) BoolNode( cmp, mask)); Node *tst = _gvn.transform( new BoolNode( cmp, mask));
IfNode *iff = create_and_map_if( control(), tst, ((mask == BoolTest::eq) ? PROB_STATIC_INFREQUENT : PROB_FAIR), COUNT_UNKNOWN ); IfNode *iff = create_and_map_if( control(), tst, ((mask == BoolTest::eq) ? PROB_STATIC_INFREQUENT : PROB_FAIR), COUNT_UNKNOWN );
return iff; return iff;
} }
// return Region node // return Region node
Node* Parse::jump_if_join(Node* iffalse, Node* iftrue) { Node* Parse::jump_if_join(Node* iffalse, Node* iftrue) {
Node *region = new (C) RegionNode(3); // 2 results Node *region = new RegionNode(3); // 2 results
record_for_igvn(region); record_for_igvn(region);
region->init_req(1, iffalse); region->init_req(1, iffalse);
region->init_req(2, iftrue ); region->init_req(2, iftrue );
@ -191,28 +191,28 @@ Node* Parse::jump_if_join(Node* iffalse, Node* iftrue) {
void Parse::jump_if_true_fork(IfNode *iff, int dest_bci_if_true, int prof_table_index) { void Parse::jump_if_true_fork(IfNode *iff, int dest_bci_if_true, int prof_table_index) {
// True branch, use existing map info // True branch, use existing map info
{ PreserveJVMState pjvms(this); { PreserveJVMState pjvms(this);
Node *iftrue = _gvn.transform( new (C) IfTrueNode (iff) ); Node *iftrue = _gvn.transform( new IfTrueNode (iff) );
set_control( iftrue ); set_control( iftrue );
profile_switch_case(prof_table_index); profile_switch_case(prof_table_index);
merge_new_path(dest_bci_if_true); merge_new_path(dest_bci_if_true);
} }
// False branch // False branch
Node *iffalse = _gvn.transform( new (C) IfFalseNode(iff) ); Node *iffalse = _gvn.transform( new IfFalseNode(iff) );
set_control( iffalse ); set_control( iffalse );
} }
void Parse::jump_if_false_fork(IfNode *iff, int dest_bci_if_true, int prof_table_index) { void Parse::jump_if_false_fork(IfNode *iff, int dest_bci_if_true, int prof_table_index) {
// True branch, use existing map info // True branch, use existing map info
{ PreserveJVMState pjvms(this); { PreserveJVMState pjvms(this);
Node *iffalse = _gvn.transform( new (C) IfFalseNode (iff) ); Node *iffalse = _gvn.transform( new IfFalseNode (iff) );
set_control( iffalse ); set_control( iffalse );
profile_switch_case(prof_table_index); profile_switch_case(prof_table_index);
merge_new_path(dest_bci_if_true); merge_new_path(dest_bci_if_true);
} }
// False branch // False branch
Node *iftrue = _gvn.transform( new (C) IfTrueNode(iff) ); Node *iftrue = _gvn.transform( new IfTrueNode(iff) );
set_control( iftrue ); set_control( iftrue );
} }
@ -440,14 +440,14 @@ bool Parse::create_jump_tables(Node* key_val, SwitchRange* lo, SwitchRange* hi)
// Normalize table lookups to zero // Normalize table lookups to zero
int lowval = lo->lo(); int lowval = lo->lo();
key_val = _gvn.transform( new (C) SubINode(key_val, _gvn.intcon(lowval)) ); key_val = _gvn.transform( new SubINode(key_val, _gvn.intcon(lowval)) );
// Generate a guard to protect against input keyvals that aren't // Generate a guard to protect against input keyvals that aren't
// in the switch domain. // in the switch domain.
if (needs_guard) { if (needs_guard) {
Node* size = _gvn.intcon(num_cases); Node* size = _gvn.intcon(num_cases);
Node* cmp = _gvn.transform( new (C) CmpUNode(key_val, size) ); Node* cmp = _gvn.transform( new CmpUNode(key_val, size) );
Node* tst = _gvn.transform( new (C) BoolNode(cmp, BoolTest::ge) ); Node* tst = _gvn.transform( new BoolNode(cmp, BoolTest::ge) );
IfNode* iff = create_and_map_if( control(), tst, PROB_FAIR, COUNT_UNKNOWN); IfNode* iff = create_and_map_if( control(), tst, PROB_FAIR, COUNT_UNKNOWN);
jump_if_true_fork(iff, default_dest, NullTableIndex); jump_if_true_fork(iff, default_dest, NullTableIndex);
} }
@ -460,21 +460,21 @@ bool Parse::create_jump_tables(Node* key_val, SwitchRange* lo, SwitchRange* hi)
// Clean the 32-bit int into a real 64-bit offset. // Clean the 32-bit int into a real 64-bit offset.
// Otherwise, the jint value 0 might turn into an offset of 0x0800000000. // Otherwise, the jint value 0 might turn into an offset of 0x0800000000.
const TypeLong* lkeytype = TypeLong::make(CONST64(0), num_cases-1, Type::WidenMin); const TypeLong* lkeytype = TypeLong::make(CONST64(0), num_cases-1, Type::WidenMin);
key_val = _gvn.transform( new (C) ConvI2LNode(key_val, lkeytype) ); key_val = _gvn.transform( new ConvI2LNode(key_val, lkeytype) );
#endif #endif
// Shift the value by wordsize so we have an index into the table, rather // Shift the value by wordsize so we have an index into the table, rather
// than a switch value // than a switch value
Node *shiftWord = _gvn.MakeConX(wordSize); Node *shiftWord = _gvn.MakeConX(wordSize);
key_val = _gvn.transform( new (C) MulXNode( key_val, shiftWord)); key_val = _gvn.transform( new MulXNode( key_val, shiftWord));
// Create the JumpNode // Create the JumpNode
Node* jtn = _gvn.transform( new (C) JumpNode(control(), key_val, num_cases) ); Node* jtn = _gvn.transform( new JumpNode(control(), key_val, num_cases) );
// These are the switch destinations hanging off the jumpnode // These are the switch destinations hanging off the jumpnode
int i = 0; int i = 0;
for (SwitchRange* r = lo; r <= hi; r++) { for (SwitchRange* r = lo; r <= hi; r++) {
for (int64_t j = r->lo(); j <= r->hi(); j++, i++) { for (int64_t j = r->lo(); j <= r->hi(); j++, i++) {
Node* input = _gvn.transform(new (C) JumpProjNode(jtn, i, r->dest(), (int)(j - lowval))); Node* input = _gvn.transform(new JumpProjNode(jtn, i, r->dest(), (int)(j - lowval)));
{ {
PreserveJVMState pjvms(this); PreserveJVMState pjvms(this);
set_control(input); set_control(input);
@ -575,8 +575,8 @@ void Parse::jump_switch_ranges(Node* key_val, SwitchRange *lo, SwitchRange *hi,
// two comparisons of same values--should enable 1 test for 2 branches // two comparisons of same values--should enable 1 test for 2 branches
// Use BoolTest::le instead of BoolTest::gt // Use BoolTest::le instead of BoolTest::gt
IfNode *iff_le = jump_if_fork_int(key_val, test_val, BoolTest::le); IfNode *iff_le = jump_if_fork_int(key_val, test_val, BoolTest::le);
Node *iftrue = _gvn.transform( new (C) IfTrueNode(iff_le) ); Node *iftrue = _gvn.transform( new IfTrueNode(iff_le) );
Node *iffalse = _gvn.transform( new (C) IfFalseNode(iff_le) ); Node *iffalse = _gvn.transform( new IfFalseNode(iff_le) );
{ PreserveJVMState pjvms(this); { PreserveJVMState pjvms(this);
set_control(iffalse); set_control(iffalse);
jump_switch_ranges(key_val, mid+1, hi, switch_depth+1); jump_switch_ranges(key_val, mid+1, hi, switch_depth+1);
@ -592,8 +592,8 @@ void Parse::jump_switch_ranges(Node* key_val, SwitchRange *lo, SwitchRange *hi,
if (mid == hi) { if (mid == hi) {
jump_if_true_fork(iff_ge, mid->dest(), mid->table_index()); jump_if_true_fork(iff_ge, mid->dest(), mid->table_index());
} else { } else {
Node *iftrue = _gvn.transform( new (C) IfTrueNode(iff_ge) ); Node *iftrue = _gvn.transform( new IfTrueNode(iff_ge) );
Node *iffalse = _gvn.transform( new (C) IfFalseNode(iff_ge) ); Node *iffalse = _gvn.transform( new IfFalseNode(iff_ge) );
{ PreserveJVMState pjvms(this); { PreserveJVMState pjvms(this);
set_control(iftrue); set_control(iftrue);
jump_switch_ranges(key_val, mid, hi, switch_depth+1); jump_switch_ranges(key_val, mid, hi, switch_depth+1);
@ -648,7 +648,7 @@ void Parse::modf() {
CAST_FROM_FN_PTR(address, SharedRuntime::frem), CAST_FROM_FN_PTR(address, SharedRuntime::frem),
"frem", NULL, //no memory effects "frem", NULL, //no memory effects
f1, f2); f1, f2);
Node* res = _gvn.transform(new (C) ProjNode(c, TypeFunc::Parms + 0)); Node* res = _gvn.transform(new ProjNode(c, TypeFunc::Parms + 0));
push(res); push(res);
} }
@ -660,10 +660,10 @@ void Parse::modd() {
CAST_FROM_FN_PTR(address, SharedRuntime::drem), CAST_FROM_FN_PTR(address, SharedRuntime::drem),
"drem", NULL, //no memory effects "drem", NULL, //no memory effects
d1, top(), d2, top()); d1, top(), d2, top());
Node* res_d = _gvn.transform(new (C) ProjNode(c, TypeFunc::Parms + 0)); Node* res_d = _gvn.transform(new ProjNode(c, TypeFunc::Parms + 0));
#ifdef ASSERT #ifdef ASSERT
Node* res_top = _gvn.transform(new (C) ProjNode(c, TypeFunc::Parms + 1)); Node* res_top = _gvn.transform(new ProjNode(c, TypeFunc::Parms + 1));
assert(res_top == top(), "second value must be top"); assert(res_top == top(), "second value must be top");
#endif #endif
@ -677,7 +677,7 @@ void Parse::l2f() {
CAST_FROM_FN_PTR(address, SharedRuntime::l2f), CAST_FROM_FN_PTR(address, SharedRuntime::l2f),
"l2f", NULL, //no memory effects "l2f", NULL, //no memory effects
f1, f2); f1, f2);
Node* res = _gvn.transform(new (C) ProjNode(c, TypeFunc::Parms + 0)); Node* res = _gvn.transform(new ProjNode(c, TypeFunc::Parms + 0));
push(res); push(res);
} }
@ -704,17 +704,17 @@ void Parse::do_irem() {
// Sigh, must handle negative dividends // Sigh, must handle negative dividends
Node *zero = _gvn.intcon(0); Node *zero = _gvn.intcon(0);
IfNode *ifff = jump_if_fork_int(a, zero, BoolTest::lt); IfNode *ifff = jump_if_fork_int(a, zero, BoolTest::lt);
Node *iff = _gvn.transform( new (C) IfFalseNode(ifff) ); Node *iff = _gvn.transform( new IfFalseNode(ifff) );
Node *ift = _gvn.transform( new (C) IfTrueNode (ifff) ); Node *ift = _gvn.transform( new IfTrueNode (ifff) );
Node *reg = jump_if_join(ift, iff); Node *reg = jump_if_join(ift, iff);
Node *phi = PhiNode::make(reg, NULL, TypeInt::INT); Node *phi = PhiNode::make(reg, NULL, TypeInt::INT);
// Negative path; negate/and/negate // Negative path; negate/and/negate
Node *neg = _gvn.transform( new (C) SubINode(zero, a) ); Node *neg = _gvn.transform( new SubINode(zero, a) );
Node *andn= _gvn.transform( new (C) AndINode(neg, mask) ); Node *andn= _gvn.transform( new AndINode(neg, mask) );
Node *negn= _gvn.transform( new (C) SubINode(zero, andn) ); Node *negn= _gvn.transform( new SubINode(zero, andn) );
phi->init_req(1, negn); phi->init_req(1, negn);
// Fast positive case // Fast positive case
Node *andx = _gvn.transform( new (C) AndINode(a, mask) ); Node *andx = _gvn.transform( new AndINode(a, mask) );
phi->init_req(2, andx); phi->init_req(2, andx);
// Push the merge // Push the merge
push( _gvn.transform(phi) ); push( _gvn.transform(phi) );
@ -723,7 +723,7 @@ void Parse::do_irem() {
} }
} }
// Default case // Default case
push( _gvn.transform( new (C) ModINode(control(),a,b) ) ); push( _gvn.transform( new ModINode(control(),a,b) ) );
} }
// Handle jsr and jsr_w bytecode // Handle jsr and jsr_w bytecode
@ -1000,7 +1000,7 @@ void Parse::do_ifnull(BoolTest::mask btest, Node *c) {
explicit_null_checks_inserted++; explicit_null_checks_inserted++;
// Generate real control flow // Generate real control flow
Node *tst = _gvn.transform( new (C) BoolNode( c, btest ) ); Node *tst = _gvn.transform( new BoolNode( c, btest ) );
// Sanity check the probability value // Sanity check the probability value
assert(prob > 0.0f,"Bad probability in Parser"); assert(prob > 0.0f,"Bad probability in Parser");
@ -1009,7 +1009,7 @@ void Parse::do_ifnull(BoolTest::mask btest, Node *c) {
assert(iff->_prob > 0.0f,"Optimizer made bad probability in parser"); assert(iff->_prob > 0.0f,"Optimizer made bad probability in parser");
// True branch // True branch
{ PreserveJVMState pjvms(this); { PreserveJVMState pjvms(this);
Node* iftrue = _gvn.transform( new (C) IfTrueNode (iff) ); Node* iftrue = _gvn.transform( new IfTrueNode (iff) );
set_control(iftrue); set_control(iftrue);
if (stopped()) { // Path is dead? if (stopped()) { // Path is dead?
@ -1029,7 +1029,7 @@ void Parse::do_ifnull(BoolTest::mask btest, Node *c) {
} }
// False branch // False branch
Node* iffalse = _gvn.transform( new (C) IfFalseNode(iff) ); Node* iffalse = _gvn.transform( new IfFalseNode(iff) );
set_control(iffalse); set_control(iffalse);
if (stopped()) { // Path is dead? if (stopped()) { // Path is dead?
@ -1092,7 +1092,7 @@ void Parse::do_if(BoolTest::mask btest, Node* c) {
} }
assert(btest != BoolTest::eq, "!= is the only canonical exact test"); assert(btest != BoolTest::eq, "!= is the only canonical exact test");
Node* tst0 = new (C) BoolNode(c, btest); Node* tst0 = new BoolNode(c, btest);
Node* tst = _gvn.transform(tst0); Node* tst = _gvn.transform(tst0);
BoolTest::mask taken_btest = BoolTest::illegal; BoolTest::mask taken_btest = BoolTest::illegal;
BoolTest::mask untaken_btest = BoolTest::illegal; BoolTest::mask untaken_btest = BoolTest::illegal;
@ -1123,8 +1123,8 @@ void Parse::do_if(BoolTest::mask btest, Node* c) {
float true_prob = (taken_if_true ? prob : untaken_prob); float true_prob = (taken_if_true ? prob : untaken_prob);
IfNode* iff = create_and_map_if(control(), tst, true_prob, cnt); IfNode* iff = create_and_map_if(control(), tst, true_prob, cnt);
assert(iff->_prob > 0.0f,"Optimizer made bad probability in parser"); assert(iff->_prob > 0.0f,"Optimizer made bad probability in parser");
Node* taken_branch = new (C) IfTrueNode(iff); Node* taken_branch = new IfTrueNode(iff);
Node* untaken_branch = new (C) IfFalseNode(iff); Node* untaken_branch = new IfFalseNode(iff);
if (!taken_if_true) { // Finish conversion to canonical form if (!taken_if_true) { // Finish conversion to canonical form
Node* tmp = taken_branch; Node* tmp = taken_branch;
taken_branch = untaken_branch; taken_branch = untaken_branch;
@ -1288,7 +1288,7 @@ void Parse::sharpen_type_after_if(BoolTest::mask btest,
JVMState* jvms = this->jvms(); JVMState* jvms = this->jvms();
if (obj_in_map >= 0 && if (obj_in_map >= 0 &&
(jvms->is_loc(obj_in_map) || jvms->is_stk(obj_in_map))) { (jvms->is_loc(obj_in_map) || jvms->is_stk(obj_in_map))) {
TypeNode* ccast = new (C) CheckCastPPNode(control(), obj, tboth); TypeNode* ccast = new CheckCastPPNode(control(), obj, tboth);
const Type* tcc = ccast->as_Type()->type(); const Type* tcc = ccast->as_Type()->type();
assert(tcc != obj_type && tcc->higher_equal(obj_type), "must improve"); assert(tcc != obj_type && tcc->higher_equal(obj_type), "must improve");
// Delay transform() call to allow recovery of pre-cast value // Delay transform() call to allow recovery of pre-cast value
@ -1323,10 +1323,10 @@ void Parse::sharpen_type_after_if(BoolTest::mask btest,
const Type* tboth = tcon->join_speculative(tval); const Type* tboth = tcon->join_speculative(tval);
if (tboth == tval) break; // Nothing to gain. if (tboth == tval) break; // Nothing to gain.
if (tcon->isa_int()) { if (tcon->isa_int()) {
ccast = new (C) CastIINode(val, tboth); ccast = new CastIINode(val, tboth);
} else if (tcon == TypePtr::NULL_PTR) { } else if (tcon == TypePtr::NULL_PTR) {
// Cast to null, but keep the pointer identity temporarily live. // Cast to null, but keep the pointer identity temporarily live.
ccast = new (C) CastPPNode(val, tboth); ccast = new CastPPNode(val, tboth);
} else { } else {
const TypeF* tf = tcon->isa_float_constant(); const TypeF* tf = tcon->isa_float_constant();
const TypeD* td = tcon->isa_double_constant(); const TypeD* td = tcon->isa_double_constant();
@ -1792,59 +1792,59 @@ void Parse::do_one_bytecode() {
if (stopped()) return; if (stopped()) return;
b = pop(); b = pop();
a = pop(); a = pop();
push( _gvn.transform( new (C) DivINode(control(),a,b) ) ); push( _gvn.transform( new DivINode(control(),a,b) ) );
break; break;
case Bytecodes::_imul: case Bytecodes::_imul:
b = pop(); a = pop(); b = pop(); a = pop();
push( _gvn.transform( new (C) MulINode(a,b) ) ); push( _gvn.transform( new MulINode(a,b) ) );
break; break;
case Bytecodes::_iadd: case Bytecodes::_iadd:
b = pop(); a = pop(); b = pop(); a = pop();
push( _gvn.transform( new (C) AddINode(a,b) ) ); push( _gvn.transform( new AddINode(a,b) ) );
break; break;
case Bytecodes::_ineg: case Bytecodes::_ineg:
a = pop(); a = pop();
push( _gvn.transform( new (C) SubINode(_gvn.intcon(0),a)) ); push( _gvn.transform( new SubINode(_gvn.intcon(0),a)) );
break; break;
case Bytecodes::_isub: case Bytecodes::_isub:
b = pop(); a = pop(); b = pop(); a = pop();
push( _gvn.transform( new (C) SubINode(a,b) ) ); push( _gvn.transform( new SubINode(a,b) ) );
break; break;
case Bytecodes::_iand: case Bytecodes::_iand:
b = pop(); a = pop(); b = pop(); a = pop();
push( _gvn.transform( new (C) AndINode(a,b) ) ); push( _gvn.transform( new AndINode(a,b) ) );
break; break;
case Bytecodes::_ior: case Bytecodes::_ior:
b = pop(); a = pop(); b = pop(); a = pop();
push( _gvn.transform( new (C) OrINode(a,b) ) ); push( _gvn.transform( new OrINode(a,b) ) );
break; break;
case Bytecodes::_ixor: case Bytecodes::_ixor:
b = pop(); a = pop(); b = pop(); a = pop();
push( _gvn.transform( new (C) XorINode(a,b) ) ); push( _gvn.transform( new XorINode(a,b) ) );
break; break;
case Bytecodes::_ishl: case Bytecodes::_ishl:
b = pop(); a = pop(); b = pop(); a = pop();
push( _gvn.transform( new (C) LShiftINode(a,b) ) ); push( _gvn.transform( new LShiftINode(a,b) ) );
break; break;
case Bytecodes::_ishr: case Bytecodes::_ishr:
b = pop(); a = pop(); b = pop(); a = pop();
push( _gvn.transform( new (C) RShiftINode(a,b) ) ); push( _gvn.transform( new RShiftINode(a,b) ) );
break; break;
case Bytecodes::_iushr: case Bytecodes::_iushr:
b = pop(); a = pop(); b = pop(); a = pop();
push( _gvn.transform( new (C) URShiftINode(a,b) ) ); push( _gvn.transform( new URShiftINode(a,b) ) );
break; break;
case Bytecodes::_fneg: case Bytecodes::_fneg:
a = pop(); a = pop();
b = _gvn.transform(new (C) NegFNode (a)); b = _gvn.transform(new NegFNode (a));
push(b); push(b);
break; break;
case Bytecodes::_fsub: case Bytecodes::_fsub:
b = pop(); b = pop();
a = pop(); a = pop();
c = _gvn.transform( new (C) SubFNode(a,b) ); c = _gvn.transform( new SubFNode(a,b) );
d = precision_rounding(c); d = precision_rounding(c);
push( d ); push( d );
break; break;
@ -1852,7 +1852,7 @@ void Parse::do_one_bytecode() {
case Bytecodes::_fadd: case Bytecodes::_fadd:
b = pop(); b = pop();
a = pop(); a = pop();
c = _gvn.transform( new (C) AddFNode(a,b) ); c = _gvn.transform( new AddFNode(a,b) );
d = precision_rounding(c); d = precision_rounding(c);
push( d ); push( d );
break; break;
@ -1860,7 +1860,7 @@ void Parse::do_one_bytecode() {
case Bytecodes::_fmul: case Bytecodes::_fmul:
b = pop(); b = pop();
a = pop(); a = pop();
c = _gvn.transform( new (C) MulFNode(a,b) ); c = _gvn.transform( new MulFNode(a,b) );
d = precision_rounding(c); d = precision_rounding(c);
push( d ); push( d );
break; break;
@ -1868,7 +1868,7 @@ void Parse::do_one_bytecode() {
case Bytecodes::_fdiv: case Bytecodes::_fdiv:
b = pop(); b = pop();
a = pop(); a = pop();
c = _gvn.transform( new (C) DivFNode(0,a,b) ); c = _gvn.transform( new DivFNode(0,a,b) );
d = precision_rounding(c); d = precision_rounding(c);
push( d ); push( d );
break; break;
@ -1878,7 +1878,7 @@ void Parse::do_one_bytecode() {
// Generate a ModF node. // Generate a ModF node.
b = pop(); b = pop();
a = pop(); a = pop();
c = _gvn.transform( new (C) ModFNode(0,a,b) ); c = _gvn.transform( new ModFNode(0,a,b) );
d = precision_rounding(c); d = precision_rounding(c);
push( d ); push( d );
} }
@ -1891,7 +1891,7 @@ void Parse::do_one_bytecode() {
case Bytecodes::_fcmpl: case Bytecodes::_fcmpl:
b = pop(); b = pop();
a = pop(); a = pop();
c = _gvn.transform( new (C) CmpF3Node( a, b)); c = _gvn.transform( new CmpF3Node( a, b));
push(c); push(c);
break; break;
case Bytecodes::_fcmpg: case Bytecodes::_fcmpg:
@ -1903,40 +1903,40 @@ void Parse::do_one_bytecode() {
// as well by using CmpF3 which implements unordered-lesser instead of // as well by using CmpF3 which implements unordered-lesser instead of
// unordered-greater semantics. Finally, commute the result bits. Result // unordered-greater semantics. Finally, commute the result bits. Result
// is same as using a CmpF3Greater except we did it with CmpF3 alone. // is same as using a CmpF3Greater except we did it with CmpF3 alone.
c = _gvn.transform( new (C) CmpF3Node( b, a)); c = _gvn.transform( new CmpF3Node( b, a));
c = _gvn.transform( new (C) SubINode(_gvn.intcon(0),c) ); c = _gvn.transform( new SubINode(_gvn.intcon(0),c) );
push(c); push(c);
break; break;
case Bytecodes::_f2i: case Bytecodes::_f2i:
a = pop(); a = pop();
push(_gvn.transform(new (C) ConvF2INode(a))); push(_gvn.transform(new ConvF2INode(a)));
break; break;
case Bytecodes::_d2i: case Bytecodes::_d2i:
a = pop_pair(); a = pop_pair();
b = _gvn.transform(new (C) ConvD2INode(a)); b = _gvn.transform(new ConvD2INode(a));
push( b ); push( b );
break; break;
case Bytecodes::_f2d: case Bytecodes::_f2d:
a = pop(); a = pop();
b = _gvn.transform( new (C) ConvF2DNode(a)); b = _gvn.transform( new ConvF2DNode(a));
push_pair( b ); push_pair( b );
break; break;
case Bytecodes::_d2f: case Bytecodes::_d2f:
a = pop_pair(); a = pop_pair();
b = _gvn.transform( new (C) ConvD2FNode(a)); b = _gvn.transform( new ConvD2FNode(a));
// This breaks _227_mtrt (speed & correctness) and _222_mpegaudio (speed) // This breaks _227_mtrt (speed & correctness) and _222_mpegaudio (speed)
//b = _gvn.transform(new (C) RoundFloatNode(0, b) ); //b = _gvn.transform(new RoundFloatNode(0, b) );
push( b ); push( b );
break; break;
case Bytecodes::_l2f: case Bytecodes::_l2f:
if (Matcher::convL2FSupported()) { if (Matcher::convL2FSupported()) {
a = pop_pair(); a = pop_pair();
b = _gvn.transform( new (C) ConvL2FNode(a)); b = _gvn.transform( new ConvL2FNode(a));
// For i486.ad, FILD doesn't restrict precision to 24 or 53 bits. // For i486.ad, FILD doesn't restrict precision to 24 or 53 bits.
// Rather than storing the result into an FP register then pushing // Rather than storing the result into an FP register then pushing
// out to memory to round, the machine instruction that implements // out to memory to round, the machine instruction that implements
@ -1951,7 +1951,7 @@ void Parse::do_one_bytecode() {
case Bytecodes::_l2d: case Bytecodes::_l2d:
a = pop_pair(); a = pop_pair();
b = _gvn.transform( new (C) ConvL2DNode(a)); b = _gvn.transform( new ConvL2DNode(a));
// For i486.ad, rounding is always necessary (see _l2f above). // For i486.ad, rounding is always necessary (see _l2f above).
// c = dprecision_rounding(b); // c = dprecision_rounding(b);
c = _gvn.transform(b); c = _gvn.transform(b);
@ -1960,20 +1960,20 @@ void Parse::do_one_bytecode() {
case Bytecodes::_f2l: case Bytecodes::_f2l:
a = pop(); a = pop();
b = _gvn.transform( new (C) ConvF2LNode(a)); b = _gvn.transform( new ConvF2LNode(a));
push_pair(b); push_pair(b);
break; break;
case Bytecodes::_d2l: case Bytecodes::_d2l:
a = pop_pair(); a = pop_pair();
b = _gvn.transform( new (C) ConvD2LNode(a)); b = _gvn.transform( new ConvD2LNode(a));
push_pair(b); push_pair(b);
break; break;
case Bytecodes::_dsub: case Bytecodes::_dsub:
b = pop_pair(); b = pop_pair();
a = pop_pair(); a = pop_pair();
c = _gvn.transform( new (C) SubDNode(a,b) ); c = _gvn.transform( new SubDNode(a,b) );
d = dprecision_rounding(c); d = dprecision_rounding(c);
push_pair( d ); push_pair( d );
break; break;
@ -1981,7 +1981,7 @@ void Parse::do_one_bytecode() {
case Bytecodes::_dadd: case Bytecodes::_dadd:
b = pop_pair(); b = pop_pair();
a = pop_pair(); a = pop_pair();
c = _gvn.transform( new (C) AddDNode(a,b) ); c = _gvn.transform( new AddDNode(a,b) );
d = dprecision_rounding(c); d = dprecision_rounding(c);
push_pair( d ); push_pair( d );
break; break;
@ -1989,7 +1989,7 @@ void Parse::do_one_bytecode() {
case Bytecodes::_dmul: case Bytecodes::_dmul:
b = pop_pair(); b = pop_pair();
a = pop_pair(); a = pop_pair();
c = _gvn.transform( new (C) MulDNode(a,b) ); c = _gvn.transform( new MulDNode(a,b) );
d = dprecision_rounding(c); d = dprecision_rounding(c);
push_pair( d ); push_pair( d );
break; break;
@ -1997,14 +1997,14 @@ void Parse::do_one_bytecode() {
case Bytecodes::_ddiv: case Bytecodes::_ddiv:
b = pop_pair(); b = pop_pair();
a = pop_pair(); a = pop_pair();
c = _gvn.transform( new (C) DivDNode(0,a,b) ); c = _gvn.transform( new DivDNode(0,a,b) );
d = dprecision_rounding(c); d = dprecision_rounding(c);
push_pair( d ); push_pair( d );
break; break;
case Bytecodes::_dneg: case Bytecodes::_dneg:
a = pop_pair(); a = pop_pair();
b = _gvn.transform(new (C) NegDNode (a)); b = _gvn.transform(new NegDNode (a));
push_pair(b); push_pair(b);
break; break;
@ -2015,7 +2015,7 @@ void Parse::do_one_bytecode() {
a = pop_pair(); a = pop_pair();
// a % b // a % b
c = _gvn.transform( new (C) ModDNode(0,a,b) ); c = _gvn.transform( new ModDNode(0,a,b) );
d = dprecision_rounding(c); d = dprecision_rounding(c);
push_pair( d ); push_pair( d );
} }
@ -2028,7 +2028,7 @@ void Parse::do_one_bytecode() {
case Bytecodes::_dcmpl: case Bytecodes::_dcmpl:
b = pop_pair(); b = pop_pair();
a = pop_pair(); a = pop_pair();
c = _gvn.transform( new (C) CmpD3Node( a, b)); c = _gvn.transform( new CmpD3Node( a, b));
push(c); push(c);
break; break;
@ -2041,8 +2041,8 @@ void Parse::do_one_bytecode() {
// unordered-lesser instead of unordered-greater semantics. // unordered-lesser instead of unordered-greater semantics.
// Finally, negate the result bits. Result is same as using a // Finally, negate the result bits. Result is same as using a
// CmpD3Greater except we did it with CmpD3 alone. // CmpD3Greater except we did it with CmpD3 alone.
c = _gvn.transform( new (C) CmpD3Node( b, a)); c = _gvn.transform( new CmpD3Node( b, a));
c = _gvn.transform( new (C) SubINode(_gvn.intcon(0),c) ); c = _gvn.transform( new SubINode(_gvn.intcon(0),c) );
push(c); push(c);
break; break;
@ -2051,44 +2051,44 @@ void Parse::do_one_bytecode() {
case Bytecodes::_land: case Bytecodes::_land:
b = pop_pair(); b = pop_pair();
a = pop_pair(); a = pop_pair();
c = _gvn.transform( new (C) AndLNode(a,b) ); c = _gvn.transform( new AndLNode(a,b) );
push_pair(c); push_pair(c);
break; break;
case Bytecodes::_lor: case Bytecodes::_lor:
b = pop_pair(); b = pop_pair();
a = pop_pair(); a = pop_pair();
c = _gvn.transform( new (C) OrLNode(a,b) ); c = _gvn.transform( new OrLNode(a,b) );
push_pair(c); push_pair(c);
break; break;
case Bytecodes::_lxor: case Bytecodes::_lxor:
b = pop_pair(); b = pop_pair();
a = pop_pair(); a = pop_pair();
c = _gvn.transform( new (C) XorLNode(a,b) ); c = _gvn.transform( new XorLNode(a,b) );
push_pair(c); push_pair(c);
break; break;
case Bytecodes::_lshl: case Bytecodes::_lshl:
b = pop(); // the shift count b = pop(); // the shift count
a = pop_pair(); // value to be shifted a = pop_pair(); // value to be shifted
c = _gvn.transform( new (C) LShiftLNode(a,b) ); c = _gvn.transform( new LShiftLNode(a,b) );
push_pair(c); push_pair(c);
break; break;
case Bytecodes::_lshr: case Bytecodes::_lshr:
b = pop(); // the shift count b = pop(); // the shift count
a = pop_pair(); // value to be shifted a = pop_pair(); // value to be shifted
c = _gvn.transform( new (C) RShiftLNode(a,b) ); c = _gvn.transform( new RShiftLNode(a,b) );
push_pair(c); push_pair(c);
break; break;
case Bytecodes::_lushr: case Bytecodes::_lushr:
b = pop(); // the shift count b = pop(); // the shift count
a = pop_pair(); // value to be shifted a = pop_pair(); // value to be shifted
c = _gvn.transform( new (C) URShiftLNode(a,b) ); c = _gvn.transform( new URShiftLNode(a,b) );
push_pair(c); push_pair(c);
break; break;
case Bytecodes::_lmul: case Bytecodes::_lmul:
b = pop_pair(); b = pop_pair();
a = pop_pair(); a = pop_pair();
c = _gvn.transform( new (C) MulLNode(a,b) ); c = _gvn.transform( new MulLNode(a,b) );
push_pair(c); push_pair(c);
break; break;
@ -2100,7 +2100,7 @@ void Parse::do_one_bytecode() {
if (stopped()) return; if (stopped()) return;
b = pop_pair(); b = pop_pair();
a = pop_pair(); a = pop_pair();
c = _gvn.transform( new (C) ModLNode(control(),a,b) ); c = _gvn.transform( new ModLNode(control(),a,b) );
push_pair(c); push_pair(c);
break; break;
@ -2112,20 +2112,20 @@ void Parse::do_one_bytecode() {
if (stopped()) return; if (stopped()) return;
b = pop_pair(); b = pop_pair();
a = pop_pair(); a = pop_pair();
c = _gvn.transform( new (C) DivLNode(control(),a,b) ); c = _gvn.transform( new DivLNode(control(),a,b) );
push_pair(c); push_pair(c);
break; break;
case Bytecodes::_ladd: case Bytecodes::_ladd:
b = pop_pair(); b = pop_pair();
a = pop_pair(); a = pop_pair();
c = _gvn.transform( new (C) AddLNode(a,b) ); c = _gvn.transform( new AddLNode(a,b) );
push_pair(c); push_pair(c);
break; break;
case Bytecodes::_lsub: case Bytecodes::_lsub:
b = pop_pair(); b = pop_pair();
a = pop_pair(); a = pop_pair();
c = _gvn.transform( new (C) SubLNode(a,b) ); c = _gvn.transform( new SubLNode(a,b) );
push_pair(c); push_pair(c);
break; break;
case Bytecodes::_lcmp: case Bytecodes::_lcmp:
@ -2156,58 +2156,58 @@ void Parse::do_one_bytecode() {
} }
b = pop_pair(); b = pop_pair();
a = pop_pair(); a = pop_pair();
c = _gvn.transform( new (C) CmpL3Node( a, b )); c = _gvn.transform( new CmpL3Node( a, b ));
push(c); push(c);
break; break;
case Bytecodes::_lneg: case Bytecodes::_lneg:
a = pop_pair(); a = pop_pair();
b = _gvn.transform( new (C) SubLNode(longcon(0),a)); b = _gvn.transform( new SubLNode(longcon(0),a));
push_pair(b); push_pair(b);
break; break;
case Bytecodes::_l2i: case Bytecodes::_l2i:
a = pop_pair(); a = pop_pair();
push( _gvn.transform( new (C) ConvL2INode(a))); push( _gvn.transform( new ConvL2INode(a)));
break; break;
case Bytecodes::_i2l: case Bytecodes::_i2l:
a = pop(); a = pop();
b = _gvn.transform( new (C) ConvI2LNode(a)); b = _gvn.transform( new ConvI2LNode(a));
push_pair(b); push_pair(b);
break; break;
case Bytecodes::_i2b: case Bytecodes::_i2b:
// Sign extend // Sign extend
a = pop(); a = pop();
a = _gvn.transform( new (C) LShiftINode(a,_gvn.intcon(24)) ); a = _gvn.transform( new LShiftINode(a,_gvn.intcon(24)) );
a = _gvn.transform( new (C) RShiftINode(a,_gvn.intcon(24)) ); a = _gvn.transform( new RShiftINode(a,_gvn.intcon(24)) );
push( a ); push( a );
break; break;
case Bytecodes::_i2s: case Bytecodes::_i2s:
a = pop(); a = pop();
a = _gvn.transform( new (C) LShiftINode(a,_gvn.intcon(16)) ); a = _gvn.transform( new LShiftINode(a,_gvn.intcon(16)) );
a = _gvn.transform( new (C) RShiftINode(a,_gvn.intcon(16)) ); a = _gvn.transform( new RShiftINode(a,_gvn.intcon(16)) );
push( a ); push( a );
break; break;
case Bytecodes::_i2c: case Bytecodes::_i2c:
a = pop(); a = pop();
push( _gvn.transform( new (C) AndINode(a,_gvn.intcon(0xFFFF)) ) ); push( _gvn.transform( new AndINode(a,_gvn.intcon(0xFFFF)) ) );
break; break;
case Bytecodes::_i2f: case Bytecodes::_i2f:
a = pop(); a = pop();
b = _gvn.transform( new (C) ConvI2FNode(a) ) ; b = _gvn.transform( new ConvI2FNode(a) ) ;
c = precision_rounding(b); c = precision_rounding(b);
push (b); push (b);
break; break;
case Bytecodes::_i2d: case Bytecodes::_i2d:
a = pop(); a = pop();
b = _gvn.transform( new (C) ConvI2DNode(a)); b = _gvn.transform( new ConvI2DNode(a));
push_pair(b); push_pair(b);
break; break;
case Bytecodes::_iinc: // Increment local case Bytecodes::_iinc: // Increment local
i = iter().get_index(); // Get local index i = iter().get_index(); // Get local index
set_local( i, _gvn.transform( new (C) AddINode( _gvn.intcon(iter().get_iinc_con()), local(i) ) ) ); set_local( i, _gvn.transform( new AddINode( _gvn.intcon(iter().get_iinc_con()), local(i) ) ) );
break; break;
// Exit points of synchronized methods must have an unlock node // Exit points of synchronized methods must have an unlock node
@ -2287,7 +2287,7 @@ void Parse::do_one_bytecode() {
assert(null_ctl->is_top(), "no null control here"); assert(null_ctl->is_top(), "no null control here");
dec_sp(1); dec_sp(1);
} }
c = _gvn.transform( new (C) CmpPNode(b, a) ); c = _gvn.transform( new CmpPNode(b, a) );
do_ifnull(btest, c); do_ifnull(btest, c);
break; break;
@ -2298,7 +2298,7 @@ void Parse::do_one_bytecode() {
maybe_add_safepoint(iter().get_dest()); maybe_add_safepoint(iter().get_dest());
a = pop(); a = pop();
b = pop(); b = pop();
c = _gvn.transform( new (C) CmpPNode(b, a) ); c = _gvn.transform( new CmpPNode(b, a) );
c = optimize_cmp_with_klass(c); c = optimize_cmp_with_klass(c);
do_if(btest, c); do_if(btest, c);
break; break;
@ -2314,7 +2314,7 @@ void Parse::do_one_bytecode() {
maybe_add_safepoint(iter().get_dest()); maybe_add_safepoint(iter().get_dest());
a = _gvn.intcon(0); a = _gvn.intcon(0);
b = pop(); b = pop();
c = _gvn.transform( new (C) CmpINode(b, a) ); c = _gvn.transform( new CmpINode(b, a) );
do_if(btest, c); do_if(btest, c);
break; break;
@ -2329,7 +2329,7 @@ void Parse::do_one_bytecode() {
maybe_add_safepoint(iter().get_dest()); maybe_add_safepoint(iter().get_dest());
a = pop(); a = pop();
b = pop(); b = pop();
c = _gvn.transform( new (C) CmpINode( b, a ) ); c = _gvn.transform( new CmpINode( b, a ) );
do_if(btest, c); do_if(btest, c);
break; break;

4
hotspot/src/share/vm/opto/parse3.cpp
View file

@ -552,7 +552,7 @@ void Parse::do_multianewarray() {
} }
make_slow_call_ex(c, env()->Throwable_klass(), false); make_slow_call_ex(c, env()->Throwable_klass(), false);
Node* res = _gvn.transform(new (C) ProjNode(c, TypeFunc::Parms)); Node* res = _gvn.transform(new ProjNode(c, TypeFunc::Parms));
const Type* type = TypeOopPtr::make_from_klass_raw(array_klass); const Type* type = TypeOopPtr::make_from_klass_raw(array_klass);
@ -566,7 +566,7 @@ void Parse::do_multianewarray() {
// We cannot sharpen the nested sub-arrays, since the top level is mutable. // We cannot sharpen the nested sub-arrays, since the top level is mutable.
Node* cast = _gvn.transform( new (C) CheckCastPPNode(control(), res, type) ); Node* cast = _gvn.transform( new CheckCastPPNode(control(), res, type) );
push(cast); push(cast);
// Possible improvements: // Possible improvements:

24
hotspot/src/share/vm/opto/parseHelper.cpp
View file

@ -43,7 +43,7 @@ void GraphKit::make_dtrace_method_entry_exit(ciMethod* method, bool is_entry) {
const char *call_name = is_entry ? "dtrace_method_entry" : "dtrace_method_exit"; const char *call_name = is_entry ? "dtrace_method_entry" : "dtrace_method_exit";
// Get base of thread-local storage area // Get base of thread-local storage area
Node* thread = _gvn.transform( new (C) ThreadLocalNode() ); Node* thread = _gvn.transform( new ThreadLocalNode() );
// Get method // Get method
const TypePtr* method_type = TypeMetadataPtr::make(method); const TypePtr* method_type = TypeMetadataPtr::make(method);
@ -175,8 +175,8 @@ void Parse::array_store_check() {
// Make a constant out of the inexact array klass // Make a constant out of the inexact array klass
const TypeKlassPtr *extak = tak->cast_to_exactness(true)->is_klassptr(); const TypeKlassPtr *extak = tak->cast_to_exactness(true)->is_klassptr();
Node* con = makecon(extak); Node* con = makecon(extak);
Node* cmp = _gvn.transform(new (C) CmpPNode( array_klass, con )); Node* cmp = _gvn.transform(new CmpPNode( array_klass, con ));
Node* bol = _gvn.transform(new (C) BoolNode( cmp, BoolTest::eq )); Node* bol = _gvn.transform(new BoolNode( cmp, BoolTest::eq ));
Node* ctrl= control(); Node* ctrl= control();
{ BuildCutout unless(this, bol, PROB_MAX); { BuildCutout unless(this, bol, PROB_MAX);
uncommon_trap(Deoptimization::Reason_array_check, uncommon_trap(Deoptimization::Reason_array_check,
@ -215,8 +215,8 @@ void Parse::emit_guard_for_new(ciInstanceKlass* klass) {
// if (klass->_init_thread != current_thread || // if (klass->_init_thread != current_thread ||
// klass->_init_state != being_initialized) // klass->_init_state != being_initialized)
// uncommon_trap // uncommon_trap
Node* cur_thread = _gvn.transform( new (C) ThreadLocalNode() ); Node* cur_thread = _gvn.transform( new ThreadLocalNode() );
Node* merge = new (C) RegionNode(3); Node* merge = new RegionNode(3);
_gvn.set_type(merge, Type::CONTROL); _gvn.set_type(merge, Type::CONTROL);
Node* kls = makecon(TypeKlassPtr::make(klass)); Node* kls = makecon(TypeKlassPtr::make(klass));
@ -327,9 +327,9 @@ void Parse::test_counter_against_threshold(Node* cnt, int limit) {
// Test invocation count vs threshold // Test invocation count vs threshold
Node *threshold = makecon(TypeInt::make(limit)); Node *threshold = makecon(TypeInt::make(limit));
Node *chk = _gvn.transform( new (C) CmpUNode( cnt, threshold) ); Node *chk = _gvn.transform( new CmpUNode( cnt, threshold) );
BoolTest::mask btest = BoolTest::lt; BoolTest::mask btest = BoolTest::lt;
Node *tst = _gvn.transform( new (C) BoolNode( chk, btest) ); Node *tst = _gvn.transform( new BoolNode( chk, btest) );
// Branch to failure if threshold exceeded // Branch to failure if threshold exceeded
{ BuildCutout unless(this, tst, PROB_ALWAYS); { BuildCutout unless(this, tst, PROB_ALWAYS);
uncommon_trap(Deoptimization::Reason_age, uncommon_trap(Deoptimization::Reason_age,
@ -359,7 +359,7 @@ void Parse::increment_and_test_invocation_counter(int limit) {
test_counter_against_threshold(cnt, limit); test_counter_against_threshold(cnt, limit);
// Add one to the counter and store // Add one to the counter and store
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, adr_iic_node, incr, T_INT, adr_type, MemNode::unordered); store_to_memory(ctrl, adr_iic_node, incr, T_INT, adr_type, MemNode::unordered);
} }
@ -380,8 +380,8 @@ Node* Parse::method_data_addressing(ciMethodData* md, ciProfileData* data, ByteS
if (stride != 0) { if (stride != 0) {
Node* str = _gvn.MakeConX(stride); Node* str = _gvn.MakeConX(stride);
Node* scale = _gvn.transform( new (C) MulXNode( idx, str ) ); Node* scale = _gvn.transform( new MulXNode( idx, str ) );
ptr = _gvn.transform( new (C) AddPNode( mdo, ptr, scale ) ); ptr = _gvn.transform( new AddPNode( mdo, ptr, scale ) );
} }
return ptr; return ptr;
@ -393,7 +393,7 @@ void Parse::increment_md_counter_at(ciMethodData* md, ciProfileData* data, ByteS
const TypePtr* adr_type = _gvn.type(adr_node)->is_ptr(); const TypePtr* adr_type = _gvn.type(adr_node)->is_ptr();
Node* cnt = make_load(NULL, adr_node, TypeInt::INT, T_INT, adr_type, MemNode::unordered); Node* cnt = make_load(NULL, adr_node, TypeInt::INT, T_INT, adr_type, MemNode::unordered);
Node* incr = _gvn.transform(new (C) AddINode(cnt, _gvn.intcon(DataLayout::counter_increment))); Node* incr = _gvn.transform(new AddINode(cnt, _gvn.intcon(DataLayout::counter_increment)));
store_to_memory(NULL, adr_node, incr, T_INT, adr_type, MemNode::unordered); store_to_memory(NULL, adr_node, incr, T_INT, adr_type, MemNode::unordered);
} }
@ -413,7 +413,7 @@ void Parse::set_md_flag_at(ciMethodData* md, ciProfileData* data, int flag_const
const TypePtr* adr_type = _gvn.type(adr_node)->is_ptr(); const TypePtr* adr_type = _gvn.type(adr_node)->is_ptr();
Node* flags = make_load(NULL, adr_node, TypeInt::BYTE, T_BYTE, adr_type, MemNode::unordered); Node* flags = make_load(NULL, adr_node, TypeInt::BYTE, T_BYTE, adr_type, MemNode::unordered);
Node* incr = _gvn.transform(new (C) OrINode(flags, _gvn.intcon(flag_constant))); Node* incr = _gvn.transform(new OrINode(flags, _gvn.intcon(flag_constant)));
store_to_memory(NULL, adr_node, incr, T_BYTE, adr_type, MemNode::unordered); store_to_memory(NULL, adr_node, incr, T_BYTE, adr_type, MemNode::unordered);
} }

6
hotspot/src/share/vm/opto/phaseX.cpp
View file

@ -47,7 +47,7 @@ NodeHash::NodeHash(uint est_max_size) :
_total_insert_probes(0), _total_inserts(0), _total_insert_probes(0), _total_inserts(0),
_insert_probes(0), _grows(0) { _insert_probes(0), _grows(0) {
// _sentinel must be in the current node space // _sentinel must be in the current node space
_sentinel = new (Compile::current()) ProjNode(NULL, TypeFunc::Control); _sentinel = new ProjNode(NULL, TypeFunc::Control);
memset(_table,0,sizeof(Node*)*_max); memset(_table,0,sizeof(Node*)*_max);
} }
@ -62,7 +62,7 @@ NodeHash::NodeHash(Arena *arena, uint est_max_size) :
_total_insert_probes(0), _total_inserts(0), _total_insert_probes(0), _total_inserts(0),
_insert_probes(0), _grows(0) { _insert_probes(0), _grows(0) {
// _sentinel must be in the current node space // _sentinel must be in the current node space
_sentinel = new (Compile::current()) ProjNode(NULL, TypeFunc::Control); _sentinel = new ProjNode(NULL, TypeFunc::Control);
memset(_table,0,sizeof(Node*)*_max); memset(_table,0,sizeof(Node*)*_max);
} }
@ -1309,7 +1309,7 @@ void PhaseIterGVN::subsume_node( Node *old, Node *nn ) {
} }
// Smash all inputs to 'old', isolating him completely // Smash all inputs to 'old', isolating him completely
Node *temp = new (C) Node(1); Node *temp = new Node(1);
temp->init_req(0,nn); // Add a use to nn to prevent him from dying temp->init_req(0,nn); // Add a use to nn to prevent him from dying
remove_dead_node( old ); remove_dead_node( old );
temp->del_req(0); // Yank bogus edge temp->del_req(0); // Yank bogus edge

8
hotspot/src/share/vm/opto/reg_split.cpp
View file

@ -93,7 +93,7 @@ Node *PhaseChaitin::get_spillcopy_wide(MachSpillCopyNode::SpillType spill_type,
// Here we assume a trip through memory is required. // Here we assume a trip through memory is required.
w_i_mask = &C->FIRST_STACK_mask(); w_i_mask = &C->FIRST_STACK_mask();
} }
return new (C) MachSpillCopyNode(spill_type, def, *w_i_mask, *w_o_mask ); return new MachSpillCopyNode(spill_type, def, *w_i_mask, *w_o_mask );
} }
//------------------------------insert_proj------------------------------------ //------------------------------insert_proj------------------------------------
@ -663,7 +663,7 @@ uint PhaseChaitin::Split(uint maxlrg, ResourceArea* split_arena) {
// create a new phi node and insert it into the block // create a new phi node and insert it into the block
// type is taken from left over pointer to a predecessor // type is taken from left over pointer to a predecessor
assert(n3,"No non-NULL reaching DEF for a Phi"); assert(n3,"No non-NULL reaching DEF for a Phi");
phi = new (C) PhiNode(b->head(), n3->bottom_type()); phi = new PhiNode(b->head(), n3->bottom_type());
// initialize the Reaches entry for this LRG // initialize the Reaches entry for this LRG
Reachblock[slidx] = phi; Reachblock[slidx] = phi;
@ -1075,7 +1075,7 @@ uint PhaseChaitin::Split(uint maxlrg, ResourceArea* split_arena) {
// First Split-UP to move value into Register // First Split-UP to move value into Register
uint def_ideal = def->ideal_reg(); uint def_ideal = def->ideal_reg();
const RegMask* tmp_rm = Matcher::idealreg2regmask[def_ideal]; const RegMask* tmp_rm = Matcher::idealreg2regmask[def_ideal];
Node *spill = new (C) MachSpillCopyNode(MachSpillCopyNode::MemToReg, def, dmask, *tmp_rm); Node *spill = new MachSpillCopyNode(MachSpillCopyNode::MemToReg, def, dmask, *tmp_rm);
insert_proj( b, insidx, spill, maxlrg ); insert_proj( b, insidx, spill, maxlrg );
// Then Split-DOWN as if previous Split was DEF // Then Split-DOWN as if previous Split was DEF
maxlrg = split_USE(MachSpillCopyNode::RegToMem, spill,b,n,inpidx,maxlrg,false,false, splits,slidx); maxlrg = split_USE(MachSpillCopyNode::RegToMem, spill,b,n,inpidx,maxlrg,false,false, splits,slidx);
@ -1229,7 +1229,7 @@ uint PhaseChaitin::Split(uint maxlrg, ResourceArea* split_arena) {
if (C->check_node_count(NodeLimitFudgeFactor, out_of_nodes)) { // Check when generating nodes if (C->check_node_count(NodeLimitFudgeFactor, out_of_nodes)) { // Check when generating nodes
return 0; return 0;
} }
Node *spill = new (C) MachSpillCopyNode(MachSpillCopyNode::MemToReg, use,use_rm,def_rm); Node *spill = new MachSpillCopyNode(MachSpillCopyNode::MemToReg, use,use_rm,def_rm);
n->set_req(copyidx,spill); n->set_req(copyidx,spill);
n->as_MachSpillCopy()->set_in_RegMask(def_rm); n->as_MachSpillCopy()->set_in_RegMask(def_rm);
// Put the spill just before the copy // Put the spill just before the copy

2
hotspot/src/share/vm/opto/split_if.cpp
View file

@ -35,7 +35,7 @@ Node *PhaseIdealLoop::split_thru_region( Node *n, Node *region ) {
uint wins = 0; uint wins = 0;
assert( n->is_CFG(), "" ); assert( n->is_CFG(), "" );
assert( region->is_Region(), "" ); assert( region->is_Region(), "" );
Node *r = new (C) RegionNode( region->req() ); Node *r = new RegionNode( region->req() );
IdealLoopTree *loop = get_loop( n ); IdealLoopTree *loop = get_loop( n );
for( uint i = 1; i < region->req(); i++ ) { for( uint i = 1; i < region->req(); i++ ) {
Node *x = n->clone(); Node *x = n->clone();

42
hotspot/src/share/vm/opto/stringopts.cpp
View file

@ -70,7 +70,7 @@ class StringConcat : public ResourceObj {
_multiple(false), _multiple(false),
_string_alloc(NULL), _string_alloc(NULL),
_stringopts(stringopts) { _stringopts(stringopts) {
_arguments = new (_stringopts->C) Node(1); _arguments = new Node(1);
_arguments->del_req(0); _arguments->del_req(0);
} }
@ -228,8 +228,8 @@ class StringConcat : public ResourceObj {
const TypeFunc* call_type = OptoRuntime::uncommon_trap_Type(); const TypeFunc* call_type = OptoRuntime::uncommon_trap_Type();
const TypePtr* no_memory_effects = NULL; const TypePtr* no_memory_effects = NULL;
Compile* C = _stringopts->C; Compile* C = _stringopts->C;
CallStaticJavaNode* call = new (C) CallStaticJavaNode(call_type, call_addr, "uncommon_trap", CallStaticJavaNode* call = new CallStaticJavaNode(call_type, call_addr, "uncommon_trap",
jvms->bci(), no_memory_effects); jvms->bci(), no_memory_effects);
for (int e = 0; e < TypeFunc::Parms; e++) { for (int e = 0; e < TypeFunc::Parms; e++) {
call->init_req(e, uct->in(e)); call->init_req(e, uct->in(e));
} }
@ -1127,9 +1127,9 @@ Node* PhaseStringOpts::fetch_static_field(GraphKit& kit, ciField* field) {
} }
Node* PhaseStringOpts::int_stringSize(GraphKit& kit, Node* arg) { Node* PhaseStringOpts::int_stringSize(GraphKit& kit, Node* arg) {
RegionNode *final_merge = new (C) RegionNode(3); RegionNode *final_merge = new RegionNode(3);
kit.gvn().set_type(final_merge, Type::CONTROL); kit.gvn().set_type(final_merge, Type::CONTROL);
Node* final_size = new (C) PhiNode(final_merge, TypeInt::INT); Node* final_size = new PhiNode(final_merge, TypeInt::INT);
kit.gvn().set_type(final_size, TypeInt::INT); kit.gvn().set_type(final_size, TypeInt::INT);
IfNode* iff = kit.create_and_map_if(kit.control(), IfNode* iff = kit.create_and_map_if(kit.control(),
@ -1146,11 +1146,11 @@ Node* PhaseStringOpts::int_stringSize(GraphKit& kit, Node* arg) {
} else { } else {
// int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i); // int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
RegionNode *r = new (C) RegionNode(3); RegionNode *r = new RegionNode(3);
kit.gvn().set_type(r, Type::CONTROL); kit.gvn().set_type(r, Type::CONTROL);
Node *phi = new (C) PhiNode(r, TypeInt::INT); Node *phi = new PhiNode(r, TypeInt::INT);
kit.gvn().set_type(phi, TypeInt::INT); kit.gvn().set_type(phi, TypeInt::INT);
Node *size = new (C) PhiNode(r, TypeInt::INT); Node *size = new PhiNode(r, TypeInt::INT);
kit.gvn().set_type(size, TypeInt::INT); kit.gvn().set_type(size, TypeInt::INT);
Node* chk = __ CmpI(arg, __ intcon(0)); Node* chk = __ CmpI(arg, __ intcon(0));
Node* p = __ Bool(chk, BoolTest::lt); Node* p = __ Bool(chk, BoolTest::lt);
@ -1175,11 +1175,11 @@ Node* PhaseStringOpts::int_stringSize(GraphKit& kit, Node* arg) {
// Add loop predicate first. // Add loop predicate first.
kit.add_predicate(); kit.add_predicate();
RegionNode *loop = new (C) RegionNode(3); RegionNode *loop = new RegionNode(3);
loop->init_req(1, kit.control()); loop->init_req(1, kit.control());
kit.gvn().set_type(loop, Type::CONTROL); kit.gvn().set_type(loop, Type::CONTROL);
Node *index = new (C) PhiNode(loop, TypeInt::INT); Node *index = new PhiNode(loop, TypeInt::INT);
index->init_req(1, __ intcon(0)); index->init_req(1, __ intcon(0));
kit.gvn().set_type(index, TypeInt::INT); kit.gvn().set_type(index, TypeInt::INT);
kit.set_control(loop); kit.set_control(loop);
@ -1212,7 +1212,7 @@ Node* PhaseStringOpts::int_stringSize(GraphKit& kit, Node* arg) {
} }
void PhaseStringOpts::int_getChars(GraphKit& kit, Node* arg, Node* char_array, Node* start, Node* end) { void PhaseStringOpts::int_getChars(GraphKit& kit, Node* arg, Node* char_array, Node* start, Node* end) {
RegionNode *final_merge = new (C) RegionNode(4); RegionNode *final_merge = new RegionNode(4);
kit.gvn().set_type(final_merge, Type::CONTROL); kit.gvn().set_type(final_merge, Type::CONTROL);
Node *final_mem = PhiNode::make(final_merge, kit.memory(char_adr_idx), Type::MEMORY, TypeAryPtr::CHARS); Node *final_mem = PhiNode::make(final_merge, kit.memory(char_adr_idx), Type::MEMORY, TypeAryPtr::CHARS);
kit.gvn().set_type(final_mem, Type::MEMORY); kit.gvn().set_type(final_mem, Type::MEMORY);
@ -1262,11 +1262,11 @@ void PhaseStringOpts::int_getChars(GraphKit& kit, Node* arg, Node* char_array, N
__ Bool(__ CmpI(arg, __ intcon(0)), BoolTest::lt), __ Bool(__ CmpI(arg, __ intcon(0)), BoolTest::lt),
PROB_FAIR, COUNT_UNKNOWN); PROB_FAIR, COUNT_UNKNOWN);
RegionNode *merge = new (C) RegionNode(3); RegionNode *merge = new RegionNode(3);
kit.gvn().set_type(merge, Type::CONTROL); kit.gvn().set_type(merge, Type::CONTROL);
i = new (C) PhiNode(merge, TypeInt::INT); i = new PhiNode(merge, TypeInt::INT);
kit.gvn().set_type(i, TypeInt::INT); kit.gvn().set_type(i, TypeInt::INT);
sign = new (C) PhiNode(merge, TypeInt::INT); sign = new PhiNode(merge, TypeInt::INT);
kit.gvn().set_type(sign, TypeInt::INT); kit.gvn().set_type(sign, TypeInt::INT);
merge->init_req(1, __ IfTrue(iff)); merge->init_req(1, __ IfTrue(iff));
@ -1295,10 +1295,10 @@ void PhaseStringOpts::int_getChars(GraphKit& kit, Node* arg, Node* char_array, N
// Add loop predicate first. // Add loop predicate first.
kit.add_predicate(); kit.add_predicate();
RegionNode *head = new (C) RegionNode(3); RegionNode *head = new RegionNode(3);
head->init_req(1, kit.control()); head->init_req(1, kit.control());
kit.gvn().set_type(head, Type::CONTROL); kit.gvn().set_type(head, Type::CONTROL);
Node *i_phi = new (C) PhiNode(head, TypeInt::INT); Node *i_phi = new PhiNode(head, TypeInt::INT);
i_phi->init_req(1, i); i_phi->init_req(1, i);
kit.gvn().set_type(i_phi, TypeInt::INT); kit.gvn().set_type(i_phi, TypeInt::INT);
charPos = PhiNode::make(head, charPos); charPos = PhiNode::make(head, charPos);
@ -1420,7 +1420,7 @@ void PhaseStringOpts::replace_string_concat(StringConcat* sc) {
// as a shim for the insertion of the new code. // as a shim for the insertion of the new code.
JVMState* jvms = sc->begin()->jvms()->clone_shallow(C); JVMState* jvms = sc->begin()->jvms()->clone_shallow(C);
uint size = sc->begin()->req(); uint size = sc->begin()->req();
SafePointNode* map = new (C) SafePointNode(size, jvms); SafePointNode* map = new SafePointNode(size, jvms);
// copy the control and memory state from the final call into our // copy the control and memory state from the final call into our
// new starting state. This allows any preceeding tests to feed // new starting state. This allows any preceeding tests to feed
@ -1465,12 +1465,12 @@ void PhaseStringOpts::replace_string_concat(StringConcat* sc) {
// Create a region for the overflow checks to merge into. // Create a region for the overflow checks to merge into.
int args = MAX2(sc->num_arguments(), 1); int args = MAX2(sc->num_arguments(), 1);
RegionNode* overflow = new (C) RegionNode(args); RegionNode* overflow = new RegionNode(args);
kit.gvn().set_type(overflow, Type::CONTROL); kit.gvn().set_type(overflow, Type::CONTROL);
// Create a hook node to hold onto the individual sizes since they // Create a hook node to hold onto the individual sizes since they
// are need for the copying phase. // are need for the copying phase.
Node* string_sizes = new (C) Node(args); Node* string_sizes = new Node(args);
Node* length = __ intcon(0); Node* length = __ intcon(0);
for (int argi = 0; argi < sc->num_arguments(); argi++) { for (int argi = 0; argi < sc->num_arguments(); argi++) {
@ -1514,9 +1514,9 @@ void PhaseStringOpts::replace_string_concat(StringConcat* sc) {
} else if (!type->higher_equal(TypeInstPtr::NOTNULL)) { } else if (!type->higher_equal(TypeInstPtr::NOTNULL)) {
// s = s != null ? s : "null"; // s = s != null ? s : "null";
// length = length + (s.count - s.offset); // length = length + (s.count - s.offset);
RegionNode *r = new (C) RegionNode(3); RegionNode *r = new RegionNode(3);
kit.gvn().set_type(r, Type::CONTROL); kit.gvn().set_type(r, Type::CONTROL);
Node *phi = new (C) PhiNode(r, type); Node *phi = new PhiNode(r, type);
kit.gvn().set_type(phi, phi->bottom_type()); kit.gvn().set_type(phi, phi->bottom_type());
Node* p = __ Bool(__ CmpP(arg, kit.null()), BoolTest::ne); Node* p = __ Bool(__ CmpP(arg, kit.null()), BoolTest::ne);
IfNode* iff = kit.create_and_map_if(kit.control(), p, PROB_MIN, COUNT_UNKNOWN); IfNode* iff = kit.create_and_map_if(kit.control(), p, PROB_MIN, COUNT_UNKNOWN);

96
hotspot/src/share/vm/opto/subnode.cpp
View file

@ -159,7 +159,7 @@ Node *SubINode::Ideal(PhaseGVN *phase, bool can_reshape){
if( t2->base() == Type::Int ){ // Might be bottom or top... if( t2->base() == Type::Int ){ // Might be bottom or top...
const TypeInt *i = t2->is_int(); const TypeInt *i = t2->is_int();
if( i->is_con() ) if( i->is_con() )
return new (phase->C) AddINode(in1, phase->intcon(-i->get_con())); return new AddINode(in1, phase->intcon(-i->get_con()));
} }
// Convert "(x+c0) - y" into (x-y) + c0" // Convert "(x+c0) - y" into (x-y) + c0"
@ -168,8 +168,8 @@ Node *SubINode::Ideal(PhaseGVN *phase, bool can_reshape){
if( op1 == Op_AddI && ok_to_convert(in1, in2) ) { if( op1 == Op_AddI && ok_to_convert(in1, in2) ) {
const Type *tadd = phase->type( in1->in(2) ); const Type *tadd = phase->type( in1->in(2) );
if( tadd->singleton() && tadd != Type::TOP ) { if( tadd->singleton() && tadd != Type::TOP ) {
Node *sub2 = phase->transform( new (phase->C) SubINode( in1->in(1), in2 )); Node *sub2 = phase->transform( new SubINode( in1->in(1), in2 ));
return new (phase->C) AddINode( sub2, in1->in(2) ); return new AddINode( sub2, in1->in(2) );
} }
} }
@ -181,9 +181,9 @@ Node *SubINode::Ideal(PhaseGVN *phase, bool can_reshape){
Node* in22 = in2->in(2); Node* in22 = in2->in(2);
const TypeInt* tcon = phase->type(in22)->isa_int(); const TypeInt* tcon = phase->type(in22)->isa_int();
if (tcon != NULL && tcon->is_con()) { if (tcon != NULL && tcon->is_con()) {
Node* sub2 = phase->transform( new (phase->C) SubINode(in1, in21) ); Node* sub2 = phase->transform( new SubINode(in1, in21) );
Node* neg_c0 = phase->intcon(- tcon->get_con()); Node* neg_c0 = phase->intcon(- tcon->get_con());
return new (phase->C) AddINode(sub2, neg_c0); return new AddINode(sub2, neg_c0);
} }
} }
@ -201,47 +201,47 @@ Node *SubINode::Ideal(PhaseGVN *phase, bool can_reshape){
// Convert "x - (x+y)" into "-y" // Convert "x - (x+y)" into "-y"
if( op2 == Op_AddI && if( op2 == Op_AddI &&
phase->eqv( in1, in2->in(1) ) ) phase->eqv( in1, in2->in(1) ) )
return new (phase->C) SubINode( phase->intcon(0),in2->in(2)); return new SubINode( phase->intcon(0),in2->in(2));
// Convert "(x-y) - x" into "-y" // Convert "(x-y) - x" into "-y"
if( op1 == Op_SubI && if( op1 == Op_SubI &&
phase->eqv( in1->in(1), in2 ) ) phase->eqv( in1->in(1), in2 ) )
return new (phase->C) SubINode( phase->intcon(0),in1->in(2)); return new SubINode( phase->intcon(0),in1->in(2));
// Convert "x - (y+x)" into "-y" // Convert "x - (y+x)" into "-y"
if( op2 == Op_AddI && if( op2 == Op_AddI &&
phase->eqv( in1, in2->in(2) ) ) phase->eqv( in1, in2->in(2) ) )
return new (phase->C) SubINode( phase->intcon(0),in2->in(1)); return new SubINode( phase->intcon(0),in2->in(1));
// Convert "0 - (x-y)" into "y-x" // Convert "0 - (x-y)" into "y-x"
if( t1 == TypeInt::ZERO && op2 == Op_SubI ) if( t1 == TypeInt::ZERO && op2 == Op_SubI )
return new (phase->C) SubINode( in2->in(2), in2->in(1) ); return new SubINode( in2->in(2), in2->in(1) );
// Convert "0 - (x+con)" into "-con-x" // Convert "0 - (x+con)" into "-con-x"
jint con; jint con;
if( t1 == TypeInt::ZERO && op2 == Op_AddI && if( t1 == TypeInt::ZERO && op2 == Op_AddI &&
(con = in2->in(2)->find_int_con(0)) != 0 ) (con = in2->in(2)->find_int_con(0)) != 0 )
return new (phase->C) SubINode( phase->intcon(-con), in2->in(1) ); return new SubINode( phase->intcon(-con), in2->in(1) );
// Convert "(X+A) - (X+B)" into "A - B" // Convert "(X+A) - (X+B)" into "A - B"
if( op1 == Op_AddI && op2 == Op_AddI && in1->in(1) == in2->in(1) ) if( op1 == Op_AddI && op2 == Op_AddI && in1->in(1) == in2->in(1) )
return new (phase->C) SubINode( in1->in(2), in2->in(2) ); return new SubINode( in1->in(2), in2->in(2) );
// Convert "(A+X) - (B+X)" into "A - B" // Convert "(A+X) - (B+X)" into "A - B"
if( op1 == Op_AddI && op2 == Op_AddI && in1->in(2) == in2->in(2) ) if( op1 == Op_AddI && op2 == Op_AddI && in1->in(2) == in2->in(2) )
return new (phase->C) SubINode( in1->in(1), in2->in(1) ); return new SubINode( in1->in(1), in2->in(1) );
// Convert "(A+X) - (X+B)" into "A - B" // Convert "(A+X) - (X+B)" into "A - B"
if( op1 == Op_AddI && op2 == Op_AddI && in1->in(2) == in2->in(1) ) if( op1 == Op_AddI && op2 == Op_AddI && in1->in(2) == in2->in(1) )
return new (phase->C) SubINode( in1->in(1), in2->in(2) ); return new SubINode( in1->in(1), in2->in(2) );
// Convert "(X+A) - (B+X)" into "A - B" // Convert "(X+A) - (B+X)" into "A - B"
if( op1 == Op_AddI && op2 == Op_AddI && in1->in(1) == in2->in(2) ) if( op1 == Op_AddI && op2 == Op_AddI && in1->in(1) == in2->in(2) )
return new (phase->C) SubINode( in1->in(2), in2->in(1) ); return new SubINode( in1->in(2), in2->in(1) );
// Convert "A-(B-C)" into (A+C)-B", since add is commutative and generally // Convert "A-(B-C)" into (A+C)-B", since add is commutative and generally
// nicer to optimize than subtract. // nicer to optimize than subtract.
if( op2 == Op_SubI && in2->outcnt() == 1) { if( op2 == Op_SubI && in2->outcnt() == 1) {
Node *add1 = phase->transform( new (phase->C) AddINode( in1, in2->in(2) ) ); Node *add1 = phase->transform( new AddINode( in1, in2->in(2) ) );
return new (phase->C) SubINode( add1, in2->in(1) ); return new SubINode( add1, in2->in(1) );
} }
return NULL; return NULL;
@ -288,7 +288,7 @@ Node *SubLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// Convert "x-c0" into "x+ -c0". // Convert "x-c0" into "x+ -c0".
if( i && // Might be bottom or top... if( i && // Might be bottom or top...
i->is_con() ) i->is_con() )
return new (phase->C) AddLNode(in1, phase->longcon(-i->get_con())); return new AddLNode(in1, phase->longcon(-i->get_con()));
// Convert "(x+c0) - y" into (x-y) + c0" // Convert "(x+c0) - y" into (x-y) + c0"
// Do not collapse (x+c0)-y if "+" is a loop increment or // Do not collapse (x+c0)-y if "+" is a loop increment or
@ -297,8 +297,8 @@ Node *SubLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node *in11 = in1->in(1); Node *in11 = in1->in(1);
const Type *tadd = phase->type( in1->in(2) ); const Type *tadd = phase->type( in1->in(2) );
if( tadd->singleton() && tadd != Type::TOP ) { if( tadd->singleton() && tadd != Type::TOP ) {
Node *sub2 = phase->transform( new (phase->C) SubLNode( in11, in2 )); Node *sub2 = phase->transform( new SubLNode( in11, in2 ));
return new (phase->C) AddLNode( sub2, in1->in(2) ); return new AddLNode( sub2, in1->in(2) );
} }
} }
@ -309,9 +309,9 @@ Node *SubLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node* in22 = in2->in(2); Node* in22 = in2->in(2);
const TypeLong* tcon = phase->type(in22)->isa_long(); const TypeLong* tcon = phase->type(in22)->isa_long();
if (tcon != NULL && tcon->is_con()) { if (tcon != NULL && tcon->is_con()) {
Node* sub2 = phase->transform( new (phase->C) SubLNode(in1, in21) ); Node* sub2 = phase->transform( new SubLNode(in1, in21) );
Node* neg_c0 = phase->longcon(- tcon->get_con()); Node* neg_c0 = phase->longcon(- tcon->get_con());
return new (phase->C) AddLNode(sub2, neg_c0); return new AddLNode(sub2, neg_c0);
} }
} }
@ -329,28 +329,28 @@ Node *SubLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// Convert "x - (x+y)" into "-y" // Convert "x - (x+y)" into "-y"
if( op2 == Op_AddL && if( op2 == Op_AddL &&
phase->eqv( in1, in2->in(1) ) ) phase->eqv( in1, in2->in(1) ) )
return new (phase->C) SubLNode( phase->makecon(TypeLong::ZERO), in2->in(2)); return new SubLNode( phase->makecon(TypeLong::ZERO), in2->in(2));
// Convert "x - (y+x)" into "-y" // Convert "x - (y+x)" into "-y"
if( op2 == Op_AddL && if( op2 == Op_AddL &&
phase->eqv( in1, in2->in(2) ) ) phase->eqv( in1, in2->in(2) ) )
return new (phase->C) SubLNode( phase->makecon(TypeLong::ZERO),in2->in(1)); return new SubLNode( phase->makecon(TypeLong::ZERO),in2->in(1));
// Convert "0 - (x-y)" into "y-x" // Convert "0 - (x-y)" into "y-x"
if( phase->type( in1 ) == TypeLong::ZERO && op2 == Op_SubL ) if( phase->type( in1 ) == TypeLong::ZERO && op2 == Op_SubL )
return new (phase->C) SubLNode( in2->in(2), in2->in(1) ); return new SubLNode( in2->in(2), in2->in(1) );
// Convert "(X+A) - (X+B)" into "A - B" // Convert "(X+A) - (X+B)" into "A - B"
if( op1 == Op_AddL && op2 == Op_AddL && in1->in(1) == in2->in(1) ) if( op1 == Op_AddL && op2 == Op_AddL && in1->in(1) == in2->in(1) )
return new (phase->C) SubLNode( in1->in(2), in2->in(2) ); return new SubLNode( in1->in(2), in2->in(2) );
// Convert "(A+X) - (B+X)" into "A - B" // Convert "(A+X) - (B+X)" into "A - B"
if( op1 == Op_AddL && op2 == Op_AddL && in1->in(2) == in2->in(2) ) if( op1 == Op_AddL && op2 == Op_AddL && in1->in(2) == in2->in(2) )
return new (phase->C) SubLNode( in1->in(1), in2->in(1) ); return new SubLNode( in1->in(1), in2->in(1) );
// Convert "A-(B-C)" into (A+C)-B" // Convert "A-(B-C)" into (A+C)-B"
if( op2 == Op_SubL && in2->outcnt() == 1) { if( op2 == Op_SubL && in2->outcnt() == 1) {
Node *add1 = phase->transform( new (phase->C) AddLNode( in1, in2->in(2) ) ); Node *add1 = phase->transform( new AddLNode( in1, in2->in(2) ) );
return new (phase->C) SubLNode( add1, in2->in(1) ); return new SubLNode( add1, in2->in(1) );
} }
return NULL; return NULL;
@ -417,7 +417,7 @@ Node *SubFNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// Convert "x - (x+y)" into "-y" // Convert "x - (x+y)" into "-y"
if( in(2)->is_Add() && if( in(2)->is_Add() &&
phase->eqv(in(1),in(2)->in(1) ) ) phase->eqv(in(1),in(2)->in(1) ) )
return new (phase->C) SubFNode( phase->makecon(TypeF::ZERO),in(2)->in(2)); return new SubFNode( phase->makecon(TypeF::ZERO),in(2)->in(2));
} }
// Cannot replace 0.0-X with -X because a 'fsub' bytecode computes // Cannot replace 0.0-X with -X because a 'fsub' bytecode computes
@ -460,7 +460,7 @@ Node *SubDNode::Ideal(PhaseGVN *phase, bool can_reshape){
// Convert "x - (x+y)" into "-y" // Convert "x - (x+y)" into "-y"
if( in(2)->is_Add() && if( in(2)->is_Add() &&
phase->eqv(in(1),in(2)->in(1) ) ) phase->eqv(in(1),in(2)->in(1) ) )
return new (phase->C) SubDNode( phase->makecon(TypeD::ZERO),in(2)->in(2)); return new SubDNode( phase->makecon(TypeD::ZERO),in(2)->in(2));
} }
// Cannot replace 0.0-X with -X because a 'dsub' bytecode computes // Cannot replace 0.0-X with -X because a 'dsub' bytecode computes
@ -666,11 +666,11 @@ Node *CmpINode::Ideal( PhaseGVN *phase, bool can_reshape ) {
if (phase->type(in(2))->higher_equal(TypeInt::ZERO)) { if (phase->type(in(2))->higher_equal(TypeInt::ZERO)) {
switch (in(1)->Opcode()) { switch (in(1)->Opcode()) {
case Op_CmpL3: // Collapse a CmpL3/CmpI into a CmpL case Op_CmpL3: // Collapse a CmpL3/CmpI into a CmpL
return new (phase->C) CmpLNode(in(1)->in(1),in(1)->in(2)); return new CmpLNode(in(1)->in(1),in(1)->in(2));
case Op_CmpF3: // Collapse a CmpF3/CmpI into a CmpF case Op_CmpF3: // Collapse a CmpF3/CmpI into a CmpF
return new (phase->C) CmpFNode(in(1)->in(1),in(1)->in(2)); return new CmpFNode(in(1)->in(1),in(1)->in(2));
case Op_CmpD3: // Collapse a CmpD3/CmpI into a CmpD case Op_CmpD3: // Collapse a CmpD3/CmpI into a CmpD
return new (phase->C) CmpDNode(in(1)->in(1),in(1)->in(2)); return new CmpDNode(in(1)->in(1),in(1)->in(2));
//case Op_SubI: //case Op_SubI:
// If (x - y) cannot overflow, then ((x - y) <?> 0) // If (x - y) cannot overflow, then ((x - y) <?> 0)
// can be turned into (x <?> y). // can be turned into (x <?> y).
@ -1109,8 +1109,8 @@ Node *CmpDNode::Ideal(PhaseGVN *phase, bool can_reshape){
new_in2 = tmp; new_in2 = tmp;
} }
CmpFNode *new_cmp = (Opcode() == Op_CmpD3) CmpFNode *new_cmp = (Opcode() == Op_CmpD3)
? new (phase->C) CmpF3Node( new_in1, new_in2 ) ? new CmpF3Node( new_in1, new_in2 )
: new (phase->C) CmpFNode ( new_in1, new_in2 ) ; : new CmpFNode ( new_in1, new_in2 ) ;
return new_cmp; // Changed to CmpFNode return new_cmp; // Changed to CmpFNode
} }
// Testing value required the precision of a double // Testing value required the precision of a double
@ -1182,9 +1182,9 @@ Node* BoolNode::make_predicate(Node* test_value, PhaseGVN* phase) {
// Else fall through. The CMove gets in the way of the test. // Else fall through. The CMove gets in the way of the test.
// It should be the case that make_predicate(bol->as_int_value()) == bol. // It should be the case that make_predicate(bol->as_int_value()) == bol.
} }
Node* cmp = new (C) CmpINode(test_value, phase->intcon(0)); Node* cmp = new CmpINode(test_value, phase->intcon(0));
cmp = phase->transform(cmp); cmp = phase->transform(cmp);
Node* bol = new (C) BoolNode(cmp, BoolTest::ne); Node* bol = new BoolNode(cmp, BoolTest::ne);
return phase->transform(bol); return phase->transform(bol);
} }
@ -1200,7 +1200,7 @@ Node* BoolNode::as_int_value(PhaseGVN* phase) {
//----------------------------------negate------------------------------------- //----------------------------------negate-------------------------------------
BoolNode* BoolNode::negate(PhaseGVN* phase) { BoolNode* BoolNode::negate(PhaseGVN* phase) {
Compile* C = phase->C; Compile* C = phase->C;
return new (C) BoolNode(in(1), _test.negate()); return new BoolNode(in(1), _test.negate());
} }
@ -1238,7 +1238,7 @@ Node *BoolNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// Swap inputs to the clone // Swap inputs to the clone
cmp->swap_edges(1, 2); cmp->swap_edges(1, 2);
cmp = phase->transform( cmp ); cmp = phase->transform( cmp );
return new (phase->C) BoolNode( cmp, _test.commute() ); return new BoolNode( cmp, _test.commute() );
} }
// Change "bool eq/ne (cmp (xor X 1) 0)" into "bool ne/eq (cmp X 0)". // Change "bool eq/ne (cmp (xor X 1) 0)" into "bool ne/eq (cmp X 0)".
@ -1255,8 +1255,8 @@ Node *BoolNode::Ideal(PhaseGVN *phase, bool can_reshape) {
phase->type( j_xor->in(2) ) == TypeInt::ONE && phase->type( j_xor->in(2) ) == TypeInt::ONE &&
(_test._test == BoolTest::eq || (_test._test == BoolTest::eq ||
_test._test == BoolTest::ne) ) { _test._test == BoolTest::ne) ) {
Node *ncmp = phase->transform(new (phase->C) CmpINode(j_xor->in(1),cmp2)); Node *ncmp = phase->transform(new CmpINode(j_xor->in(1),cmp2));
return new (phase->C) BoolNode( ncmp, _test.negate() ); return new BoolNode( ncmp, _test.negate() );
} }
// Change "bool eq/ne (cmp (Conv2B X) 0)" into "bool eq/ne (cmp X 0)". // Change "bool eq/ne (cmp (Conv2B X) 0)" into "bool eq/ne (cmp X 0)".
@ -1267,10 +1267,10 @@ Node *BoolNode::Ideal(PhaseGVN *phase, bool can_reshape) {
(_test._test == BoolTest::eq || (_test._test == BoolTest::eq ||
_test._test == BoolTest::ne) ) { _test._test == BoolTest::ne) ) {
Node *ncmp = phase->transform(phase->type(c2b->in(1))->isa_int() Node *ncmp = phase->transform(phase->type(c2b->in(1))->isa_int()
? (Node*)new (phase->C) CmpINode(c2b->in(1),cmp2) ? (Node*)new CmpINode(c2b->in(1),cmp2)
: (Node*)new (phase->C) CmpPNode(c2b->in(1),phase->makecon(TypePtr::NULL_PTR)) : (Node*)new CmpPNode(c2b->in(1),phase->makecon(TypePtr::NULL_PTR))
); );
return new (phase->C) BoolNode( ncmp, _test._test ); return new BoolNode( ncmp, _test._test );
} }
// Comparing a SubI against a zero is equal to comparing the SubI // Comparing a SubI against a zero is equal to comparing the SubI
@ -1280,8 +1280,8 @@ Node *BoolNode::Ideal(PhaseGVN *phase, bool can_reshape) {
(cop == Op_CmpI) && (cop == Op_CmpI) &&
(cmp1->Opcode() == Op_SubI) && (cmp1->Opcode() == Op_SubI) &&
( cmp2_type == TypeInt::ZERO ) ) { ( cmp2_type == TypeInt::ZERO ) ) {
Node *ncmp = phase->transform( new (phase->C) CmpINode(cmp1->in(1),cmp1->in(2))); Node *ncmp = phase->transform( new CmpINode(cmp1->in(1),cmp1->in(2)));
return new (phase->C) BoolNode( ncmp, _test._test ); return new BoolNode( ncmp, _test._test );
} }
// Change (-A vs 0) into (A vs 0) by commuting the test. Disallow in the // Change (-A vs 0) into (A vs 0) by commuting the test. Disallow in the
@ -1292,8 +1292,8 @@ Node *BoolNode::Ideal(PhaseGVN *phase, bool can_reshape) {
cmp2_type == TypeInt::ZERO && cmp2_type == TypeInt::ZERO &&
phase->type( cmp1->in(1) ) == TypeInt::ZERO && phase->type( cmp1->in(1) ) == TypeInt::ZERO &&
phase->type( cmp1->in(2) )->higher_equal(TypeInt::SYMINT) ) { phase->type( cmp1->in(2) )->higher_equal(TypeInt::SYMINT) ) {
Node *ncmp = phase->transform( new (phase->C) CmpINode(cmp1->in(2),cmp2)); Node *ncmp = phase->transform( new CmpINode(cmp1->in(2),cmp2));
return new (phase->C) BoolNode( ncmp, _test.commute() ); return new BoolNode( ncmp, _test.commute() );
} }
// The transformation below is not valid for either signed or unsigned // The transformation below is not valid for either signed or unsigned

34
hotspot/src/share/vm/opto/superword.cpp
View file

@ -1456,7 +1456,7 @@ Node* SuperWord::vector_opd(Node_List* p, int opd_idx) {
if (t == NULL || t->_lo < 0 || t->_hi > (int)mask) { if (t == NULL || t->_lo < 0 || t->_hi > (int)mask) {
cnt = ConNode::make(C, TypeInt::make(mask)); cnt = ConNode::make(C, TypeInt::make(mask));
_igvn.register_new_node_with_optimizer(cnt); _igvn.register_new_node_with_optimizer(cnt);
cnt = new (C) AndINode(opd, cnt); cnt = new AndINode(opd, cnt);
_igvn.register_new_node_with_optimizer(cnt); _igvn.register_new_node_with_optimizer(cnt);
_phase->set_ctrl(cnt, _phase->get_ctrl(opd)); _phase->set_ctrl(cnt, _phase->get_ctrl(opd));
} }
@ -2067,42 +2067,42 @@ void SuperWord::align_initial_loop_index(MemNode* align_to_ref) {
if (align_to_ref_p.invar() != NULL) { if (align_to_ref_p.invar() != NULL) {
// incorporate any extra invariant piece producing (offset +/- invar) >>> log2(elt) // incorporate any extra invariant piece producing (offset +/- invar) >>> log2(elt)
Node* log2_elt = _igvn.intcon(exact_log2(elt_size)); Node* log2_elt = _igvn.intcon(exact_log2(elt_size));
Node* aref = new (_phase->C) URShiftINode(align_to_ref_p.invar(), log2_elt); Node* aref = new URShiftINode(align_to_ref_p.invar(), log2_elt);
_igvn.register_new_node_with_optimizer(aref); _igvn.register_new_node_with_optimizer(aref);
_phase->set_ctrl(aref, pre_ctrl); _phase->set_ctrl(aref, pre_ctrl);
if (align_to_ref_p.negate_invar()) { if (align_to_ref_p.negate_invar()) {
e = new (_phase->C) SubINode(e, aref); e = new SubINode(e, aref);
} else { } else {
e = new (_phase->C) AddINode(e, aref); e = new AddINode(e, aref);
} }
_igvn.register_new_node_with_optimizer(e); _igvn.register_new_node_with_optimizer(e);
_phase->set_ctrl(e, pre_ctrl); _phase->set_ctrl(e, pre_ctrl);
} }
if (vw > ObjectAlignmentInBytes) { if (vw > ObjectAlignmentInBytes) {
// incorporate base e +/- base && Mask >>> log2(elt) // incorporate base e +/- base && Mask >>> log2(elt)
Node* xbase = new(_phase->C) CastP2XNode(NULL, align_to_ref_p.base()); Node* xbase = new CastP2XNode(NULL, align_to_ref_p.base());
_igvn.register_new_node_with_optimizer(xbase); _igvn.register_new_node_with_optimizer(xbase);
#ifdef _LP64 #ifdef _LP64
xbase = new (_phase->C) ConvL2INode(xbase); xbase = new ConvL2INode(xbase);
_igvn.register_new_node_with_optimizer(xbase); _igvn.register_new_node_with_optimizer(xbase);
#endif #endif
Node* mask = _igvn.intcon(vw-1); Node* mask = _igvn.intcon(vw-1);
Node* masked_xbase = new (_phase->C) AndINode(xbase, mask); Node* masked_xbase = new AndINode(xbase, mask);
_igvn.register_new_node_with_optimizer(masked_xbase); _igvn.register_new_node_with_optimizer(masked_xbase);
Node* log2_elt = _igvn.intcon(exact_log2(elt_size)); Node* log2_elt = _igvn.intcon(exact_log2(elt_size));
Node* bref = new (_phase->C) URShiftINode(masked_xbase, log2_elt); Node* bref = new URShiftINode(masked_xbase, log2_elt);
_igvn.register_new_node_with_optimizer(bref); _igvn.register_new_node_with_optimizer(bref);
_phase->set_ctrl(bref, pre_ctrl); _phase->set_ctrl(bref, pre_ctrl);
e = new (_phase->C) AddINode(e, bref); e = new AddINode(e, bref);
_igvn.register_new_node_with_optimizer(e); _igvn.register_new_node_with_optimizer(e);
_phase->set_ctrl(e, pre_ctrl); _phase->set_ctrl(e, pre_ctrl);
} }
// compute e +/- lim0 // compute e +/- lim0
if (scale < 0) { if (scale < 0) {
e = new (_phase->C) SubINode(e, lim0); e = new SubINode(e, lim0);
} else { } else {
e = new (_phase->C) AddINode(e, lim0); e = new AddINode(e, lim0);
} }
_igvn.register_new_node_with_optimizer(e); _igvn.register_new_node_with_optimizer(e);
_phase->set_ctrl(e, pre_ctrl); _phase->set_ctrl(e, pre_ctrl);
@ -2110,13 +2110,13 @@ void SuperWord::align_initial_loop_index(MemNode* align_to_ref) {
if (stride * scale > 0) { if (stride * scale > 0) {
// compute V - (e +/- lim0) // compute V - (e +/- lim0)
Node* va = _igvn.intcon(v_align); Node* va = _igvn.intcon(v_align);
e = new (_phase->C) SubINode(va, e); e = new SubINode(va, e);
_igvn.register_new_node_with_optimizer(e); _igvn.register_new_node_with_optimizer(e);
_phase->set_ctrl(e, pre_ctrl); _phase->set_ctrl(e, pre_ctrl);
} }
// compute N = (exp) % V // compute N = (exp) % V
Node* va_msk = _igvn.intcon(v_align - 1); Node* va_msk = _igvn.intcon(v_align - 1);
Node* N = new (_phase->C) AndINode(e, va_msk); Node* N = new AndINode(e, va_msk);
_igvn.register_new_node_with_optimizer(N); _igvn.register_new_node_with_optimizer(N);
_phase->set_ctrl(N, pre_ctrl); _phase->set_ctrl(N, pre_ctrl);
@ -2124,15 +2124,15 @@ void SuperWord::align_initial_loop_index(MemNode* align_to_ref) {
// lim = lim0 + N // lim = lim0 + N
Node* lim; Node* lim;
if (stride < 0) { if (stride < 0) {
lim = new (_phase->C) SubINode(lim0, N); lim = new SubINode(lim0, N);
} else { } else {
lim = new (_phase->C) AddINode(lim0, N); lim = new AddINode(lim0, N);
} }
_igvn.register_new_node_with_optimizer(lim); _igvn.register_new_node_with_optimizer(lim);
_phase->set_ctrl(lim, pre_ctrl); _phase->set_ctrl(lim, pre_ctrl);
Node* constrained = Node* constrained =
(stride > 0) ? (Node*) new (_phase->C) MinINode(lim, orig_limit) (stride > 0) ? (Node*) new MinINode(lim, orig_limit)
: (Node*) new (_phase->C) MaxINode(lim, orig_limit); : (Node*) new MaxINode(lim, orig_limit);
_igvn.register_new_node_with_optimizer(constrained); _igvn.register_new_node_with_optimizer(constrained);
_phase->set_ctrl(constrained, pre_ctrl); _phase->set_ctrl(constrained, pre_ctrl);
_igvn.hash_delete(pre_opaq); _igvn.hash_delete(pre_opaq);

126
hotspot/src/share/vm/opto/vectornode.cpp
View file

@ -252,46 +252,46 @@ VectorNode* VectorNode::make(Compile* C, int opc, Node* n1, Node* n2, uint vlen,
guarantee(vopc > 0, err_msg_res("Vector for '%s' is not implemented", NodeClassNames[opc])); guarantee(vopc > 0, err_msg_res("Vector for '%s' is not implemented", NodeClassNames[opc]));
switch (vopc) { switch (vopc) {
case Op_AddVB: return new (C) AddVBNode(n1, n2, vt); case Op_AddVB: return new AddVBNode(n1, n2, vt);
case Op_AddVS: return new (C) AddVSNode(n1, n2, vt); case Op_AddVS: return new AddVSNode(n1, n2, vt);
case Op_AddVI: return new (C) AddVINode(n1, n2, vt); case Op_AddVI: return new AddVINode(n1, n2, vt);
case Op_AddVL: return new (C) AddVLNode(n1, n2, vt); case Op_AddVL: return new AddVLNode(n1, n2, vt);
case Op_AddVF: return new (C) AddVFNode(n1, n2, vt); case Op_AddVF: return new AddVFNode(n1, n2, vt);
case Op_AddVD: return new (C) AddVDNode(n1, n2, vt); case Op_AddVD: return new AddVDNode(n1, n2, vt);
case Op_SubVB: return new (C) SubVBNode(n1, n2, vt); case Op_SubVB: return new SubVBNode(n1, n2, vt);
case Op_SubVS: return new (C) SubVSNode(n1, n2, vt); case Op_SubVS: return new SubVSNode(n1, n2, vt);
case Op_SubVI: return new (C) SubVINode(n1, n2, vt); case Op_SubVI: return new SubVINode(n1, n2, vt);
case Op_SubVL: return new (C) SubVLNode(n1, n2, vt); case Op_SubVL: return new SubVLNode(n1, n2, vt);
case Op_SubVF: return new (C) SubVFNode(n1, n2, vt); case Op_SubVF: return new SubVFNode(n1, n2, vt);
case Op_SubVD: return new (C) SubVDNode(n1, n2, vt); case Op_SubVD: return new SubVDNode(n1, n2, vt);
case Op_MulVS: return new (C) MulVSNode(n1, n2, vt); case Op_MulVS: return new MulVSNode(n1, n2, vt);
case Op_MulVI: return new (C) MulVINode(n1, n2, vt); case Op_MulVI: return new MulVINode(n1, n2, vt);
case Op_MulVF: return new (C) MulVFNode(n1, n2, vt); case Op_MulVF: return new MulVFNode(n1, n2, vt);
case Op_MulVD: return new (C) MulVDNode(n1, n2, vt); case Op_MulVD: return new MulVDNode(n1, n2, vt);
case Op_DivVF: return new (C) DivVFNode(n1, n2, vt); case Op_DivVF: return new DivVFNode(n1, n2, vt);
case Op_DivVD: return new (C) DivVDNode(n1, n2, vt); case Op_DivVD: return new DivVDNode(n1, n2, vt);
case Op_LShiftVB: return new (C) LShiftVBNode(n1, n2, vt); case Op_LShiftVB: return new LShiftVBNode(n1, n2, vt);
case Op_LShiftVS: return new (C) LShiftVSNode(n1, n2, vt); case Op_LShiftVS: return new LShiftVSNode(n1, n2, vt);
case Op_LShiftVI: return new (C) LShiftVINode(n1, n2, vt); case Op_LShiftVI: return new LShiftVINode(n1, n2, vt);
case Op_LShiftVL: return new (C) LShiftVLNode(n1, n2, vt); case Op_LShiftVL: return new LShiftVLNode(n1, n2, vt);
case Op_RShiftVB: return new (C) RShiftVBNode(n1, n2, vt); case Op_RShiftVB: return new RShiftVBNode(n1, n2, vt);
case Op_RShiftVS: return new (C) RShiftVSNode(n1, n2, vt); case Op_RShiftVS: return new RShiftVSNode(n1, n2, vt);
case Op_RShiftVI: return new (C) RShiftVINode(n1, n2, vt); case Op_RShiftVI: return new RShiftVINode(n1, n2, vt);
case Op_RShiftVL: return new (C) RShiftVLNode(n1, n2, vt); case Op_RShiftVL: return new RShiftVLNode(n1, n2, vt);
case Op_URShiftVB: return new (C) URShiftVBNode(n1, n2, vt); case Op_URShiftVB: return new URShiftVBNode(n1, n2, vt);
case Op_URShiftVS: return new (C) URShiftVSNode(n1, n2, vt); case Op_URShiftVS: return new URShiftVSNode(n1, n2, vt);
case Op_URShiftVI: return new (C) URShiftVINode(n1, n2, vt); case Op_URShiftVI: return new URShiftVINode(n1, n2, vt);
case Op_URShiftVL: return new (C) URShiftVLNode(n1, n2, vt); case Op_URShiftVL: return new URShiftVLNode(n1, n2, vt);
case Op_AndV: return new (C) AndVNode(n1, n2, vt); case Op_AndV: return new AndVNode(n1, n2, vt);
case Op_OrV: return new (C) OrVNode (n1, n2, vt); case Op_OrV: return new OrVNode (n1, n2, vt);
case Op_XorV: return new (C) XorVNode(n1, n2, vt); case Op_XorV: return new XorVNode(n1, n2, vt);
} }
fatal(err_msg_res("Missed vector creation for '%s'", NodeClassNames[vopc])); fatal(err_msg_res("Missed vector creation for '%s'", NodeClassNames[vopc]));
return NULL; return NULL;
@ -306,18 +306,18 @@ VectorNode* VectorNode::scalar2vector(Compile* C, Node* s, uint vlen, const Type
switch (bt) { switch (bt) {
case T_BOOLEAN: case T_BOOLEAN:
case T_BYTE: case T_BYTE:
return new (C) ReplicateBNode(s, vt); return new ReplicateBNode(s, vt);
case T_CHAR: case T_CHAR:
case T_SHORT: case T_SHORT:
return new (C) ReplicateSNode(s, vt); return new ReplicateSNode(s, vt);
case T_INT: case T_INT:
return new (C) ReplicateINode(s, vt); return new ReplicateINode(s, vt);
case T_LONG: case T_LONG:
return new (C) ReplicateLNode(s, vt); return new ReplicateLNode(s, vt);
case T_FLOAT: case T_FLOAT:
return new (C) ReplicateFNode(s, vt); return new ReplicateFNode(s, vt);
case T_DOUBLE: case T_DOUBLE:
return new (C) ReplicateDNode(s, vt); return new ReplicateDNode(s, vt);
} }
fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt))); fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt)));
return NULL; return NULL;
@ -330,12 +330,12 @@ VectorNode* VectorNode::shift_count(Compile* C, Node* shift, Node* cnt, uint vle
switch (shift->Opcode()) { switch (shift->Opcode()) {
case Op_LShiftI: case Op_LShiftI:
case Op_LShiftL: case Op_LShiftL:
return new (C) LShiftCntVNode(cnt, vt); return new LShiftCntVNode(cnt, vt);
case Op_RShiftI: case Op_RShiftI:
case Op_RShiftL: case Op_RShiftL:
case Op_URShiftI: case Op_URShiftI:
case Op_URShiftL: case Op_URShiftL:
return new (C) RShiftCntVNode(cnt, vt); return new RShiftCntVNode(cnt, vt);
} }
fatal(err_msg_res("Missed vector creation for '%s'", NodeClassNames[shift->Opcode()])); fatal(err_msg_res("Missed vector creation for '%s'", NodeClassNames[shift->Opcode()]));
return NULL; return NULL;
@ -347,18 +347,18 @@ PackNode* PackNode::make(Compile* C, Node* s, uint vlen, BasicType bt) {
switch (bt) { switch (bt) {
case T_BOOLEAN: case T_BOOLEAN:
case T_BYTE: case T_BYTE:
return new (C) PackBNode(s, vt); return new PackBNode(s, vt);
case T_CHAR: case T_CHAR:
case T_SHORT: case T_SHORT:
return new (C) PackSNode(s, vt); return new PackSNode(s, vt);
case T_INT: case T_INT:
return new (C) PackINode(s, vt); return new PackINode(s, vt);
case T_LONG: case T_LONG:
return new (C) PackLNode(s, vt); return new PackLNode(s, vt);
case T_FLOAT: case T_FLOAT:
return new (C) PackFNode(s, vt); return new PackFNode(s, vt);
case T_DOUBLE: case T_DOUBLE:
return new (C) PackDNode(s, vt); return new PackDNode(s, vt);
} }
fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt))); fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt)));
return NULL; return NULL;
@ -383,18 +383,18 @@ PackNode* PackNode::binary_tree_pack(Compile* C, int lo, int hi) {
switch (bt) { switch (bt) {
case T_BOOLEAN: case T_BOOLEAN:
case T_BYTE: case T_BYTE:
return new (C) PackSNode(n1, n2, TypeVect::make(T_SHORT, 2)); return new PackSNode(n1, n2, TypeVect::make(T_SHORT, 2));
case T_CHAR: case T_CHAR:
case T_SHORT: case T_SHORT:
return new (C) PackINode(n1, n2, TypeVect::make(T_INT, 2)); return new PackINode(n1, n2, TypeVect::make(T_INT, 2));
case T_INT: case T_INT:
return new (C) PackLNode(n1, n2, TypeVect::make(T_LONG, 2)); return new PackLNode(n1, n2, TypeVect::make(T_LONG, 2));
case T_LONG: case T_LONG:
return new (C) Pack2LNode(n1, n2, TypeVect::make(T_LONG, 2)); return new Pack2LNode(n1, n2, TypeVect::make(T_LONG, 2));
case T_FLOAT: case T_FLOAT:
return new (C) PackDNode(n1, n2, TypeVect::make(T_DOUBLE, 2)); return new PackDNode(n1, n2, TypeVect::make(T_DOUBLE, 2));
case T_DOUBLE: case T_DOUBLE:
return new (C) Pack2DNode(n1, n2, TypeVect::make(T_DOUBLE, 2)); return new Pack2DNode(n1, n2, TypeVect::make(T_DOUBLE, 2));
} }
fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt))); fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt)));
} }
@ -405,14 +405,14 @@ PackNode* PackNode::binary_tree_pack(Compile* C, int lo, int hi) {
LoadVectorNode* LoadVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem, LoadVectorNode* LoadVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem,
Node* adr, const TypePtr* atyp, uint vlen, BasicType bt) { Node* adr, const TypePtr* atyp, uint vlen, BasicType bt) {
const TypeVect* vt = TypeVect::make(bt, vlen); const TypeVect* vt = TypeVect::make(bt, vlen);
return new (C) LoadVectorNode(ctl, mem, adr, atyp, vt); return new LoadVectorNode(ctl, mem, adr, atyp, vt);
} }
// Return the vector version of a scalar store node. // Return the vector version of a scalar store node.
StoreVectorNode* StoreVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem, StoreVectorNode* StoreVectorNode::make(Compile* C, int opc, Node* ctl, Node* mem,
Node* adr, const TypePtr* atyp, Node* val, Node* adr, const TypePtr* atyp, Node* val,
uint vlen) { uint vlen) {
return new (C) StoreVectorNode(ctl, mem, adr, atyp, val); return new StoreVectorNode(ctl, mem, adr, atyp, val);
} }
// Extract a scalar element of vector. // Extract a scalar element of vector.
@ -421,21 +421,21 @@ Node* ExtractNode::make(Compile* C, Node* v, uint position, BasicType bt) {
ConINode* pos = ConINode::make(C, (int)position); ConINode* pos = ConINode::make(C, (int)position);
switch (bt) { switch (bt) {
case T_BOOLEAN: case T_BOOLEAN:
return new (C) ExtractUBNode(v, pos); return new ExtractUBNode(v, pos);
case T_BYTE: case T_BYTE:
return new (C) ExtractBNode(v, pos); return new ExtractBNode(v, pos);
case T_CHAR: case T_CHAR:
return new (C) ExtractCNode(v, pos); return new ExtractCNode(v, pos);
case T_SHORT: case T_SHORT:
return new (C) ExtractSNode(v, pos); return new ExtractSNode(v, pos);
case T_INT: case T_INT:
return new (C) ExtractINode(v, pos); return new ExtractINode(v, pos);
case T_LONG: case T_LONG:
return new (C) ExtractLNode(v, pos); return new ExtractLNode(v, pos);
case T_FLOAT: case T_FLOAT:
return new (C) ExtractFNode(v, pos); return new ExtractFNode(v, pos);
case T_DOUBLE: case T_DOUBLE:
return new (C) ExtractDNode(v, pos); return new ExtractDNode(v, pos);
} }
fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt))); fatal(err_msg_res("Type '%s' is not supported for vectors", type2name(bt)));
return NULL; return NULL;