Mercurial > hg > truffle

comparison src/share/vm/opto/superword.cpp @ 6804:e626685e9f6c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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 }