< prev index next > src/hotspot/share/opto/subtypenode.cpp
Print this page
#include "opto/rootnode.hpp"
#include "opto/subnode.hpp"
#include "opto/subtypenode.hpp"
const Type* SubTypeCheckNode::sub(const Type* sub_t, const Type* super_t) const {
- const TypeKlassPtr* superk = super_t->isa_klassptr();
+ const TypeKlassPtr* super_klass_type = super_t->isa_klassptr();
assert(sub_t != Type::TOP && !TypePtr::NULL_PTR->higher_equal(sub_t), "should be not null");
- const TypeKlassPtr* subk = sub_t->isa_klassptr() ? sub_t->is_klassptr() : sub_t->is_oopptr()->as_klass_type();
+ const TypeKlassPtr* sub_klass_type = sub_t->isa_klassptr() ? sub_t->is_klassptr() : sub_t->is_oopptr()->as_klass_type();
// Oop can't be a subtype of abstract type that has no subclass.
- if (sub_t->isa_oopptr() && superk->isa_instklassptr() && superk->klass_is_exact()) {
- ciKlass* superklass = superk->exact_klass();
+ if (sub_t->isa_oopptr() && super_klass_type->isa_instklassptr() && super_klass_type->klass_is_exact()) {
+ ciKlass* superklass = super_klass_type->exact_klass();
if (!superklass->is_interface() && superklass->is_abstract() &&
!superklass->as_instance_klass()->has_subklass()) {
Compile::current()->dependencies()->assert_leaf_type(superklass);
return TypeInt::CC_GT;
}
}
- if (subk != nullptr) {
- switch (Compile::current()->static_subtype_check(superk, subk, false)) {
- case Compile::SSC_always_false:
- return TypeInt::CC_GT;
- case Compile::SSC_always_true:
- return TypeInt::CC_EQ;
- case Compile::SSC_easy_test:
- case Compile::SSC_full_test:
- break;
- default:
- ShouldNotReachHere();
+ // FIXME: shouldn't this be encoded in helper methods of the type system (maybe_java_subtype_of() etc.?)
+ // Similar to logic in CmpPNode::sub()
+ bool unrelated_classes = false;
+
+ // Handle inline type arrays
+ //
+ // The super klass can be an exact non-array klass constant which is known to be not flat in array (e.g. Object)
+ // while the sub klass could very well be flat in array:
+ //
+ // MyValue <: Object:exact
+ // flat in array not flat in array
+ //
+ // We therefore first cast the super klass to inexact (if the class is not final itself) and recompute the flat in
+ // array property for the super klass (all done in cast_to_exactness()) in order to check whether the sub klass is
+ // flat in array and the super klass is not flat in array. If that's the case, the classes must be unrelated.
+ const TypeKlassPtr* super_klass_type_for_flat_in_array = super_klass_type;
+ if (super_klass_type->isa_instklassptr()) {
+ // Only relevant for TypeInstKlassPtr. TypeAryKlassPtr will always be not flat in array.
+ super_klass_type_for_flat_in_array = super_klass_type->cast_to_exactness(false);
+ }
+
+ if (sub_klass_type->is_flat_in_array() && super_klass_type_for_flat_in_array->is_not_flat_in_array()) {
+ // The subtype is in flat arrays and the supertype is not in flat arrays and no subklass can be. Must be unrelated.
+ unrelated_classes = true;
+ } else if (sub_klass_type->is_not_flat() && super_klass_type->is_flat()) {
+ // The subtype is a non-flat array and the supertype is a flat array. Must be unrelated.
+ unrelated_classes = true;
+ } else if (sub_klass_type->is_not_null_free() && super_klass_type->is_null_free()) {
+ // The subtype is a nullable array and the supertype is null-free array. Must be unrelated.
+ unrelated_classes = true;
+ }
+ if (unrelated_classes) {
+ TypePtr::PTR jp = sub_t->is_ptr()->join_ptr(super_t->is_ptr()->_ptr);
+ if (jp != TypePtr::Null && jp != TypePtr::BotPTR) {
+ return TypeInt::CC_GT;
}
}
+ switch (Compile::current()->static_subtype_check(super_klass_type, sub_klass_type, false)) {
+ case Compile::SSC_always_false:
+ return TypeInt::CC_GT;
+ case Compile::SSC_always_true:
+ return TypeInt::CC_EQ;
+ case Compile::SSC_easy_test:
+ case Compile::SSC_full_test:
+ break;
+ default:
+ ShouldNotReachHere();
+ }
+
return bottom_type();
}
Node *SubTypeCheckNode::Ideal(PhaseGVN* phase, bool can_reshape) {
Node* obj_or_subklass = in(ObjOrSubKlass);
phase->is_IterGVN()->_worklist.push(n); // record for cleanup
}
return n;
}
bool SubTypeCheckNode::verify_helper(PhaseGVN* phase, Node* subklass, const Type* cached_t) {
- Node* cmp = phase->transform(new CmpPNode(subklass, in(SuperKlass)));
+ Node* cmp_orig = new CmpPNode(subklass, in(SuperKlass));
+ Node* cmp = phase->transform(cmp_orig);
record_for_cleanup(cmp, phase);
const Type* cmp_t = phase->type(cmp);
const Type* t = Value(phase);
(cmp_t != TypeInt::CC_GT && cmp_t != TypeInt::CC_EQ)) {
return true;
} else {
t->dump(); tty->cr();
this->dump(2); tty->cr();
+ tty->print_cr("VS.\n");
cmp_t->dump(); tty->cr();
- subklass->dump(2); tty->cr();
- tty->print_cr("==============================");
+ cmp_orig->dump(2); tty->cr();
+ tty->print_cr("==============================\n");
phase->C->root()->dump(9999);
return false;
}
}
Node* p1 = phase->transform(new AddPNode(superklass, superklass, phase->MakeConX(in_bytes(Klass::super_check_offset_offset()))));
Node* chk_off = phase->transform(new LoadINode(nullptr, C->immutable_memory(), p1, phase->type(p1)->is_ptr(), TypeInt::INT, MemNode::unordered));
record_for_cleanup(chk_off, phase);
int cacheoff_con = in_bytes(Klass::secondary_super_cache_offset());
- bool might_be_cache = (phase->find_int_con(chk_off, cacheoff_con) == cacheoff_con);
+ bool might_be_cache = phase->find_int_con(chk_off, cacheoff_con) == cacheoff_con;
if (!might_be_cache) {
Node* subklass = load_klass(phase);
Node* chk_off_X = chk_off;
#ifdef _LP64
chk_off_X = phase->transform(new ConvI2LNode(chk_off_X));
st->print(" profiled at:");
_method->print_short_name(st);
st->print(":%d", _bci);
}
}
- #endif
+ #endif
< prev index next >