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