Mercurial > hg > truffle
annotate src/share/vm/opto/addnode.cpp @ 9126:bc26f978b0ce
HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly
don't use the (wrong) cached value, but ask the runtime on each request.
Fixes regression on xml.* benchmarks @ specjvm2008. The problem was:
After the constructor of Object was deoptimized due to an assumption violation,
it was recompiled again after some time. However, on recompilation, the value
of hasFinalizeSubclass for the class was not updated and it was compiled again
with a, now wrong, assumption, which then triggers deoptimization again.
This was repeated until it hit the recompilation limit (defined by
PerMethodRecompilationCutoff), and therefore only executed by the interpreter
from now on, causing the performance regression.
| author | Bernhard Urban <bernhard.urban@jku.at> |
|---|---|
| date | Mon, 15 Apr 2013 19:54:58 +0200 |
| parents | ad5dd04754ee |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6842
b9a9ed0f8eeb
7197424: update copyright year to match last edit in jdk8 hotspot repository
mikael
parents:
6804
diff
changeset
|
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1541
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1541
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1541
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "memory/allocation.inline.hpp" | |
| 27 #include "opto/addnode.hpp" | |
| 28 #include "opto/cfgnode.hpp" | |
| 29 #include "opto/connode.hpp" | |
| 30 #include "opto/machnode.hpp" | |
| 31 #include "opto/mulnode.hpp" | |
| 32 #include "opto/phaseX.hpp" | |
| 33 #include "opto/subnode.hpp" | |
| 0 | 34 |
| 1972 | 35 // Portions of code courtesy of Clifford Click |
| 0 | 36 |
| 37 // Classic Add functionality. This covers all the usual 'add' behaviors for | |
| 38 // an algebraic ring. Add-integer, add-float, add-double, and binary-or are | |
| 39 // all inherited from this class. The various identity values are supplied | |
| 40 // by virtual functions. | |
| 41 | |
| 42 | |
| 43 //============================================================================= | |
| 44 //------------------------------hash------------------------------------------- | |
| 45 // Hash function over AddNodes. Needs to be commutative; i.e., I swap | |
| 46 // (commute) inputs to AddNodes willy-nilly so the hash function must return | |
| 47 // the same value in the presence of edge swapping. | |
| 48 uint AddNode::hash() const { | |
| 49 return (uintptr_t)in(1) + (uintptr_t)in(2) + Opcode(); | |
| 50 } | |
| 51 | |
| 52 //------------------------------Identity--------------------------------------- | |
| 53 // If either input is a constant 0, return the other input. | |
| 54 Node *AddNode::Identity( PhaseTransform *phase ) { | |
| 55 const Type *zero = add_id(); // The additive identity | |
| 56 if( phase->type( in(1) )->higher_equal( zero ) ) return in(2); | |
| 57 if( phase->type( in(2) )->higher_equal( zero ) ) return in(1); | |
| 58 return this; | |
| 59 } | |
| 60 | |
| 61 //------------------------------commute---------------------------------------- | |
| 62 // Commute operands to move loads and constants to the right. | |
| 63 static bool commute( Node *add, int con_left, int con_right ) { | |
| 64 Node *in1 = add->in(1); | |
| 65 Node *in2 = add->in(2); | |
| 66 | |
| 67 // Convert "1+x" into "x+1". | |
| 68 // Right is a constant; leave it | |
| 69 if( con_right ) return false; | |
| 70 // Left is a constant; move it right. | |
| 71 if( con_left ) { | |
| 72 add->swap_edges(1, 2); | |
| 73 return true; | |
| 74 } | |
| 75 | |
| 76 // Convert "Load+x" into "x+Load". | |
| 77 // Now check for loads | |
|
99
8a4ef4e001d3
6680594: Load + Load isn't canonicalized leading to missed GVN opportunities
never
parents:
32
diff
changeset
|
78 if (in2->is_Load()) { |
|
8a4ef4e001d3
6680594: Load + Load isn't canonicalized leading to missed GVN opportunities
never
parents:
32
diff
changeset
|
79 if (!in1->is_Load()) { |
|
8a4ef4e001d3
6680594: Load + Load isn't canonicalized leading to missed GVN opportunities
never
parents:
32
diff
changeset
|
80 // already x+Load to return |
|
8a4ef4e001d3
6680594: Load + Load isn't canonicalized leading to missed GVN opportunities
never
parents:
32
diff
changeset
|
81 return false; |
|
8a4ef4e001d3
6680594: Load + Load isn't canonicalized leading to missed GVN opportunities
never
parents:
32
diff
changeset
|
82 } |
|
8a4ef4e001d3
6680594: Load + Load isn't canonicalized leading to missed GVN opportunities
never
parents:
32
diff
changeset
|
83 // both are loads, so fall through to sort inputs by idx |
|
8a4ef4e001d3
6680594: Load + Load isn't canonicalized leading to missed GVN opportunities
never
parents:
32
diff
changeset
|
84 } else if( in1->is_Load() ) { |
|
8a4ef4e001d3
6680594: Load + Load isn't canonicalized leading to missed GVN opportunities
never
parents:
32
diff
changeset
|
85 // Left is a Load and Right is not; move it right. |
| 0 | 86 add->swap_edges(1, 2); |
| 87 return true; | |
| 88 } | |
| 89 | |
| 90 PhiNode *phi; | |
| 91 // Check for tight loop increments: Loop-phi of Add of loop-phi | |
| 92 if( in1->is_Phi() && (phi = in1->as_Phi()) && !phi->is_copy() && phi->region()->is_Loop() && phi->in(2)==add) | |
| 93 return false; | |
| 94 if( in2->is_Phi() && (phi = in2->as_Phi()) && !phi->is_copy() && phi->region()->is_Loop() && phi->in(2)==add){ | |
| 95 add->swap_edges(1, 2); | |
| 96 return true; | |
| 97 } | |
| 98 | |
| 99 // Otherwise, sort inputs (commutativity) to help value numbering. | |
| 100 if( in1->_idx > in2->_idx ) { | |
| 101 add->swap_edges(1, 2); | |
| 102 return true; | |
| 103 } | |
| 104 return false; | |
| 105 } | |
| 106 | |
| 107 //------------------------------Idealize--------------------------------------- | |
| 108 // If we get here, we assume we are associative! | |
| 109 Node *AddNode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 110 const Type *t1 = phase->type( in(1) ); | |
| 111 const Type *t2 = phase->type( in(2) ); | |
| 112 int con_left = t1->singleton(); | |
| 113 int con_right = t2->singleton(); | |
| 114 | |
| 115 // Check for commutative operation desired | |
| 116 if( commute(this,con_left,con_right) ) return this; | |
| 117 | |
| 118 AddNode *progress = NULL; // Progress flag | |
| 119 | |
| 120 // Convert "(x+1)+2" into "x+(1+2)". If the right input is a | |
| 121 // constant, and the left input is an add of a constant, flatten the | |
| 122 // expression tree. | |
| 123 Node *add1 = in(1); | |
| 124 Node *add2 = in(2); | |
| 125 int add1_op = add1->Opcode(); | |
| 126 int this_op = Opcode(); | |
| 127 if( con_right && t2 != Type::TOP && // Right input is a constant? | |
| 128 add1_op == this_op ) { // Left input is an Add? | |
| 129 | |
| 130 // Type of left _in right input | |
| 131 const Type *t12 = phase->type( add1->in(2) ); | |
| 132 if( t12->singleton() && t12 != Type::TOP ) { // Left input is an add of a constant? | |
| 133 // Check for rare case of closed data cycle which can happen inside | |
| 134 // unreachable loops. In these cases the computation is undefined. | |
| 135 #ifdef ASSERT | |
| 136 Node *add11 = add1->in(1); | |
| 137 int add11_op = add11->Opcode(); | |
| 138 if( (add1 == add1->in(1)) | |
| 139 || (add11_op == this_op && add11->in(1) == add1) ) { | |
| 140 assert(false, "dead loop in AddNode::Ideal"); | |
| 141 } | |
| 142 #endif | |
| 143 // The Add of the flattened expression | |
| 144 Node *x1 = add1->in(1); | |
| 145 Node *x2 = phase->makecon( add1->as_Add()->add_ring( t2, t12 )); | |
| 146 PhaseIterGVN *igvn = phase->is_IterGVN(); | |
| 147 if( igvn ) { | |
| 148 set_req_X(2,x2,igvn); | |
| 149 set_req_X(1,x1,igvn); | |
| 150 } else { | |
| 151 set_req(2,x2); | |
| 152 set_req(1,x1); | |
| 153 } | |
| 154 progress = this; // Made progress | |
| 155 add1 = in(1); | |
| 156 add1_op = add1->Opcode(); | |
| 157 } | |
| 158 } | |
| 159 | |
| 160 // Convert "(x+1)+y" into "(x+y)+1". Push constants down the expression tree. | |
| 161 if( add1_op == this_op && !con_right ) { | |
| 162 Node *a12 = add1->in(2); | |
| 163 const Type *t12 = phase->type( a12 ); | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
164 if( t12->singleton() && t12 != Type::TOP && (add1 != add1->in(1)) && |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
165 !(add1->in(1)->is_Phi() && add1->in(1)->as_Phi()->is_tripcount()) ) { |
|
320
2b73d212b1fd
6676462: JVM sometimes would suddenly consume significant amount of memory
kvn
parents:
306
diff
changeset
|
166 assert(add1->in(1) != this, "dead loop in AddNode::Ideal"); |
| 0 | 167 add2 = add1->clone(); |
| 168 add2->set_req(2, in(2)); | |
| 169 add2 = phase->transform(add2); | |
| 170 set_req(1, add2); | |
| 171 set_req(2, a12); | |
| 172 progress = this; | |
| 173 add2 = a12; | |
| 174 } | |
| 175 } | |
| 176 | |
| 177 // Convert "x+(y+1)" into "(x+y)+1". Push constants down the expression tree. | |
| 178 int add2_op = add2->Opcode(); | |
| 179 if( add2_op == this_op && !con_left ) { | |
| 180 Node *a22 = add2->in(2); | |
| 181 const Type *t22 = phase->type( a22 ); | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
182 if( t22->singleton() && t22 != Type::TOP && (add2 != add2->in(1)) && |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
183 !(add2->in(1)->is_Phi() && add2->in(1)->as_Phi()->is_tripcount()) ) { |
|
320
2b73d212b1fd
6676462: JVM sometimes would suddenly consume significant amount of memory
kvn
parents:
306
diff
changeset
|
184 assert(add2->in(1) != this, "dead loop in AddNode::Ideal"); |
| 0 | 185 Node *addx = add2->clone(); |
| 186 addx->set_req(1, in(1)); | |
| 187 addx->set_req(2, add2->in(1)); | |
| 188 addx = phase->transform(addx); | |
| 189 set_req(1, addx); | |
| 190 set_req(2, a22); | |
| 191 progress = this; | |
|
7421
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
6842
diff
changeset
|
192 PhaseIterGVN *igvn = phase->is_IterGVN(); |
|
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
6842
diff
changeset
|
193 if (add2->outcnt() == 0 && igvn) { |
|
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
6842
diff
changeset
|
194 // add disconnected. |
|
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
6842
diff
changeset
|
195 igvn->_worklist.push(add2); |
|
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
6842
diff
changeset
|
196 } |
| 0 | 197 } |
| 198 } | |
| 199 | |
| 200 return progress; | |
| 201 } | |
| 202 | |
| 203 //------------------------------Value----------------------------------------- | |
| 204 // An add node sums it's two _in. If one input is an RSD, we must mixin | |
| 205 // the other input's symbols. | |
| 206 const Type *AddNode::Value( PhaseTransform *phase ) const { | |
| 207 // Either input is TOP ==> the result is TOP | |
| 208 const Type *t1 = phase->type( in(1) ); | |
| 209 const Type *t2 = phase->type( in(2) ); | |
| 210 if( t1 == Type::TOP ) return Type::TOP; | |
| 211 if( t2 == Type::TOP ) return Type::TOP; | |
| 212 | |
| 213 // Either input is BOTTOM ==> the result is the local BOTTOM | |
| 214 const Type *bot = bottom_type(); | |
| 215 if( (t1 == bot) || (t2 == bot) || | |
| 216 (t1 == Type::BOTTOM) || (t2 == Type::BOTTOM) ) | |
| 217 return bot; | |
| 218 | |
| 219 // Check for an addition involving the additive identity | |
| 220 const Type *tadd = add_of_identity( t1, t2 ); | |
| 221 if( tadd ) return tadd; | |
| 222 | |
| 223 return add_ring(t1,t2); // Local flavor of type addition | |
| 224 } | |
| 225 | |
| 226 //------------------------------add_identity----------------------------------- | |
| 227 // Check for addition of the identity | |
| 228 const Type *AddNode::add_of_identity( const Type *t1, const Type *t2 ) const { | |
| 229 const Type *zero = add_id(); // The additive identity | |
| 230 if( t1->higher_equal( zero ) ) return t2; | |
| 231 if( t2->higher_equal( zero ) ) return t1; | |
| 232 | |
| 233 return NULL; | |
| 234 } | |
| 235 | |
| 236 | |
| 237 //============================================================================= | |
| 238 //------------------------------Idealize--------------------------------------- | |
| 239 Node *AddINode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
240 Node* in1 = in(1); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
241 Node* in2 = in(2); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
242 int op1 = in1->Opcode(); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
243 int op2 = in2->Opcode(); |
| 0 | 244 // Fold (con1-x)+con2 into (con1+con2)-x |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
245 if ( op1 == Op_AddI && op2 == Op_SubI ) { |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
246 // Swap edges to try optimizations below |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
247 in1 = in2; |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
248 in2 = in(1); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
249 op1 = op2; |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
250 op2 = in2->Opcode(); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
251 } |
| 0 | 252 if( op1 == Op_SubI ) { |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
253 const Type *t_sub1 = phase->type( in1->in(1) ); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
254 const Type *t_2 = phase->type( in2 ); |
| 0 | 255 if( t_sub1->singleton() && t_2->singleton() && t_sub1 != Type::TOP && t_2 != Type::TOP ) |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
256 return new (phase->C) SubINode(phase->makecon( add_ring( t_sub1, t_2 ) ), |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
257 in1->in(2) ); |
| 0 | 258 // Convert "(a-b)+(c-d)" into "(a+c)-(b+d)" |
| 259 if( op2 == Op_SubI ) { | |
| 260 // Check for dead cycle: d = (a-b)+(c-d) | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
261 assert( in1->in(2) != this && in2->in(2) != this, |
| 0 | 262 "dead loop in AddINode::Ideal" ); |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
263 Node *sub = new (phase->C) SubINode(NULL, NULL); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
264 sub->init_req(1, phase->transform(new (phase->C) AddINode(in1->in(1), in2->in(1) ) )); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
265 sub->init_req(2, phase->transform(new (phase->C) AddINode(in1->in(2), in2->in(2) ) )); |
| 0 | 266 return sub; |
| 267 } | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
268 // Convert "(a-b)+(b+c)" into "(a+c)" |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
269 if( op2 == Op_AddI && in1->in(2) == in2->in(1) ) { |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
270 assert(in1->in(1) != this && in2->in(2) != this,"dead loop in AddINode::Ideal"); |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
271 return new (phase->C) AddINode(in1->in(1), in2->in(2)); |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
272 } |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
273 // Convert "(a-b)+(c+b)" into "(a+c)" |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
274 if( op2 == Op_AddI && in1->in(2) == in2->in(2) ) { |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
275 assert(in1->in(1) != this && in2->in(1) != this,"dead loop in AddINode::Ideal"); |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
276 return new (phase->C) AddINode(in1->in(1), in2->in(1)); |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
277 } |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
278 // Convert "(a-b)+(b-c)" into "(a-c)" |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
279 if( op2 == Op_SubI && in1->in(2) == in2->in(1) ) { |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
280 assert(in1->in(1) != this && in2->in(2) != this,"dead loop in AddINode::Ideal"); |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
281 return new (phase->C) SubINode(in1->in(1), in2->in(2)); |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
282 } |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
283 // Convert "(a-b)+(c-a)" into "(c-b)" |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
284 if( op2 == Op_SubI && in1->in(1) == in2->in(2) ) { |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
285 assert(in1->in(2) != this && in2->in(1) != this,"dead loop in AddINode::Ideal"); |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
286 return new (phase->C) SubINode(in2->in(1), in1->in(2)); |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
287 } |
| 0 | 288 } |
| 289 | |
| 290 // Convert "x+(0-y)" into "(x-y)" | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
291 if( op2 == Op_SubI && phase->type(in2->in(1)) == TypeInt::ZERO ) |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
292 return new (phase->C) SubINode(in1, in2->in(2) ); |
| 0 | 293 |
| 294 // Convert "(0-y)+x" into "(x-y)" | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
295 if( op1 == Op_SubI && phase->type(in1->in(1)) == TypeInt::ZERO ) |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
296 return new (phase->C) SubINode( in2, in1->in(2) ); |
| 0 | 297 |
| 298 // Convert (x>>>z)+y into (x+(y<<z))>>>z for small constant z and y. | |
| 299 // Helps with array allocation math constant folding | |
| 300 // See 4790063: | |
| 301 // Unrestricted transformation is unsafe for some runtime values of 'x' | |
| 302 // ( x == 0, z == 1, y == -1 ) fails | |
| 303 // ( x == -5, z == 1, y == 1 ) fails | |
| 304 // Transform works for small z and small negative y when the addition | |
| 305 // (x + (y << z)) does not cross zero. | |
| 306 // Implement support for negative y and (x >= -(y << z)) | |
| 307 // Have not observed cases where type information exists to support | |
| 308 // positive y and (x <= -(y << z)) | |
| 309 if( op1 == Op_URShiftI && op2 == Op_ConI && | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
310 in1->in(2)->Opcode() == Op_ConI ) { |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
311 jint z = phase->type( in1->in(2) )->is_int()->get_con() & 0x1f; // only least significant 5 bits matter |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
312 jint y = phase->type( in2 )->is_int()->get_con(); |
| 0 | 313 |
| 314 if( z < 5 && -5 < y && y < 0 ) { | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
315 const Type *t_in11 = phase->type(in1->in(1)); |
| 0 | 316 if( t_in11 != Type::TOP && (t_in11->is_int()->_lo >= -(y << z)) ) { |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
317 Node *a = phase->transform( new (phase->C) AddINode( in1->in(1), phase->intcon(y<<z) ) ); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
318 return new (phase->C) URShiftINode( a, in1->in(2) ); |
| 0 | 319 } |
| 320 } | |
| 321 } | |
| 322 | |
| 323 return AddNode::Ideal(phase, can_reshape); | |
| 324 } | |
| 325 | |
| 326 | |
| 327 //------------------------------Identity--------------------------------------- | |
| 328 // Fold (x-y)+y OR y+(x-y) into x | |
| 329 Node *AddINode::Identity( PhaseTransform *phase ) { | |
| 330 if( in(1)->Opcode() == Op_SubI && phase->eqv(in(1)->in(2),in(2)) ) { | |
| 331 return in(1)->in(1); | |
| 332 } | |
| 333 else if( in(2)->Opcode() == Op_SubI && phase->eqv(in(2)->in(2),in(1)) ) { | |
| 334 return in(2)->in(1); | |
| 335 } | |
| 336 return AddNode::Identity(phase); | |
| 337 } | |
| 338 | |
| 339 | |
| 340 //------------------------------add_ring--------------------------------------- | |
| 341 // Supplied function returns the sum of the inputs. Guaranteed never | |
| 342 // to be passed a TOP or BOTTOM type, these are filtered out by | |
| 343 // pre-check. | |
| 344 const Type *AddINode::add_ring( const Type *t0, const Type *t1 ) const { | |
| 345 const TypeInt *r0 = t0->is_int(); // Handy access | |
| 346 const TypeInt *r1 = t1->is_int(); | |
| 347 int lo = r0->_lo + r1->_lo; | |
| 348 int hi = r0->_hi + r1->_hi; | |
| 349 if( !(r0->is_con() && r1->is_con()) ) { | |
| 350 // Not both constants, compute approximate result | |
| 351 if( (r0->_lo & r1->_lo) < 0 && lo >= 0 ) { | |
| 352 lo = min_jint; hi = max_jint; // Underflow on the low side | |
| 353 } | |
| 354 if( (~(r0->_hi | r1->_hi)) < 0 && hi < 0 ) { | |
| 355 lo = min_jint; hi = max_jint; // Overflow on the high side | |
| 356 } | |
| 357 if( lo > hi ) { // Handle overflow | |
| 358 lo = min_jint; hi = max_jint; | |
| 359 } | |
| 360 } else { | |
| 361 // both constants, compute precise result using 'lo' and 'hi' | |
| 362 // Semantics define overflow and underflow for integer addition | |
| 363 // as expected. In particular: 0x80000000 + 0x80000000 --> 0x0 | |
| 364 } | |
| 365 return TypeInt::make( lo, hi, MAX2(r0->_widen,r1->_widen) ); | |
| 366 } | |
| 367 | |
| 368 | |
| 369 //============================================================================= | |
| 370 //------------------------------Idealize--------------------------------------- | |
| 371 Node *AddLNode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
372 Node* in1 = in(1); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
373 Node* in2 = in(2); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
374 int op1 = in1->Opcode(); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
375 int op2 = in2->Opcode(); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
376 // Fold (con1-x)+con2 into (con1+con2)-x |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
377 if ( op1 == Op_AddL && op2 == Op_SubL ) { |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
378 // Swap edges to try optimizations below |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
379 in1 = in2; |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
380 in2 = in(1); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
381 op1 = op2; |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
382 op2 = in2->Opcode(); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
383 } |
| 0 | 384 // Fold (con1-x)+con2 into (con1+con2)-x |
| 385 if( op1 == Op_SubL ) { | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
386 const Type *t_sub1 = phase->type( in1->in(1) ); |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
387 const Type *t_2 = phase->type( in2 ); |
| 0 | 388 if( t_sub1->singleton() && t_2->singleton() && t_sub1 != Type::TOP && t_2 != Type::TOP ) |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
389 return new (phase->C) SubLNode(phase->makecon( add_ring( t_sub1, t_2 ) ), |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
390 in1->in(2) ); |
| 0 | 391 // Convert "(a-b)+(c-d)" into "(a+c)-(b+d)" |
| 392 if( op2 == Op_SubL ) { | |
| 393 // Check for dead cycle: d = (a-b)+(c-d) | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
394 assert( in1->in(2) != this && in2->in(2) != this, |
| 0 | 395 "dead loop in AddLNode::Ideal" ); |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
396 Node *sub = new (phase->C) SubLNode(NULL, NULL); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
397 sub->init_req(1, phase->transform(new (phase->C) AddLNode(in1->in(1), in2->in(1) ) )); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
398 sub->init_req(2, phase->transform(new (phase->C) AddLNode(in1->in(2), in2->in(2) ) )); |
| 0 | 399 return sub; |
| 400 } | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
401 // Convert "(a-b)+(b+c)" into "(a+c)" |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
402 if( op2 == Op_AddL && in1->in(2) == in2->in(1) ) { |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
403 assert(in1->in(1) != this && in2->in(2) != this,"dead loop in AddLNode::Ideal"); |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
404 return new (phase->C) AddLNode(in1->in(1), in2->in(2)); |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
405 } |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
406 // Convert "(a-b)+(c+b)" into "(a+c)" |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
407 if( op2 == Op_AddL && in1->in(2) == in2->in(2) ) { |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
408 assert(in1->in(1) != this && in2->in(1) != this,"dead loop in AddLNode::Ideal"); |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
409 return new (phase->C) AddLNode(in1->in(1), in2->in(1)); |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
410 } |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
411 // Convert "(a-b)+(b-c)" into "(a-c)" |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
412 if( op2 == Op_SubL && in1->in(2) == in2->in(1) ) { |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
413 assert(in1->in(1) != this && in2->in(2) != this,"dead loop in AddLNode::Ideal"); |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
414 return new (phase->C) SubLNode(in1->in(1), in2->in(2)); |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
415 } |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
416 // Convert "(a-b)+(c-a)" into "(c-b)" |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
417 if( op2 == Op_SubL && in1->in(1) == in1->in(2) ) { |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
418 assert(in1->in(2) != this && in2->in(1) != this,"dead loop in AddLNode::Ideal"); |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
419 return new (phase->C) SubLNode(in2->in(1), in1->in(2)); |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
420 } |
| 0 | 421 } |
| 422 | |
| 423 // Convert "x+(0-y)" into "(x-y)" | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
424 if( op2 == Op_SubL && phase->type(in2->in(1)) == TypeLong::ZERO ) |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
425 return new (phase->C) SubLNode( in1, in2->in(2) ); |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
426 |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
427 // Convert "(0-y)+x" into "(x-y)" |
|
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
428 if( op1 == Op_SubL && phase->type(in1->in(1)) == TypeInt::ZERO ) |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
429 return new (phase->C) SubLNode( in2, in1->in(2) ); |
| 0 | 430 |
| 431 // Convert "X+X+X+X+X...+X+Y" into "k*X+Y" or really convert "X+(X+Y)" | |
| 432 // into "(X<<1)+Y" and let shift-folding happen. | |
| 433 if( op2 == Op_AddL && | |
|
400
cc80376deb0c
6667595: Set probability FAIR for pre-, post- loops and ALWAYS for main loop
kvn
parents:
320
diff
changeset
|
434 in2->in(1) == in1 && |
| 0 | 435 op1 != Op_ConL && |
| 436 0 ) { | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
437 Node *shift = phase->transform(new (phase->C) LShiftLNode(in1,phase->intcon(1))); |
|
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
438 return new (phase->C) AddLNode(shift,in2->in(2)); |
| 0 | 439 } |
| 440 | |
| 441 return AddNode::Ideal(phase, can_reshape); | |
| 442 } | |
| 443 | |
| 444 | |
| 445 //------------------------------Identity--------------------------------------- | |
| 446 // Fold (x-y)+y OR y+(x-y) into x | |
| 447 Node *AddLNode::Identity( PhaseTransform *phase ) { | |
| 448 if( in(1)->Opcode() == Op_SubL && phase->eqv(in(1)->in(2),in(2)) ) { | |
| 449 return in(1)->in(1); | |
| 450 } | |
| 451 else if( in(2)->Opcode() == Op_SubL && phase->eqv(in(2)->in(2),in(1)) ) { | |
| 452 return in(2)->in(1); | |
| 453 } | |
| 454 return AddNode::Identity(phase); | |
| 455 } | |
| 456 | |
| 457 | |
| 458 //------------------------------add_ring--------------------------------------- | |
| 459 // Supplied function returns the sum of the inputs. Guaranteed never | |
| 460 // to be passed a TOP or BOTTOM type, these are filtered out by | |
| 461 // pre-check. | |
| 462 const Type *AddLNode::add_ring( const Type *t0, const Type *t1 ) const { | |
| 463 const TypeLong *r0 = t0->is_long(); // Handy access | |
| 464 const TypeLong *r1 = t1->is_long(); | |
| 465 jlong lo = r0->_lo + r1->_lo; | |
| 466 jlong hi = r0->_hi + r1->_hi; | |
| 467 if( !(r0->is_con() && r1->is_con()) ) { | |
| 468 // Not both constants, compute approximate result | |
| 469 if( (r0->_lo & r1->_lo) < 0 && lo >= 0 ) { | |
| 470 lo =min_jlong; hi = max_jlong; // Underflow on the low side | |
| 471 } | |
| 472 if( (~(r0->_hi | r1->_hi)) < 0 && hi < 0 ) { | |
| 473 lo = min_jlong; hi = max_jlong; // Overflow on the high side | |
| 474 } | |
| 475 if( lo > hi ) { // Handle overflow | |
| 476 lo = min_jlong; hi = max_jlong; | |
| 477 } | |
| 478 } else { | |
| 479 // both constants, compute precise result using 'lo' and 'hi' | |
| 480 // Semantics define overflow and underflow for integer addition | |
| 481 // as expected. In particular: 0x80000000 + 0x80000000 --> 0x0 | |
| 482 } | |
| 483 return TypeLong::make( lo, hi, MAX2(r0->_widen,r1->_widen) ); | |
| 484 } | |
| 485 | |
| 486 | |
| 487 //============================================================================= | |
| 488 //------------------------------add_of_identity-------------------------------- | |
| 489 // Check for addition of the identity | |
| 490 const Type *AddFNode::add_of_identity( const Type *t1, const Type *t2 ) const { | |
| 491 // x ADD 0 should return x unless 'x' is a -zero | |
| 492 // | |
| 493 // const Type *zero = add_id(); // The additive identity | |
| 494 // jfloat f1 = t1->getf(); | |
| 495 // jfloat f2 = t2->getf(); | |
| 496 // | |
| 497 // if( t1->higher_equal( zero ) ) return t2; | |
| 498 // if( t2->higher_equal( zero ) ) return t1; | |
| 499 | |
| 500 return NULL; | |
| 501 } | |
| 502 | |
| 503 //------------------------------add_ring--------------------------------------- | |
| 504 // Supplied function returns the sum of the inputs. | |
| 505 // This also type-checks the inputs for sanity. Guaranteed never to | |
| 506 // be passed a TOP or BOTTOM type, these are filtered out by pre-check. | |
| 507 const Type *AddFNode::add_ring( const Type *t0, const Type *t1 ) const { | |
| 508 // We must be adding 2 float constants. | |
| 509 return TypeF::make( t0->getf() + t1->getf() ); | |
| 510 } | |
| 511 | |
| 512 //------------------------------Ideal------------------------------------------ | |
| 513 Node *AddFNode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 514 if( IdealizedNumerics && !phase->C->method()->is_strict() ) { | |
| 515 return AddNode::Ideal(phase, can_reshape); // commutative and associative transforms | |
| 516 } | |
| 517 | |
| 518 // Floating point additions are not associative because of boundary conditions (infinity) | |
| 519 return commute(this, | |
| 520 phase->type( in(1) )->singleton(), | |
| 521 phase->type( in(2) )->singleton() ) ? this : NULL; | |
| 522 } | |
| 523 | |
| 524 | |
| 525 //============================================================================= | |
| 526 //------------------------------add_of_identity-------------------------------- | |
| 527 // Check for addition of the identity | |
| 528 const Type *AddDNode::add_of_identity( const Type *t1, const Type *t2 ) const { | |
| 529 // x ADD 0 should return x unless 'x' is a -zero | |
| 530 // | |
| 531 // const Type *zero = add_id(); // The additive identity | |
| 532 // jfloat f1 = t1->getf(); | |
| 533 // jfloat f2 = t2->getf(); | |
| 534 // | |
| 535 // if( t1->higher_equal( zero ) ) return t2; | |
| 536 // if( t2->higher_equal( zero ) ) return t1; | |
| 537 | |
| 538 return NULL; | |
| 539 } | |
| 540 //------------------------------add_ring--------------------------------------- | |
| 541 // Supplied function returns the sum of the inputs. | |
| 542 // This also type-checks the inputs for sanity. Guaranteed never to | |
| 543 // be passed a TOP or BOTTOM type, these are filtered out by pre-check. | |
| 544 const Type *AddDNode::add_ring( const Type *t0, const Type *t1 ) const { | |
| 545 // We must be adding 2 double constants. | |
| 546 return TypeD::make( t0->getd() + t1->getd() ); | |
| 547 } | |
| 548 | |
| 549 //------------------------------Ideal------------------------------------------ | |
| 550 Node *AddDNode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 551 if( IdealizedNumerics && !phase->C->method()->is_strict() ) { | |
| 552 return AddNode::Ideal(phase, can_reshape); // commutative and associative transforms | |
| 553 } | |
| 554 | |
| 555 // Floating point additions are not associative because of boundary conditions (infinity) | |
| 556 return commute(this, | |
| 557 phase->type( in(1) )->singleton(), | |
| 558 phase->type( in(2) )->singleton() ) ? this : NULL; | |
| 559 } | |
| 560 | |
| 561 | |
| 562 //============================================================================= | |
| 563 //------------------------------Identity--------------------------------------- | |
| 564 // If one input is a constant 0, return the other input. | |
| 565 Node *AddPNode::Identity( PhaseTransform *phase ) { | |
| 566 return ( phase->type( in(Offset) )->higher_equal( TypeX_ZERO ) ) ? in(Address) : this; | |
| 567 } | |
| 568 | |
| 569 //------------------------------Idealize--------------------------------------- | |
| 570 Node *AddPNode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 571 // Bail out if dead inputs | |
| 572 if( phase->type( in(Address) ) == Type::TOP ) return NULL; | |
| 573 | |
| 574 // If the left input is an add of a constant, flatten the expression tree. | |
| 575 const Node *n = in(Address); | |
| 576 if (n->is_AddP() && n->in(Base) == in(Base)) { | |
| 577 const AddPNode *addp = n->as_AddP(); // Left input is an AddP | |
| 578 assert( !addp->in(Address)->is_AddP() || | |
| 579 addp->in(Address)->as_AddP() != addp, | |
| 580 "dead loop in AddPNode::Ideal" ); | |
| 581 // Type of left input's right input | |
| 582 const Type *t = phase->type( addp->in(Offset) ); | |
| 583 if( t == Type::TOP ) return NULL; | |
| 584 const TypeX *t12 = t->is_intptr_t(); | |
| 585 if( t12->is_con() ) { // Left input is an add of a constant? | |
| 586 // If the right input is a constant, combine constants | |
| 587 const Type *temp_t2 = phase->type( in(Offset) ); | |
| 588 if( temp_t2 == Type::TOP ) return NULL; | |
| 589 const TypeX *t2 = temp_t2->is_intptr_t(); | |
|
32
4d428c5b4cb3
6667573: Use set_req_X() in AddPNode::Ideal() for Iterative GVN
kvn
parents:
17
diff
changeset
|
590 Node* address; |
|
4d428c5b4cb3
6667573: Use set_req_X() in AddPNode::Ideal() for Iterative GVN
kvn
parents:
17
diff
changeset
|
591 Node* offset; |
| 0 | 592 if( t2->is_con() ) { |
| 593 // The Add of the flattened expression | |
|
32
4d428c5b4cb3
6667573: Use set_req_X() in AddPNode::Ideal() for Iterative GVN
kvn
parents:
17
diff
changeset
|
594 address = addp->in(Address); |
|
4d428c5b4cb3
6667573: Use set_req_X() in AddPNode::Ideal() for Iterative GVN
kvn
parents:
17
diff
changeset
|
595 offset = phase->MakeConX(t2->get_con() + t12->get_con()); |
|
4d428c5b4cb3
6667573: Use set_req_X() in AddPNode::Ideal() for Iterative GVN
kvn
parents:
17
diff
changeset
|
596 } else { |
|
4d428c5b4cb3
6667573: Use set_req_X() in AddPNode::Ideal() for Iterative GVN
kvn
parents:
17
diff
changeset
|
597 // Else move the constant to the right. ((A+con)+B) into ((A+B)+con) |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
598 address = phase->transform(new (phase->C) AddPNode(in(Base),addp->in(Address),in(Offset))); |
|
32
4d428c5b4cb3
6667573: Use set_req_X() in AddPNode::Ideal() for Iterative GVN
kvn
parents:
17
diff
changeset
|
599 offset = addp->in(Offset); |
| 0 | 600 } |
|
32
4d428c5b4cb3
6667573: Use set_req_X() in AddPNode::Ideal() for Iterative GVN
kvn
parents:
17
diff
changeset
|
601 PhaseIterGVN *igvn = phase->is_IterGVN(); |
|
4d428c5b4cb3
6667573: Use set_req_X() in AddPNode::Ideal() for Iterative GVN
kvn
parents:
17
diff
changeset
|
602 if( igvn ) { |
|
4d428c5b4cb3
6667573: Use set_req_X() in AddPNode::Ideal() for Iterative GVN
kvn
parents:
17
diff
changeset
|
603 set_req_X(Address,address,igvn); |
|
4d428c5b4cb3
6667573: Use set_req_X() in AddPNode::Ideal() for Iterative GVN
kvn
parents:
17
diff
changeset
|
604 set_req_X(Offset,offset,igvn); |
|
4d428c5b4cb3
6667573: Use set_req_X() in AddPNode::Ideal() for Iterative GVN
kvn
parents:
17
diff
changeset
|
605 } else { |
|
4d428c5b4cb3
6667573: Use set_req_X() in AddPNode::Ideal() for Iterative GVN
kvn
parents:
17
diff
changeset
|
606 set_req(Address,address); |
|
4d428c5b4cb3
6667573: Use set_req_X() in AddPNode::Ideal() for Iterative GVN
kvn
parents:
17
diff
changeset
|
607 set_req(Offset,offset); |
|
4d428c5b4cb3
6667573: Use set_req_X() in AddPNode::Ideal() for Iterative GVN
kvn
parents:
17
diff
changeset
|
608 } |
| 0 | 609 return this; |
| 610 } | |
| 611 } | |
| 612 | |
| 613 // Raw pointers? | |
| 614 if( in(Base)->bottom_type() == Type::TOP ) { | |
| 615 // If this is a NULL+long form (from unsafe accesses), switch to a rawptr. | |
| 616 if (phase->type(in(Address)) == TypePtr::NULL_PTR) { | |
| 617 Node* offset = in(Offset); | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
618 return new (phase->C) CastX2PNode(offset); |
| 0 | 619 } |
| 620 } | |
| 621 | |
| 622 // If the right is an add of a constant, push the offset down. | |
| 623 // Convert: (ptr + (offset+con)) into (ptr+offset)+con. | |
| 624 // The idea is to merge array_base+scaled_index groups together, | |
| 625 // and only have different constant offsets from the same base. | |
| 626 const Node *add = in(Offset); | |
| 627 if( add->Opcode() == Op_AddX && add->in(1) != add ) { | |
| 628 const Type *t22 = phase->type( add->in(2) ); | |
| 629 if( t22->singleton() && (t22 != Type::TOP) ) { // Right input is an add of a constant? | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
630 set_req(Address, phase->transform(new (phase->C) AddPNode(in(Base),in(Address),add->in(1)))); |
| 0 | 631 set_req(Offset, add->in(2)); |
|
7421
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
6842
diff
changeset
|
632 PhaseIterGVN *igvn = phase->is_IterGVN(); |
|
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
6842
diff
changeset
|
633 if (add->outcnt() == 0 && igvn) { |
|
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
6842
diff
changeset
|
634 // add disconnected. |
|
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
6842
diff
changeset
|
635 igvn->_worklist.push((Node*)add); |
|
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
6842
diff
changeset
|
636 } |
| 0 | 637 return this; // Made progress |
| 638 } | |
| 639 } | |
| 640 | |
| 641 return NULL; // No progress | |
| 642 } | |
| 643 | |
| 644 //------------------------------bottom_type------------------------------------ | |
| 645 // Bottom-type is the pointer-type with unknown offset. | |
| 646 const Type *AddPNode::bottom_type() const { | |
| 647 if (in(Address) == NULL) return TypePtr::BOTTOM; | |
| 648 const TypePtr *tp = in(Address)->bottom_type()->isa_ptr(); | |
| 649 if( !tp ) return Type::TOP; // TOP input means TOP output | |
| 650 assert( in(Offset)->Opcode() != Op_ConP, "" ); | |
| 651 const Type *t = in(Offset)->bottom_type(); | |
| 652 if( t == Type::TOP ) | |
| 653 return tp->add_offset(Type::OffsetTop); | |
| 654 const TypeX *tx = t->is_intptr_t(); | |
| 655 intptr_t txoffset = Type::OffsetBot; | |
| 656 if (tx->is_con()) { // Left input is an add of a constant? | |
| 657 txoffset = tx->get_con(); | |
| 658 } | |
| 659 return tp->add_offset(txoffset); | |
| 660 } | |
| 661 | |
| 662 //------------------------------Value------------------------------------------ | |
| 663 const Type *AddPNode::Value( PhaseTransform *phase ) const { | |
| 664 // Either input is TOP ==> the result is TOP | |
| 665 const Type *t1 = phase->type( in(Address) ); | |
| 666 const Type *t2 = phase->type( in(Offset) ); | |
| 667 if( t1 == Type::TOP ) return Type::TOP; | |
| 668 if( t2 == Type::TOP ) return Type::TOP; | |
| 669 | |
| 670 // Left input is a pointer | |
| 671 const TypePtr *p1 = t1->isa_ptr(); | |
| 672 // Right input is an int | |
| 673 const TypeX *p2 = t2->is_intptr_t(); | |
| 674 // Add 'em | |
| 675 intptr_t p2offset = Type::OffsetBot; | |
| 676 if (p2->is_con()) { // Left input is an add of a constant? | |
| 677 p2offset = p2->get_con(); | |
| 678 } | |
| 679 return p1->add_offset(p2offset); | |
| 680 } | |
| 681 | |
| 682 //------------------------Ideal_base_and_offset-------------------------------- | |
| 683 // Split an oop pointer into a base and offset. | |
| 684 // (The offset might be Type::OffsetBot in the case of an array.) | |
| 685 // Return the base, or NULL if failure. | |
| 686 Node* AddPNode::Ideal_base_and_offset(Node* ptr, PhaseTransform* phase, | |
| 687 // second return value: | |
| 688 intptr_t& offset) { | |
| 689 if (ptr->is_AddP()) { | |
| 690 Node* base = ptr->in(AddPNode::Base); | |
| 691 Node* addr = ptr->in(AddPNode::Address); | |
| 692 Node* offs = ptr->in(AddPNode::Offset); | |
| 693 if (base == addr || base->is_top()) { | |
| 694 offset = phase->find_intptr_t_con(offs, Type::OffsetBot); | |
| 695 if (offset != Type::OffsetBot) { | |
| 696 return addr; | |
| 697 } | |
| 698 } | |
| 699 } | |
| 700 offset = Type::OffsetBot; | |
| 701 return NULL; | |
| 702 } | |
| 703 | |
|
17
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
704 //------------------------------unpack_offsets---------------------------------- |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
705 // Collect the AddP offset values into the elements array, giving up |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
706 // if there are more than length. |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
707 int AddPNode::unpack_offsets(Node* elements[], int length) { |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
708 int count = 0; |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
709 Node* addr = this; |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
710 Node* base = addr->in(AddPNode::Base); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
711 while (addr->is_AddP()) { |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
712 if (addr->in(AddPNode::Base) != base) { |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
713 // give up |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
714 return -1; |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
715 } |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
716 elements[count++] = addr->in(AddPNode::Offset); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
717 if (count == length) { |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
718 // give up |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
719 return -1; |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
720 } |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
721 addr = addr->in(AddPNode::Address); |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
722 } |
| 1763 | 723 if (addr != base) { |
| 724 return -1; | |
| 725 } | |
|
17
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
726 return count; |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
727 } |
|
ff5961f4c095
6395208: Elide autoboxing for calls to HashMap.get(int) and HashMap.get(long)
never
parents:
0
diff
changeset
|
728 |
| 0 | 729 //------------------------------match_edge------------------------------------- |
| 730 // Do we Match on this edge index or not? Do not match base pointer edge | |
| 731 uint AddPNode::match_edge(uint idx) const { | |
| 732 return idx > Base; | |
| 733 } | |
| 734 | |
| 735 //============================================================================= | |
| 736 //------------------------------Identity--------------------------------------- | |
| 737 Node *OrINode::Identity( PhaseTransform *phase ) { | |
| 738 // x | x => x | |
| 739 if (phase->eqv(in(1), in(2))) { | |
| 740 return in(1); | |
| 741 } | |
| 742 | |
| 743 return AddNode::Identity(phase); | |
| 744 } | |
| 745 | |
| 746 //------------------------------add_ring--------------------------------------- | |
| 747 // Supplied function returns the sum of the inputs IN THE CURRENT RING. For | |
| 748 // the logical operations the ring's ADD is really a logical OR function. | |
| 749 // This also type-checks the inputs for sanity. Guaranteed never to | |
| 750 // be passed a TOP or BOTTOM type, these are filtered out by pre-check. | |
| 751 const Type *OrINode::add_ring( const Type *t0, const Type *t1 ) const { | |
| 752 const TypeInt *r0 = t0->is_int(); // Handy access | |
| 753 const TypeInt *r1 = t1->is_int(); | |
| 754 | |
| 755 // If both args are bool, can figure out better types | |
| 756 if ( r0 == TypeInt::BOOL ) { | |
| 757 if ( r1 == TypeInt::ONE) { | |
| 758 return TypeInt::ONE; | |
| 759 } else if ( r1 == TypeInt::BOOL ) { | |
| 760 return TypeInt::BOOL; | |
| 761 } | |
| 762 } else if ( r0 == TypeInt::ONE ) { | |
| 763 if ( r1 == TypeInt::BOOL ) { | |
| 764 return TypeInt::ONE; | |
| 765 } | |
| 766 } | |
| 767 | |
| 768 // If either input is not a constant, just return all integers. | |
| 769 if( !r0->is_con() || !r1->is_con() ) | |
| 770 return TypeInt::INT; // Any integer, but still no symbols. | |
| 771 | |
| 772 // Otherwise just OR them bits. | |
| 773 return TypeInt::make( r0->get_con() | r1->get_con() ); | |
| 774 } | |
| 775 | |
| 776 //============================================================================= | |
| 777 //------------------------------Identity--------------------------------------- | |
| 778 Node *OrLNode::Identity( PhaseTransform *phase ) { | |
| 779 // x | x => x | |
| 780 if (phase->eqv(in(1), in(2))) { | |
| 781 return in(1); | |
| 782 } | |
| 783 | |
| 784 return AddNode::Identity(phase); | |
| 785 } | |
| 786 | |
| 787 //------------------------------add_ring--------------------------------------- | |
| 788 const Type *OrLNode::add_ring( const Type *t0, const Type *t1 ) const { | |
| 789 const TypeLong *r0 = t0->is_long(); // Handy access | |
| 790 const TypeLong *r1 = t1->is_long(); | |
| 791 | |
| 792 // If either input is not a constant, just return all integers. | |
| 793 if( !r0->is_con() || !r1->is_con() ) | |
| 794 return TypeLong::LONG; // Any integer, but still no symbols. | |
| 795 | |
| 796 // Otherwise just OR them bits. | |
| 797 return TypeLong::make( r0->get_con() | r1->get_con() ); | |
| 798 } | |
| 799 | |
| 800 //============================================================================= | |
| 801 //------------------------------add_ring--------------------------------------- | |
| 802 // Supplied function returns the sum of the inputs IN THE CURRENT RING. For | |
| 803 // the logical operations the ring's ADD is really a logical OR function. | |
| 804 // This also type-checks the inputs for sanity. Guaranteed never to | |
| 805 // be passed a TOP or BOTTOM type, these are filtered out by pre-check. | |
| 806 const Type *XorINode::add_ring( const Type *t0, const Type *t1 ) const { | |
| 807 const TypeInt *r0 = t0->is_int(); // Handy access | |
| 808 const TypeInt *r1 = t1->is_int(); | |
| 809 | |
| 810 // Complementing a boolean? | |
| 811 if( r0 == TypeInt::BOOL && ( r1 == TypeInt::ONE | |
| 812 || r1 == TypeInt::BOOL)) | |
| 813 return TypeInt::BOOL; | |
| 814 | |
| 815 if( !r0->is_con() || !r1->is_con() ) // Not constants | |
| 816 return TypeInt::INT; // Any integer, but still no symbols. | |
| 817 | |
| 818 // Otherwise just XOR them bits. | |
| 819 return TypeInt::make( r0->get_con() ^ r1->get_con() ); | |
| 820 } | |
| 821 | |
| 822 //============================================================================= | |
| 823 //------------------------------add_ring--------------------------------------- | |
| 824 const Type *XorLNode::add_ring( const Type *t0, const Type *t1 ) const { | |
| 825 const TypeLong *r0 = t0->is_long(); // Handy access | |
| 826 const TypeLong *r1 = t1->is_long(); | |
| 827 | |
| 828 // If either input is not a constant, just return all integers. | |
| 829 if( !r0->is_con() || !r1->is_con() ) | |
| 830 return TypeLong::LONG; // Any integer, but still no symbols. | |
| 831 | |
| 832 // Otherwise just OR them bits. | |
| 833 return TypeLong::make( r0->get_con() ^ r1->get_con() ); | |
| 834 } | |
| 835 | |
| 836 //============================================================================= | |
| 837 //------------------------------add_ring--------------------------------------- | |
| 838 // Supplied function returns the sum of the inputs. | |
| 839 const Type *MaxINode::add_ring( const Type *t0, const Type *t1 ) const { | |
| 840 const TypeInt *r0 = t0->is_int(); // Handy access | |
| 841 const TypeInt *r1 = t1->is_int(); | |
| 842 | |
| 843 // Otherwise just MAX them bits. | |
| 844 return TypeInt::make( MAX2(r0->_lo,r1->_lo), MAX2(r0->_hi,r1->_hi), MAX2(r0->_widen,r1->_widen) ); | |
| 845 } | |
| 846 | |
| 847 //============================================================================= | |
| 848 //------------------------------Idealize--------------------------------------- | |
| 849 // MINs show up in range-check loop limit calculations. Look for | |
| 850 // "MIN2(x+c0,MIN2(y,x+c1))". Pick the smaller constant: "MIN2(x+c0,y)" | |
| 851 Node *MinINode::Ideal(PhaseGVN *phase, bool can_reshape) { | |
| 852 Node *progress = NULL; | |
| 853 // Force a right-spline graph | |
| 854 Node *l = in(1); | |
| 855 Node *r = in(2); | |
| 856 // Transform MinI1( MinI2(a,b), c) into MinI1( a, MinI2(b,c) ) | |
| 857 // to force a right-spline graph for the rest of MinINode::Ideal(). | |
| 858 if( l->Opcode() == Op_MinI ) { | |
| 859 assert( l != l->in(1), "dead loop in MinINode::Ideal" ); | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
860 r = phase->transform(new (phase->C) MinINode(l->in(2),r)); |
| 0 | 861 l = l->in(1); |
| 862 set_req(1, l); | |
| 863 set_req(2, r); | |
| 864 return this; | |
| 865 } | |
| 866 | |
| 867 // Get left input & constant | |
| 868 Node *x = l; | |
| 869 int x_off = 0; | |
| 870 if( x->Opcode() == Op_AddI && // Check for "x+c0" and collect constant | |
| 871 x->in(2)->is_Con() ) { | |
| 872 const Type *t = x->in(2)->bottom_type(); | |
| 873 if( t == Type::TOP ) return NULL; // No progress | |
| 874 x_off = t->is_int()->get_con(); | |
| 875 x = x->in(1); | |
| 876 } | |
| 877 | |
| 878 // Scan a right-spline-tree for MINs | |
| 879 Node *y = r; | |
| 880 int y_off = 0; | |
| 881 // Check final part of MIN tree | |
| 882 if( y->Opcode() == Op_AddI && // Check for "y+c1" and collect constant | |
| 883 y->in(2)->is_Con() ) { | |
| 884 const Type *t = y->in(2)->bottom_type(); | |
| 885 if( t == Type::TOP ) return NULL; // No progress | |
| 886 y_off = t->is_int()->get_con(); | |
| 887 y = y->in(1); | |
| 888 } | |
| 889 if( x->_idx > y->_idx && r->Opcode() != Op_MinI ) { | |
| 890 swap_edges(1, 2); | |
| 891 return this; | |
| 892 } | |
| 893 | |
| 894 | |
| 895 if( r->Opcode() == Op_MinI ) { | |
| 896 assert( r != r->in(2), "dead loop in MinINode::Ideal" ); | |
| 897 y = r->in(1); | |
| 898 // Check final part of MIN tree | |
| 899 if( y->Opcode() == Op_AddI &&// Check for "y+c1" and collect constant | |
| 900 y->in(2)->is_Con() ) { | |
| 901 const Type *t = y->in(2)->bottom_type(); | |
| 902 if( t == Type::TOP ) return NULL; // No progress | |
| 903 y_off = t->is_int()->get_con(); | |
| 904 y = y->in(1); | |
| 905 } | |
| 906 | |
| 907 if( x->_idx > y->_idx ) | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
908 return new (phase->C) MinINode(r->in(1),phase->transform(new (phase->C) MinINode(l,r->in(2)))); |
| 0 | 909 |
| 910 // See if covers: MIN2(x+c0,MIN2(y+c1,z)) | |
| 911 if( !phase->eqv(x,y) ) return NULL; | |
| 912 // If (y == x) transform MIN2(x+c0, MIN2(x+c1,z)) into | |
| 913 // MIN2(x+c0 or x+c1 which less, z). | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
914 return new (phase->C) MinINode(phase->transform(new (phase->C) AddINode(x,phase->intcon(MIN2(x_off,y_off)))),r->in(2)); |
| 0 | 915 } else { |
| 916 // See if covers: MIN2(x+c0,y+c1) | |
| 917 if( !phase->eqv(x,y) ) return NULL; | |
| 918 // If (y == x) transform MIN2(x+c0,x+c1) into x+c0 or x+c1 which less. | |
|
6804
e626685e9f6c
7193318: C2: remove number of inputs requirement from Node's new operator
kvn
parents:
4045
diff
changeset
|
919 return new (phase->C) AddINode(x,phase->intcon(MIN2(x_off,y_off))); |
| 0 | 920 } |
| 921 | |
| 922 } | |
| 923 | |
| 924 //------------------------------add_ring--------------------------------------- | |
| 925 // Supplied function returns the sum of the inputs. | |
| 926 const Type *MinINode::add_ring( const Type *t0, const Type *t1 ) const { | |
| 927 const TypeInt *r0 = t0->is_int(); // Handy access | |
| 928 const TypeInt *r1 = t1->is_int(); | |
| 929 | |
| 930 // Otherwise just MIN them bits. | |
| 931 return TypeInt::make( MIN2(r0->_lo,r1->_lo), MIN2(r0->_hi,r1->_hi), MAX2(r0->_widen,r1->_widen) ); | |
| 932 } |