Mercurial > hg > graal-compiler
comparison src/share/vm/opto/superword.cpp @ 6804:e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
Summary: Deleted placement new operator of Node - node(size_t, Compile *, int).
Reviewed-by: kvn, twisti
Contributed-by: bharadwaj.yadavalli@oracle.com
author | kvn |
---|---|
date | Thu, 27 Sep 2012 09:38:42 -0700 |
parents | 06f52c4d0e18 |
children | 859c45fb8cea |
comparison
equal
deleted
inserted
replaced
6803:06f52c4d0e18 | 6804:e626685e9f6c |
---|---|
1449 } | 1449 } |
1450 } else { | 1450 } else { |
1451 if (t == NULL || t->_lo < 0 || t->_hi > (int)mask) { | 1451 if (t == NULL || t->_lo < 0 || t->_hi > (int)mask) { |
1452 cnt = ConNode::make(C, TypeInt::make(mask)); | 1452 cnt = ConNode::make(C, TypeInt::make(mask)); |
1453 _igvn.register_new_node_with_optimizer(cnt); | 1453 _igvn.register_new_node_with_optimizer(cnt); |
1454 cnt = new (C, 3) AndINode(opd, cnt); | 1454 cnt = new (C) AndINode(opd, cnt); |
1455 _igvn.register_new_node_with_optimizer(cnt); | 1455 _igvn.register_new_node_with_optimizer(cnt); |
1456 _phase->set_ctrl(cnt, _phase->get_ctrl(opd)); | 1456 _phase->set_ctrl(cnt, _phase->get_ctrl(opd)); |
1457 } | 1457 } |
1458 assert(opd->bottom_type()->isa_int(), "int type only"); | 1458 assert(opd->bottom_type()->isa_int(), "int type only"); |
1459 // Move non constant shift count into XMM register. | 1459 // Move non constant shift count into XMM register. |
1460 cnt = new (C, 2) MoveI2FNode(cnt); | 1460 cnt = new (C) MoveI2FNode(cnt); |
1461 } | 1461 } |
1462 if (cnt != opd) { | 1462 if (cnt != opd) { |
1463 _igvn.register_new_node_with_optimizer(cnt); | 1463 _igvn.register_new_node_with_optimizer(cnt); |
1464 _phase->set_ctrl(cnt, _phase->get_ctrl(opd)); | 1464 _phase->set_ctrl(cnt, _phase->get_ctrl(opd)); |
1465 } | 1465 } |
2019 | 2019 |
2020 Node *e = offsn; | 2020 Node *e = offsn; |
2021 if (align_to_ref_p.invar() != NULL) { | 2021 if (align_to_ref_p.invar() != NULL) { |
2022 // incorporate any extra invariant piece producing (offset +/- invar) >>> log2(elt) | 2022 // incorporate any extra invariant piece producing (offset +/- invar) >>> log2(elt) |
2023 Node* log2_elt = _igvn.intcon(exact_log2(elt_size)); | 2023 Node* log2_elt = _igvn.intcon(exact_log2(elt_size)); |
2024 Node* aref = new (_phase->C, 3) URShiftINode(align_to_ref_p.invar(), log2_elt); | 2024 Node* aref = new (_phase->C) URShiftINode(align_to_ref_p.invar(), log2_elt); |
2025 _igvn.register_new_node_with_optimizer(aref); | 2025 _igvn.register_new_node_with_optimizer(aref); |
2026 _phase->set_ctrl(aref, pre_ctrl); | 2026 _phase->set_ctrl(aref, pre_ctrl); |
2027 if (align_to_ref_p.negate_invar()) { | 2027 if (align_to_ref_p.negate_invar()) { |
2028 e = new (_phase->C, 3) SubINode(e, aref); | 2028 e = new (_phase->C) SubINode(e, aref); |
2029 } else { | 2029 } else { |
2030 e = new (_phase->C, 3) AddINode(e, aref); | 2030 e = new (_phase->C) AddINode(e, aref); |
2031 } | 2031 } |
2032 _igvn.register_new_node_with_optimizer(e); | 2032 _igvn.register_new_node_with_optimizer(e); |
2033 _phase->set_ctrl(e, pre_ctrl); | 2033 _phase->set_ctrl(e, pre_ctrl); |
2034 } | 2034 } |
2035 if (vw > ObjectAlignmentInBytes) { | 2035 if (vw > ObjectAlignmentInBytes) { |
2036 // incorporate base e +/- base && Mask >>> log2(elt) | 2036 // incorporate base e +/- base && Mask >>> log2(elt) |
2037 Node* xbase = new(_phase->C, 2) CastP2XNode(NULL, align_to_ref_p.base()); | 2037 Node* xbase = new(_phase->C) CastP2XNode(NULL, align_to_ref_p.base()); |
2038 _igvn.register_new_node_with_optimizer(xbase); | 2038 _igvn.register_new_node_with_optimizer(xbase); |
2039 #ifdef _LP64 | 2039 #ifdef _LP64 |
2040 xbase = new (_phase->C, 2) ConvL2INode(xbase); | 2040 xbase = new (_phase->C) ConvL2INode(xbase); |
2041 _igvn.register_new_node_with_optimizer(xbase); | 2041 _igvn.register_new_node_with_optimizer(xbase); |
2042 #endif | 2042 #endif |
2043 Node* mask = _igvn.intcon(vw-1); | 2043 Node* mask = _igvn.intcon(vw-1); |
2044 Node* masked_xbase = new (_phase->C, 3) AndINode(xbase, mask); | 2044 Node* masked_xbase = new (_phase->C) AndINode(xbase, mask); |
2045 _igvn.register_new_node_with_optimizer(masked_xbase); | 2045 _igvn.register_new_node_with_optimizer(masked_xbase); |
2046 Node* log2_elt = _igvn.intcon(exact_log2(elt_size)); | 2046 Node* log2_elt = _igvn.intcon(exact_log2(elt_size)); |
2047 Node* bref = new (_phase->C, 3) URShiftINode(masked_xbase, log2_elt); | 2047 Node* bref = new (_phase->C) URShiftINode(masked_xbase, log2_elt); |
2048 _igvn.register_new_node_with_optimizer(bref); | 2048 _igvn.register_new_node_with_optimizer(bref); |
2049 _phase->set_ctrl(bref, pre_ctrl); | 2049 _phase->set_ctrl(bref, pre_ctrl); |
2050 e = new (_phase->C, 3) AddINode(e, bref); | 2050 e = new (_phase->C) AddINode(e, bref); |
2051 _igvn.register_new_node_with_optimizer(e); | 2051 _igvn.register_new_node_with_optimizer(e); |
2052 _phase->set_ctrl(e, pre_ctrl); | 2052 _phase->set_ctrl(e, pre_ctrl); |
2053 } | 2053 } |
2054 | 2054 |
2055 // compute e +/- lim0 | 2055 // compute e +/- lim0 |
2056 if (scale < 0) { | 2056 if (scale < 0) { |
2057 e = new (_phase->C, 3) SubINode(e, lim0); | 2057 e = new (_phase->C) SubINode(e, lim0); |
2058 } else { | 2058 } else { |
2059 e = new (_phase->C, 3) AddINode(e, lim0); | 2059 e = new (_phase->C) AddINode(e, lim0); |
2060 } | 2060 } |
2061 _igvn.register_new_node_with_optimizer(e); | 2061 _igvn.register_new_node_with_optimizer(e); |
2062 _phase->set_ctrl(e, pre_ctrl); | 2062 _phase->set_ctrl(e, pre_ctrl); |
2063 | 2063 |
2064 if (stride * scale > 0) { | 2064 if (stride * scale > 0) { |
2065 // compute V - (e +/- lim0) | 2065 // compute V - (e +/- lim0) |
2066 Node* va = _igvn.intcon(v_align); | 2066 Node* va = _igvn.intcon(v_align); |
2067 e = new (_phase->C, 3) SubINode(va, e); | 2067 e = new (_phase->C) SubINode(va, e); |
2068 _igvn.register_new_node_with_optimizer(e); | 2068 _igvn.register_new_node_with_optimizer(e); |
2069 _phase->set_ctrl(e, pre_ctrl); | 2069 _phase->set_ctrl(e, pre_ctrl); |
2070 } | 2070 } |
2071 // compute N = (exp) % V | 2071 // compute N = (exp) % V |
2072 Node* va_msk = _igvn.intcon(v_align - 1); | 2072 Node* va_msk = _igvn.intcon(v_align - 1); |
2073 Node* N = new (_phase->C, 3) AndINode(e, va_msk); | 2073 Node* N = new (_phase->C) AndINode(e, va_msk); |
2074 _igvn.register_new_node_with_optimizer(N); | 2074 _igvn.register_new_node_with_optimizer(N); |
2075 _phase->set_ctrl(N, pre_ctrl); | 2075 _phase->set_ctrl(N, pre_ctrl); |
2076 | 2076 |
2077 // substitute back into (1), so that new limit | 2077 // substitute back into (1), so that new limit |
2078 // lim = lim0 + N | 2078 // lim = lim0 + N |
2079 Node* lim; | 2079 Node* lim; |
2080 if (stride < 0) { | 2080 if (stride < 0) { |
2081 lim = new (_phase->C, 3) SubINode(lim0, N); | 2081 lim = new (_phase->C) SubINode(lim0, N); |
2082 } else { | 2082 } else { |
2083 lim = new (_phase->C, 3) AddINode(lim0, N); | 2083 lim = new (_phase->C) AddINode(lim0, N); |
2084 } | 2084 } |
2085 _igvn.register_new_node_with_optimizer(lim); | 2085 _igvn.register_new_node_with_optimizer(lim); |
2086 _phase->set_ctrl(lim, pre_ctrl); | 2086 _phase->set_ctrl(lim, pre_ctrl); |
2087 Node* constrained = | 2087 Node* constrained = |
2088 (stride > 0) ? (Node*) new (_phase->C,3) MinINode(lim, orig_limit) | 2088 (stride > 0) ? (Node*) new (_phase->C) MinINode(lim, orig_limit) |
2089 : (Node*) new (_phase->C,3) MaxINode(lim, orig_limit); | 2089 : (Node*) new (_phase->C) MaxINode(lim, orig_limit); |
2090 _igvn.register_new_node_with_optimizer(constrained); | 2090 _igvn.register_new_node_with_optimizer(constrained); |
2091 _phase->set_ctrl(constrained, pre_ctrl); | 2091 _phase->set_ctrl(constrained, pre_ctrl); |
2092 _igvn.hash_delete(pre_opaq); | 2092 _igvn.hash_delete(pre_opaq); |
2093 pre_opaq->set_req(1, constrained); | 2093 pre_opaq->set_req(1, constrained); |
2094 } | 2094 } |