1 /*
2 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "opto/addnode.hpp"
27 #include "opto/callnode.hpp"
28 #include "opto/castnode.hpp"
29 #include "opto/connode.hpp"
30 #include "opto/matcher.hpp"
31 #include "opto/phaseX.hpp"
32 #include "opto/subnode.hpp"
33 #include "opto/type.hpp"
34
35 //=============================================================================
36 // If input is already higher or equal to cast type, then this is an identity.
37 Node *ConstraintCastNode::Identity(PhaseTransform *phase) {
38 Node* dom = dominating_cast(phase);
39 if (dom != NULL) {
40 assert(_carry_dependency, "only for casts that carry a dependency");
41 return dom;
42 }
43 if (_carry_dependency) {
44 return this;
45 }
46 return phase->type(in(1))->higher_equal_speculative(_type) ? in(1) : this;
47 }
48
49 //------------------------------Value------------------------------------------
50 // Take 'join' of input and cast-up type
51 const Type *ConstraintCastNode::Value(PhaseTransform *phase) const {
52 if (in(0) && phase->type(in(0)) == Type::TOP) return Type::TOP;
53 const Type* ft = phase->type(in(1))->filter_speculative(_type);
54
55 #ifdef ASSERT
56 // Previous versions of this function had some special case logic,
57 // which is no longer necessary. Make sure of the required effects.
58 switch (Opcode()) {
59 case Op_CastII:
60 {
61 const Type* t1 = phase->type(in(1));
62 if( t1 == Type::TOP ) assert(ft == Type::TOP, "special case #1");
63 const Type* rt = t1->join_speculative(_type);
64 if (rt->empty()) assert(ft == Type::TOP, "special case #2");
65 break;
66 }
67 case Op_CastPP:
68 if (phase->type(in(1)) == TypePtr::NULL_PTR &&
69 _type->isa_ptr() && _type->is_ptr()->_ptr == TypePtr::NotNull)
70 assert(ft == Type::TOP, "special case #3");
71 break;
72 }
73 #endif //ASSERT
74
75 return ft;
76 }
77
78 //------------------------------Ideal------------------------------------------
79 // Return a node which is more "ideal" than the current node. Strip out
80 // control copies
81 Node *ConstraintCastNode::Ideal(PhaseGVN *phase, bool can_reshape) {
82 return (in(0) && remove_dead_region(phase, can_reshape)) ? this : NULL;
83 }
84
85 uint ConstraintCastNode::cmp(const Node &n) const {
86 return TypeNode::cmp(n) && ((ConstraintCastNode&)n)._carry_dependency == _carry_dependency;
87 }
88
89 uint ConstraintCastNode::size_of() const {
90 return sizeof(*this);
91 }
92
93 Node* ConstraintCastNode::make_cast(int opcode, Node* c, Node *n, const Type *t, bool carry_dependency) {
94 switch(opcode) {
95 case Op_CastII: {
96 Node* cast = new CastIINode(n, t, carry_dependency);
97 cast->set_req(0, c);
98 return cast;
99 }
100 case Op_CastPP: {
101 Node* cast = new CastPPNode(n, t, carry_dependency);
102 cast->set_req(0, c);
103 return cast;
104 }
105 case Op_CheckCastPP: return new CheckCastPPNode(c, n, t, carry_dependency);
106 default:
107 fatal("Bad opcode %d", opcode);
108 }
109 return NULL;
110 }
111
112 TypeNode* ConstraintCastNode::dominating_cast(PhaseTransform *phase) const {
113 if (!carry_dependency()) {
114 return NULL;
115 }
116 Node* val = in(1);
117 Node* ctl = in(0);
118 int opc = Opcode();
119 if (ctl == NULL) {
120 return NULL;
121 }
122 for (DUIterator_Fast imax, i = val->fast_outs(imax); i < imax; i++) {
123 Node* u = val->fast_out(i);
124 if (u != this &&
125 u->Opcode() == opc &&
126 u->in(0) != NULL &&
127 u->bottom_type()->higher_equal(type())) {
128 if (phase->is_dominator(u->in(0), ctl)) {
129 return u->as_Type();
130 }
131 if (is_CheckCastPP() && u->in(1)->is_Proj() && u->in(1)->in(0)->is_Allocate() &&
132 u->in(0)->is_Proj() && u->in(0)->in(0)->is_Initialize() &&
133 u->in(1)->in(0)->as_Allocate()->initialization() == u->in(0)->in(0)) {
134 // CheckCastPP following an allocation always dominates all
135 // use of the allocation result
136 return u->as_Type();
137 }
138 }
139 }
140 return NULL;
141 }
142
143 #ifndef PRODUCT
144 void ConstraintCastNode::dump_spec(outputStream *st) const {
145 TypeNode::dump_spec(st);
146 if (_carry_dependency) {
147 st->print(" carry dependency");
148 }
149 }
150 #endif
151
152 const Type *CastIINode::Value(PhaseTransform *phase) const {
153 const Type *res = ConstraintCastNode::Value(phase);
154
155 // Try to improve the type of the CastII if we recognize a CmpI/If
156 // pattern.
157 if (_carry_dependency) {
158 if (in(0) != NULL && in(0)->in(0) != NULL && in(0)->in(0)->is_If()) {
159 assert(in(0)->is_IfFalse() || in(0)->is_IfTrue(), "should be If proj");
160 Node* proj = in(0);
161 if (proj->in(0)->in(1)->is_Bool()) {
162 Node* b = proj->in(0)->in(1);
163 if (b->in(1)->Opcode() == Op_CmpI) {
164 Node* cmp = b->in(1);
165 if (cmp->in(1) == in(1) && phase->type(cmp->in(2))->isa_int()) {
166 const TypeInt* in2_t = phase->type(cmp->in(2))->is_int();
167 const Type* t = TypeInt::INT;
168 BoolTest test = b->as_Bool()->_test;
169 if (proj->is_IfFalse()) {
170 test = test.negate();
171 }
172 BoolTest::mask m = test._test;
173 jlong lo_long = min_jint;
174 jlong hi_long = max_jint;
175 if (m == BoolTest::le || m == BoolTest::lt) {
176 hi_long = in2_t->_hi;
177 if (m == BoolTest::lt) {
178 hi_long -= 1;
179 }
180 } else if (m == BoolTest::ge || m == BoolTest::gt) {
181 lo_long = in2_t->_lo;
182 if (m == BoolTest::gt) {
183 lo_long += 1;
184 }
185 } else if (m == BoolTest::eq) {
186 lo_long = in2_t->_lo;
187 hi_long = in2_t->_hi;
188 } else if (m == BoolTest::ne) {
189 // can't do any better
190 } else {
191 stringStream ss;
192 test.dump_on(&ss);
193 fatal("unexpected comparison %s", ss.as_string());
194 }
195 int lo_int = (int)lo_long;
196 int hi_int = (int)hi_long;
197
198 if (lo_long != (jlong)lo_int) {
199 lo_int = min_jint;
200 }
201 if (hi_long != (jlong)hi_int) {
202 hi_int = max_jint;
203 }
204
205 t = TypeInt::make(lo_int, hi_int, Type::WidenMax);
206
207 res = res->filter_speculative(t);
208
209 return res;
210 }
211 }
212 }
213 }
214 }
215 return res;
216 }
217
218 //=============================================================================
219 //------------------------------Identity---------------------------------------
220 // If input is already higher or equal to cast type, then this is an identity.
221 Node *CheckCastPPNode::Identity( PhaseTransform *phase ) {
222 Node* dom = dominating_cast(phase);
223 if (dom != NULL) {
224 assert(_carry_dependency, "only for casts that carry a dependency");
225 return dom;
226 }
227 if (_carry_dependency) {
228 return this;
229 }
230 // Toned down to rescue meeting at a Phi 3 different oops all implementing
231 // the same interface. CompileTheWorld starting at 502, kd12rc1.zip.
232 return (phase->type(in(1)) == phase->type(this)) ? in(1) : this;
233 }
234
235 //------------------------------Value------------------------------------------
236 // Take 'join' of input and cast-up type, unless working with an Interface
237 const Type *CheckCastPPNode::Value( PhaseTransform *phase ) const {
238 if( in(0) && phase->type(in(0)) == Type::TOP ) return Type::TOP;
239
240 const Type *inn = phase->type(in(1));
241 if( inn == Type::TOP ) return Type::TOP; // No information yet
242
243 const TypePtr *in_type = inn->isa_ptr();
244 const TypePtr *my_type = _type->isa_ptr();
245 const Type *result = _type;
246 if( in_type != NULL && my_type != NULL ) {
247 TypePtr::PTR in_ptr = in_type->ptr();
248 if (in_ptr == TypePtr::Null) {
249 result = in_type;
250 } else if (in_ptr == TypePtr::Constant) {
251 const TypeOopPtr *jptr = my_type->isa_oopptr();
252 assert(jptr, "");
253 result = !in_type->higher_equal(_type)
254 ? my_type->cast_to_ptr_type(TypePtr::NotNull)
255 : in_type;
256 } else {
257 result = my_type->cast_to_ptr_type( my_type->join_ptr(in_ptr) );
258 }
259 }
260
261 // This is the code from TypePtr::xmeet() that prevents us from
262 // having 2 ways to represent the same type. We have to replicate it
263 // here because we don't go through meet/join.
264 if (result->remove_speculative() == result->speculative()) {
265 result = result->remove_speculative();
266 }
267
268 // Same as above: because we don't go through meet/join, remove the
269 // speculative type if we know we won't use it.
270 return result->cleanup_speculative();
271
272 // JOIN NOT DONE HERE BECAUSE OF INTERFACE ISSUES.
273 // FIX THIS (DO THE JOIN) WHEN UNION TYPES APPEAR!
274
275 //
276 // Remove this code after overnight run indicates no performance
277 // loss from not performing JOIN at CheckCastPPNode
278 //
279 // const TypeInstPtr *in_oop = in->isa_instptr();
280 // const TypeInstPtr *my_oop = _type->isa_instptr();
281 // // If either input is an 'interface', return destination type
282 // assert (in_oop == NULL || in_oop->klass() != NULL, "");
283 // assert (my_oop == NULL || my_oop->klass() != NULL, "");
284 // if( (in_oop && in_oop->klass()->is_interface())
285 // ||(my_oop && my_oop->klass()->is_interface()) ) {
286 // TypePtr::PTR in_ptr = in->isa_ptr() ? in->is_ptr()->_ptr : TypePtr::BotPTR;
287 // // Preserve cast away nullness for interfaces
288 // if( in_ptr == TypePtr::NotNull && my_oop && my_oop->_ptr == TypePtr::BotPTR ) {
289 // return my_oop->cast_to_ptr_type(TypePtr::NotNull);
290 // }
291 // return _type;
292 // }
293 //
294 // // Neither the input nor the destination type is an interface,
295 //
296 // // history: JOIN used to cause weird corner case bugs
297 // // return (in == TypeOopPtr::NULL_PTR) ? in : _type;
298 // // JOIN picks up NotNull in common instance-of/check-cast idioms, both oops.
299 // // JOIN does not preserve NotNull in other cases, e.g. RawPtr vs InstPtr
300 // const Type *join = in->join(_type);
301 // // Check if join preserved NotNull'ness for pointers
302 // if( join->isa_ptr() && _type->isa_ptr() ) {
303 // TypePtr::PTR join_ptr = join->is_ptr()->_ptr;
304 // TypePtr::PTR type_ptr = _type->is_ptr()->_ptr;
305 // // If there isn't any NotNull'ness to preserve
306 // // OR if join preserved NotNull'ness then return it
307 // if( type_ptr == TypePtr::BotPTR || type_ptr == TypePtr::Null ||
308 // join_ptr == TypePtr::NotNull || join_ptr == TypePtr::Constant ) {
309 // return join;
310 // }
311 // // ELSE return same old type as before
312 // return _type;
313 // }
314 // // Not joining two pointers
315 // return join;
316 }
317
318 //=============================================================================
319 //------------------------------Value------------------------------------------
320 const Type *CastX2PNode::Value( PhaseTransform *phase ) const {
321 const Type* t = phase->type(in(1));
322 if (t == Type::TOP) return Type::TOP;
323 if (t->base() == Type_X && t->singleton()) {
324 uintptr_t bits = (uintptr_t) t->is_intptr_t()->get_con();
325 if (bits == 0) return TypePtr::NULL_PTR;
326 return TypeRawPtr::make((address) bits);
327 }
328 return CastX2PNode::bottom_type();
329 }
330
331 //------------------------------Idealize---------------------------------------
332 static inline bool fits_in_int(const Type* t, bool but_not_min_int = false) {
333 if (t == Type::TOP) return false;
334 const TypeX* tl = t->is_intptr_t();
335 jint lo = min_jint;
336 jint hi = max_jint;
337 if (but_not_min_int) ++lo; // caller wants to negate the value w/o overflow
338 return (tl->_lo >= lo) && (tl->_hi <= hi);
339 }
340
341 static inline Node* addP_of_X2P(PhaseGVN *phase,
342 Node* base,
343 Node* dispX,
344 bool negate = false) {
345 if (negate) {
346 dispX = new SubXNode(phase->MakeConX(0), phase->transform(dispX));
347 }
348 return new AddPNode(phase->C->top(),
349 phase->transform(new CastX2PNode(base)),
350 phase->transform(dispX));
351 }
352
353 Node *CastX2PNode::Ideal(PhaseGVN *phase, bool can_reshape) {
354 // convert CastX2P(AddX(x, y)) to AddP(CastX2P(x), y) if y fits in an int
355 int op = in(1)->Opcode();
356 Node* x;
357 Node* y;
358 switch (op) {
359 case Op_SubX:
360 x = in(1)->in(1);
361 // Avoid ideal transformations ping-pong between this and AddP for raw pointers.
362 if (phase->find_intptr_t_con(x, -1) == 0)
363 break;
364 y = in(1)->in(2);
365 if (fits_in_int(phase->type(y), true)) {
366 return addP_of_X2P(phase, x, y, true);
367 }
368 break;
369 case Op_AddX:
370 x = in(1)->in(1);
371 y = in(1)->in(2);
372 if (fits_in_int(phase->type(y))) {
373 return addP_of_X2P(phase, x, y);
374 }
375 if (fits_in_int(phase->type(x))) {
376 return addP_of_X2P(phase, y, x);
377 }
378 break;
379 }
380 return NULL;
381 }
382
383 //------------------------------Identity---------------------------------------
384 Node *CastX2PNode::Identity( PhaseTransform *phase ) {
385 if (in(1)->Opcode() == Op_CastP2X) return in(1)->in(1);
386 return this;
387 }
388
389 //=============================================================================
390 //------------------------------Value------------------------------------------
391 const Type *CastP2XNode::Value( PhaseTransform *phase ) const {
392 const Type* t = phase->type(in(1));
393 if (t == Type::TOP) return Type::TOP;
394 if (t->base() == Type::RawPtr && t->singleton()) {
395 uintptr_t bits = (uintptr_t) t->is_rawptr()->get_con();
396 return TypeX::make(bits);
397 }
398 return CastP2XNode::bottom_type();
399 }
400
401 Node *CastP2XNode::Ideal(PhaseGVN *phase, bool can_reshape) {
402 return (in(0) && remove_dead_region(phase, can_reshape)) ? this : NULL;
403 }
404
405 //------------------------------Identity---------------------------------------
406 Node *CastP2XNode::Identity( PhaseTransform *phase ) {
407 if (in(1)->Opcode() == Op_CastX2P) return in(1)->in(1);
408 return this;
409 }