1 /*
  2  * Copyright (c) 2003, 2024, 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 "cds/cdsConfig.hpp"
 27 #include "classfile/symbolTable.hpp"
 28 #include "classfile/systemDictionary.hpp"
 29 #include "classfile/systemDictionaryShared.hpp"
 30 #include "classfile/verificationType.hpp"
 31 #include "classfile/verifier.hpp"
 32 #include "classfile/vmClasses.hpp"
 33 #include "classfile/vmSymbols.hpp"
 34 #include "logging/log.hpp"
 35 #include "oops/klass.inline.hpp"
 36 #include "runtime/handles.inline.hpp"
 37 
 38 VerificationType VerificationType::from_tag(u1 tag) {
 39   switch (tag) {
 40     case ITEM_Top:     return bogus_type();
 41     case ITEM_Integer: return integer_type();
 42     case ITEM_Float:   return float_type();
 43     case ITEM_Double:  return double_type();
 44     case ITEM_Long:    return long_type();
 45     case ITEM_Null:    return null_type();
 46     default:
 47       ShouldNotReachHere();
 48       return bogus_type();
 49   }
 50 }
 51 
 52 bool VerificationType::resolve_and_check_assignability(InstanceKlass* klass, Symbol* name,
 53          Symbol* from_name, bool from_field_is_protected, bool from_is_array, bool from_is_object, TRAPS) {
 54   HandleMark hm(THREAD);
 55   Klass* this_class;
 56   if (klass->is_hidden() && klass->name() == name) {
 57     this_class = klass;
 58   } else {
 59     this_class = SystemDictionary::resolve_or_fail(
 60       name, Handle(THREAD, klass->class_loader()),
 61       Handle(THREAD, klass->protection_domain()), true, CHECK_false);
 62     if (log_is_enabled(Debug, class, resolve)) {
 63       Verifier::trace_class_resolution(this_class, klass);
 64     }
 65   }
 66 
 67   // Need to do this check when called from CDS.
 68   // if (this_class->access_flags().is_primitive_class()) {
 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   //   return from_class == this_class;
 73   // }
 74   if (this_class->is_interface() && (!from_field_is_protected ||
 75       from_name != vmSymbols::java_lang_Object())) {
 76     // If we are not trying to access a protected field or method in
 77     // java.lang.Object then, for arrays, we only allow assignability
 78     // to interfaces java.lang.Cloneable and java.io.Serializable
 79     // Otherwise, we treat interfaces as java.lang.Object.
 80     return !from_is_array ||
 81       this_class == vmClasses::Cloneable_klass() ||
 82       this_class == vmClasses::Serializable_klass();
 83   } else if (from_is_object) {
 84     Klass* from_class;
 85     if (klass->is_hidden() && klass->name() == from_name) {
 86       from_class = klass;
 87     } else {
 88       from_class = SystemDictionary::resolve_or_fail(
 89         from_name, Handle(THREAD, klass->class_loader()),
 90         Handle(THREAD, klass->protection_domain()), true, CHECK_false);
 91       if (log_is_enabled(Debug, class, resolve)) {
 92         Verifier::trace_class_resolution(from_class, klass);
 93       }
 94     }
 95     return from_class->is_subclass_of(this_class);
 96   }
 97 
 98   return false;
 99 }
100 
101 bool VerificationType::is_reference_assignable_from(
102     const VerificationType& from, ClassVerifier* context,
103     bool from_field_is_protected, TRAPS) const {
104   InstanceKlass* klass = context->current_class();
105   if (from.is_null()) {
106     // null is assignable to any reference
107     return true;
108   } else if (is_null()) {
109     return false;
110   } else if (name() == from.name()) {
111     return true;
112   } else if (is_object()) {
113     // We need check the class hierarchy to check assignability
114     if (name() == vmSymbols::java_lang_Object()) {
115       // any object or array is assignable to java.lang.Object
116       return true;
117     }
118 
119     if (CDSConfig::is_dumping_archive()) {
120       if (SystemDictionaryShared::add_verification_constraint(klass,
121               name(), from.name(), from_field_is_protected, from.is_array(),
122               from.is_object())) {
123         // If add_verification_constraint() returns true, the resolution/check should be
124         // delayed until runtime.
125         return true;
126       }
127     }
128 
129     return resolve_and_check_assignability(klass, name(), from.name(),
130           from_field_is_protected, from.is_array(), from.is_object(), THREAD);
131   } else if (is_array() && from.is_array()) {
132     VerificationType comp_this = get_component(context);
133     VerificationType comp_from = from.get_component(context);
134 
135     if (!comp_this.is_bogus() && !comp_from.is_bogus()) {
136       return comp_this.is_component_assignable_from(comp_from, context,
137                                                     from_field_is_protected, THREAD);
138     }
139   }
140   return false;
141 }
142 
143 VerificationType VerificationType::get_component(ClassVerifier *context) const {
144   assert(is_array() && name()->utf8_length() >= 2, "Must be a valid array");
145   SignatureStream ss(name(), false);
146   ss.skip_array_prefix(1);
147   switch (ss.type()) {
148     case T_BOOLEAN: return VerificationType(Boolean);
149     case T_BYTE:    return VerificationType(Byte);
150     case T_CHAR:    return VerificationType(Char);
151     case T_SHORT:   return VerificationType(Short);
152     case T_INT:     return VerificationType(Integer);
153     case T_LONG:    return VerificationType(Long);
154     case T_FLOAT:   return VerificationType(Float);
155     case T_DOUBLE:  return VerificationType(Double);
156     case T_ARRAY:
157     case T_OBJECT: {
158       guarantee(ss.is_reference(), "unchecked verifier input?");
159       Symbol* component = ss.as_symbol();
160       // Create another symbol to save as signature stream unreferences this symbol.
161       Symbol* component_copy = context->create_temporary_symbol(component);
162       assert(component_copy == component, "symbols don't match");
163       return VerificationType::reference_type(component_copy);
164    }
165    default:
166      // Met an invalid type signature, e.g. [X
167      return VerificationType::bogus_type();
168   }
169 }
170 
171 void VerificationType::print_on(outputStream* st) const {
172   switch (_u._data) {
173     case Bogus:            st->print("top"); break;
174     case Category1:        st->print("category1"); break;
175     case Category2:        st->print("category2"); break;
176     case Category2_2nd:    st->print("category2_2nd"); break;
177     case Boolean:          st->print("boolean"); break;
178     case Byte:             st->print("byte"); break;
179     case Short:            st->print("short"); break;
180     case Char:             st->print("char"); break;
181     case Integer:          st->print("integer"); break;
182     case Float:            st->print("float"); break;
183     case Long:             st->print("long"); break;
184     case Double:           st->print("double"); break;
185     case Long_2nd:         st->print("long_2nd"); break;
186     case Double_2nd:       st->print("double_2nd"); break;
187     case Null:             st->print("null"); break;
188     case ReferenceQuery:   st->print("reference type"); break;
189     case Category1Query:   st->print("category1 type"); break;
190     case Category2Query:   st->print("category2 type"); break;
191     case Category2_2ndQuery: st->print("category2_2nd type"); break;
192     default:
193       if (is_uninitialized_this()) {
194         st->print("uninitializedThis");
195       } else if (is_uninitialized()) {
196         st->print("uninitialized %d", bci());
197       } else {
198         if (name() != nullptr) {
199           name()->print_value_on(st);
200         } else {
201           st->print_cr("null");
202         }
203       }
204   }
205 }