1 /*
   2  * Copyright (c) 2003, 2019, 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 "classfile/symbolTable.hpp"
  27 #include "classfile/systemDictionaryShared.hpp"
  28 #include "classfile/verificationType.hpp"
  29 #include "classfile/verifier.hpp"
  30 #include "logging/log.hpp"
  31 #include "runtime/handles.inline.hpp"
  32 
  33 VerificationType VerificationType::from_tag(u1 tag) {
  34   switch (tag) {
  35     case ITEM_Top:     return bogus_type();
  36     case ITEM_Integer: return integer_type();
  37     case ITEM_Float:   return float_type();
  38     case ITEM_Double:  return double_type();
  39     case ITEM_Long:    return long_type();
  40     case ITEM_Null:    return null_type();
  41     default:
  42       ShouldNotReachHere();
  43       return bogus_type();
  44   }
  45 }
  46 
  47 bool VerificationType::resolve_and_check_assignability(InstanceKlass* klass, Symbol* name,
  48          Symbol* from_name, bool from_field_is_protected, bool from_is_array, bool from_is_object, TRAPS) {
  49   HandleMark hm(THREAD);
  50   Klass* this_class = SystemDictionary::resolve_or_fail(
  51       name, Handle(THREAD, klass->class_loader()),
  52       Handle(THREAD, klass->protection_domain()), true, CHECK_false);
  53   klass->class_loader_data()->record_dependency(this_class);
  54   if (log_is_enabled(Debug, class, resolve)) {
  55     Verifier::trace_class_resolution(this_class, klass);
  56   }
  57 
  58   if (this_class->access_flags().is_value_type()) return false;
  59   if (this_class->is_interface() && (!from_field_is_protected ||
  60       from_name != vmSymbols::java_lang_Object())) {
  61     // If we are not trying to access a protected field or method in
  62     // java.lang.Object then, for arrays, we only allow assignability
  63     // to interfaces java.lang.Cloneable and java.io.Serializable.
  64     // Otherwise, we treat interfaces as java.lang.Object.
  65     return !from_is_array ||
  66       this_class == SystemDictionary::Cloneable_klass() ||
  67       this_class == SystemDictionary::Serializable_klass();
  68   } else if (from_is_object) {
  69     Klass* from_class = SystemDictionary::resolve_or_fail(
  70         from_name, Handle(THREAD, klass->class_loader()),
  71         Handle(THREAD, klass->protection_domain()), true, CHECK_false);
  72     klass->class_loader_data()->record_dependency(from_class);
  73     if (log_is_enabled(Debug, class, resolve)) {
  74       Verifier::trace_class_resolution(from_class, klass);
  75     }
  76     return InstanceKlass::cast(from_class)->is_subclass_of(this_class);
  77   }
  78 
  79   return false;
  80 }
  81 
  82 bool VerificationType::is_reference_assignable_from(
  83     const VerificationType& from, ClassVerifier* context,
  84     bool from_field_is_protected, TRAPS) const {
  85   InstanceKlass* klass = context->current_class();
  86   if (from.is_null()) {
  87     // null is assignable to any reference
  88     return true;
  89   } else if (is_null()) {
  90     return false;
  91   } else if (name() == from.name()) {
  92     return true;
  93   } else if (is_object()) {
  94     // We need check the class hierarchy to check assignability
  95     if (name() == vmSymbols::java_lang_Object()) {
  96       // any object or array is assignable to java.lang.Object
  97       return true;
  98     }
  99 
 100     if (DumpSharedSpaces && SystemDictionaryShared::add_verification_constraint(klass,
 101               name(), from.name(), from_field_is_protected, from.is_array(),
 102               from.is_object())) {
 103       // If add_verification_constraint() returns true, the resolution/check should be
 104       // delayed until runtime.
 105       return true;
 106     }
 107 
 108     return resolve_and_check_assignability(klass, name(), from.name(),
 109           from_field_is_protected, from.is_array(), from.is_object(), THREAD);
 110   } else if (is_array() && from.is_array()) {
 111     VerificationType comp_this = get_component(context, CHECK_false);
 112     VerificationType comp_from = from.get_component(context, CHECK_false);
 113 
 114     // This code implements non-covariance between value type arrays and both
 115     // arrays of objects and arrays of interface types.  If covariance is
 116     // supported for value type arrays then this code should be removed.
 117     if (comp_from.is_valuetype() && !comp_this.is_null() && comp_this.is_reference()) {
 118       // An array of value types is not assignable to an array of java.lang.Objects.
 119       if (comp_this.name() == vmSymbols::java_lang_Object()) {
 120         return false;
 121       }
 122 
 123       // Need to load 'comp_this' to see if it is an interface.
 124       InstanceKlass* klass = context->current_class();
 125       {
 126         HandleMark hm(THREAD);
 127         Klass* comp_this_class = SystemDictionary::resolve_or_fail(
 128             comp_this.name(), Handle(THREAD, klass->class_loader()),
 129             Handle(THREAD, klass->protection_domain()), true, CHECK_false);
 130         klass->class_loader_data()->record_dependency(comp_this_class);
 131         if (log_is_enabled(Debug, class, resolve)) {
 132           Verifier::trace_class_resolution(comp_this_class, klass);
 133         }
 134         // An array of value types is not assignable to an array of interface types.
 135         if (comp_this_class->is_interface()) {
 136           return false;
 137         }
 138       }
 139     }
 140 
 141     if (!comp_this.is_bogus() && !comp_from.is_bogus()) {
 142       return comp_this.is_component_assignable_from(comp_from, context,
 143                                                     from_field_is_protected, THREAD);
 144     }
 145   }
 146   return false;
 147 }
 148 
 149 bool VerificationType::is_valuetype_assignable_from(const VerificationType& from) const {
 150   // Check that 'from' is not null, is a value type, and is the same value type.
 151   assert(is_valuetype(), "called with a non-valuetype type");
 152   assert(!is_null(), "valuetype is not null");
 153   assert(name() != vmSymbols::java_lang_Object(), "java.lang.Object is a value type?");
 154   return (!from.is_null() && from.is_valuetype() && name() == from.name());
 155 }
 156 
 157 bool VerificationType::is_ref_assignable_from_value_type(const VerificationType& from, ClassVerifier* context, TRAPS) const {
 158   assert(!from.is_null(), "Value type should not be null");
 159   if (!is_null() && (name()->is_same_fundamental_type(from.name()) ||
 160       name() == vmSymbols::java_lang_Object())) {
 161     return true;
 162   }
 163 
 164   // Need to load 'this' to see if it is an interface.
 165   InstanceKlass* klass = context->current_class();
 166   {
 167     HandleMark hm(THREAD);
 168     Klass* this_class = SystemDictionary::resolve_or_fail(
 169         name(), Handle(THREAD, klass->class_loader()),
 170         Handle(THREAD, klass->protection_domain()), true, CHECK_false);
 171     klass->class_loader_data()->record_dependency(this_class);
 172     if (log_is_enabled(Debug, class, resolve)) {
 173       Verifier::trace_class_resolution(this_class, klass);
 174     }
 175     return (this_class->is_interface());
 176   }
 177 }
 178 
 179 VerificationType VerificationType::get_component(ClassVerifier *context, TRAPS) const {
 180   assert(is_array() && name()->utf8_length() >= 2, "Must be a valid array");
 181   Symbol* component;
 182   switch (name()->char_at(1)) {
 183     case 'Z': return VerificationType(Boolean);
 184     case 'B': return VerificationType(Byte);
 185     case 'C': return VerificationType(Char);
 186     case 'S': return VerificationType(Short);
 187     case 'I': return VerificationType(Integer);
 188     case 'J': return VerificationType(Long);
 189     case 'F': return VerificationType(Float);
 190     case 'D': return VerificationType(Double);
 191     case '[':
 192       component = context->create_temporary_symbol(
 193         name(), 1, name()->utf8_length(),
 194         CHECK_(VerificationType::bogus_type()));
 195       return VerificationType::reference_type(component);
 196     case 'L':
 197       component = context->create_temporary_symbol(
 198         name(), 2, name()->utf8_length() - 1,
 199         CHECK_(VerificationType::bogus_type()));
 200       return VerificationType::reference_type(component);
 201     case 'Q':
 202       component = context->create_temporary_symbol(
 203         name(), 2, name()->utf8_length() - 1,
 204         CHECK_(VerificationType::bogus_type()));
 205       return VerificationType::valuetype_type(component);
 206     default:
 207       // Met an invalid type signature, e.g. [X
 208       return VerificationType::bogus_type();
 209   }
 210 }
 211 
 212 void VerificationType::print_on(outputStream* st) const {
 213   switch (_u._data) {
 214     case Bogus:            st->print("top"); break;
 215     case Category1:        st->print("category1"); break;
 216     case Category2:        st->print("category2"); break;
 217     case Category2_2nd:    st->print("category2_2nd"); break;
 218     case Boolean:          st->print("boolean"); break;
 219     case Byte:             st->print("byte"); break;
 220     case Short:            st->print("short"); break;
 221     case Char:             st->print("char"); break;
 222     case Integer:          st->print("integer"); break;
 223     case Float:            st->print("float"); break;
 224     case Long:             st->print("long"); break;
 225     case Double:           st->print("double"); break;
 226     case Long_2nd:         st->print("long_2nd"); break;
 227     case Double_2nd:       st->print("double_2nd"); break;
 228     case Null:             st->print("null"); break;
 229     case ReferenceQuery:   st->print("reference type"); break;
 230     case ValueTypeQuery:   st->print("value type"); break;
 231     case NonScalarQuery:   st->print("reference or value type"); break;
 232     case Category1Query:   st->print("category1 type"); break;
 233     case Category2Query:   st->print("category2 type"); break;
 234     case Category2_2ndQuery: st->print("category2_2nd type"); break;
 235     default:
 236       if (is_uninitialized_this()) {
 237         st->print("uninitializedThis");
 238       } else if (is_uninitialized()) {
 239         st->print("uninitialized %d", bci());
 240       } else if (is_valuetype()) {
 241         name()->print_Qvalue_on(st);
 242       } else {
 243         if (name() != NULL) {
 244           name()->print_value_on(st);
 245         } else {
 246           st->print_cr("NULL");
 247         }
 248       }
 249   }
 250 }
--- EOF ---