1 /*
  2  * Copyright (c) 2020, 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/connode.hpp"
 29 #include "opto/convertnode.hpp"
 30 #include "opto/phaseX.hpp"
 31 #include "opto/rootnode.hpp"
 32 #include "opto/subnode.hpp"
 33 #include "opto/subtypenode.hpp"
 34 
 35 const Type* SubTypeCheckNode::sub(const Type* sub_t, const Type* super_t) const {
 36   ciKlass* superk = super_t->is_klassptr()->klass();
 37   ciKlass* subk   = sub_t->isa_klassptr() ? sub_t->is_klassptr()->klass() : sub_t->is_oopptr()->klass();
 38 
 39   bool xsubk = sub_t->isa_klassptr() ? sub_t->is_klassptr()->klass_is_exact() : sub_t->is_oopptr()->klass_is_exact();
 40 
 41 
 42   // Oop can't be a subtype of abstract type that has no subclass.
 43   if (sub_t->isa_oopptr() && superk->is_instance_klass() &&
 44       !superk->is_interface() && superk->is_abstract() &&
 45       !superk->as_instance_klass()->has_subklass()) {
 46     Compile::current()->dependencies()->assert_leaf_type(superk);
 47     return TypeInt::CC_GT;
 48   }
 49 
 50   // Similar to logic in CmpPNode::sub()
 51 
 52   // Interfaces can't be trusted unless the subclass is an exact
 53   // interface (it can then only be a constant) or the subclass is an
 54   // exact array of interfaces (a newly allocated array of interfaces
 55   // for instance)
 56   if (superk && subk &&
 57       superk->is_loaded() && !superk->is_interface() &&
 58       subk->is_loaded() && (!subk->is_interface() || xsubk) &&
 59       (!superk->is_obj_array_klass() ||
 60        !superk->as_obj_array_klass()->base_element_klass()->is_interface()) &&
 61       (!subk->is_obj_array_klass() ||
 62        !subk->as_obj_array_klass()->base_element_klass()->is_interface() ||
 63        xsubk)) {
 64     bool unrelated_classes = false;
 65     if (superk->equals(subk)) {
 66       // skip
 67     } else if (superk->is_subtype_of(subk)) {
 68       // If the subclass is exact then the superclass is a subtype of
 69       // the subclass. Given they're no equals, that subtype check can
 70       // only fail.
 71       unrelated_classes = xsubk;
 72     } else if (subk->is_subtype_of(superk)) {
 73       // skip
 74     } else {
 75       // Neither class subtypes the other: they are unrelated and this
 76       // type check is known to fail.
 77       unrelated_classes = true;
 78     }
 79     if (unrelated_classes) {
 80       TypePtr::PTR jp = sub_t->is_ptr()->join_ptr(super_t->is_ptr()->_ptr);
 81       if (jp != TypePtr::Null && jp != TypePtr::BotPTR) {
 82         return TypeInt::CC_GT;
 83       }
 84     }
 85   }
 86 
 87   if (super_t->singleton()) {
 88     if (subk != NULL) {
 89       switch (Compile::current()->static_subtype_check(superk, subk)) {
 90       case Compile::SSC_always_false:
 91         return TypeInt::CC_GT;
 92       case Compile::SSC_always_true:
 93         return TypeInt::CC_EQ;
 94       case Compile::SSC_easy_test:
 95       case Compile::SSC_full_test:
 96         break;
 97       default:
 98         ShouldNotReachHere();
 99       }
100     }
101   }
102 
103   return bottom_type();
104 }
105 
106 Node *SubTypeCheckNode::Ideal(PhaseGVN* phase, bool can_reshape) {
107   Node* obj_or_subklass = in(ObjOrSubKlass);
108   Node* superklass = in(SuperKlass);
109 
110   if (obj_or_subklass == NULL ||
111       superklass == NULL) {
112     return NULL;
113   }
114 
115   const Type* sub_t = phase->type(obj_or_subklass);
116   const Type* super_t = phase->type(superklass);
117 
118   if (!super_t->isa_klassptr() ||
119       (!sub_t->isa_klassptr() && !sub_t->isa_oopptr())) {
120     return NULL;
121   }
122 
123   Node* addr = NULL;
124   if (obj_or_subklass->is_DecodeNKlass()) {
125     if (obj_or_subklass->in(1) != NULL &&
126         obj_or_subklass->in(1)->Opcode() == Op_LoadNKlass) {
127       addr = obj_or_subklass->in(1)->in(MemNode::Address);
128     }
129   } else if (obj_or_subklass->Opcode() == Op_LoadKlass) {
130     addr = obj_or_subklass->in(MemNode::Address);
131   }
132 
133   if (addr != NULL) {
134     intptr_t con = 0;
135     Node* obj = AddPNode::Ideal_base_and_offset(addr, phase, con);
136     if (con == oopDesc::klass_offset_in_bytes() && obj != NULL) {
137       assert(is_oop(phase, obj), "only for oop input");
138       set_req(ObjOrSubKlass, obj);
139       return this;
140     }
141   }
142 
143   // AllocateNode might have more accurate klass input
144   Node* allocated_klass = AllocateNode::Ideal_klass(obj_or_subklass, phase);
145   if (allocated_klass != NULL) {
146     assert(is_oop(phase, obj_or_subklass), "only for oop input");
147     set_req(ObjOrSubKlass, allocated_klass);
148     return this;
149   }
150 
151   // Verify that optimizing the subtype check to a simple code pattern
152   // when possible would not constant fold better
153   assert(verify(phase), "missing Value() optimization");
154 
155   return NULL;
156 }
157 
158 #ifdef ASSERT
159 bool SubTypeCheckNode::is_oop(PhaseGVN* phase, Node* n) {
160     const Type* t = phase->type(n);
161     if (!t->isa_oopptr() && t != Type::TOP) {
162       n->dump();
163       t->dump(); tty->cr();
164       return false;
165     }
166     return true;
167 }
168 
169 static Node* record_for_cleanup(Node* n, PhaseGVN* phase) {
170   if (phase->is_IterGVN()) {
171     phase->is_IterGVN()->_worklist.push(n); // record for cleanup
172   }
173   return n;
174 }
175 bool SubTypeCheckNode::verify_helper(PhaseGVN* phase, Node* subklass, const Type* cached_t) {
176   Node* cmp = phase->transform(new CmpPNode(subklass, in(SuperKlass)));
177   record_for_cleanup(cmp, phase);
178 
179   const Type* cmp_t = phase->type(cmp);
180   const Type* t = Value(phase);
181 
182   if (t == cmp_t ||
183       t != cached_t || // previous observations don't hold anymore
184       (cmp_t != TypeInt::CC_GT && cmp_t != TypeInt::CC_EQ)) {
185     return true;
186   } else {
187     t->dump(); tty->cr();
188     this->dump(2); tty->cr();
189     cmp_t->dump(); tty->cr();
190     subklass->dump(2); tty->cr();
191     tty->print_cr("==============================");
192     phase->C->root()->dump(9999);
193     return false;
194   }
195 }
196 
197 // Verify that optimizing the subtype check to a simple code pattern when possible would not constant fold better.
198 bool SubTypeCheckNode::verify(PhaseGVN* phase) {
199   Compile* C = phase->C;
200   Node* obj_or_subklass = in(ObjOrSubKlass);
201   Node* superklass = in(SuperKlass);
202 
203   const Type* sub_t = phase->type(obj_or_subklass);
204   const Type* super_t = phase->type(superklass);
205 
206   ciKlass* subk = sub_t->isa_klassptr() ? sub_t->is_klassptr()->klass() : sub_t->is_oopptr()->klass(); // can be NULL for bottom[]
207   ciKlass* superk = super_t->is_klassptr()->klass();
208 
209   if (super_t->singleton() && subk != NULL) {
210     Node* subklass = NULL;
211     if (sub_t->isa_oopptr()) {
212       Node* adr = phase->transform(new AddPNode(obj_or_subklass, obj_or_subklass, phase->MakeConX(oopDesc::klass_offset_in_bytes())));
213       subklass  = phase->transform(LoadKlassNode::make(*phase, NULL, C->immutable_memory(), adr, TypeInstPtr::KLASS));
214       record_for_cleanup(subklass, phase);
215     } else {
216       subklass = obj_or_subklass;
217     }
218 
219     const Type* cached_t = Value(phase); // cache the type to validate consistency
220     switch (C->static_subtype_check(superk, subk)) {
221       case Compile::SSC_easy_test: {
222         return verify_helper(phase, subklass, cached_t);
223       }
224       case Compile::SSC_full_test: {
225         Node* p1 = phase->transform(new AddPNode(superklass, superklass, phase->MakeConX(in_bytes(Klass::super_check_offset_offset()))));
226         Node* chk_off = phase->transform(new LoadINode(NULL, C->immutable_memory(), p1, phase->type(p1)->is_ptr(), TypeInt::INT, MemNode::unordered));
227         record_for_cleanup(chk_off, phase);
228 
229         int cacheoff_con = in_bytes(Klass::secondary_super_cache_offset());
230         bool might_be_cache = (phase->find_int_con(chk_off, cacheoff_con) == cacheoff_con);
231         if (!might_be_cache) {
232           Node* chk_off_X = chk_off;
233 #ifdef _LP64
234           chk_off_X = phase->transform(new ConvI2LNode(chk_off_X));
235 #endif
236           Node* p2 = phase->transform(new AddPNode(subklass, subklass, chk_off_X));
237           Node* nkls = phase->transform(LoadKlassNode::make(*phase, NULL, C->immutable_memory(), p2, phase->type(p2)->is_ptr(), TypeInstKlassPtr::OBJECT_OR_NULL));
238 
239           return verify_helper(phase, nkls, cached_t);
240         }
241         break;
242       }
243       case Compile::SSC_always_false:
244       case Compile::SSC_always_true:
245       default: {
246         break; // nothing to do
247       }
248     }
249   }
250 
251   return true;
252 }
253 #endif