< prev index next >

src/hotspot/share/classfile/verificationType.cpp

Print this page

  1 /*
  2  * Copyright (c) 2003, 2021, 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  *

 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   if (this_class->is_interface() && (!from_field_is_protected ||
 68       from_name != vmSymbols::java_lang_Object())) {
 69     // If we are not trying to access a protected field or method in
 70     // java.lang.Object then, for arrays, we only allow assignability
 71     // to interfaces java.lang.Cloneable and java.io.Serializable.
 72     // Otherwise, we treat interfaces as java.lang.Object.
 73     return !from_is_array ||
 74       this_class == vmClasses::Cloneable_klass() ||
 75       this_class == vmClasses::Serializable_klass();
 76   } else if (from_is_object) {
 77     Klass* from_class;
 78     if (klass->is_hidden() && klass->name() == from_name) {
 79       from_class = klass;
 80     } else {
 81       from_class = SystemDictionary::resolve_or_fail(
 82         from_name, Handle(THREAD, klass->class_loader()),
 83         Handle(THREAD, klass->protection_domain()), true, CHECK_false);
 84       if (log_is_enabled(Debug, class, resolve)) {
 85         Verifier::trace_class_resolution(from_class, klass);
 86       }
 87     }
 88     return from_class->is_subclass_of(this_class);
 89   }
 90 
 91   return false;

107     if (name() == vmSymbols::java_lang_Object()) {
108       // any object or array is assignable to java.lang.Object
109       return true;
110     }
111 
112     if (Arguments::is_dumping_archive()) {
113       if (SystemDictionaryShared::add_verification_constraint(klass,
114               name(), from.name(), from_field_is_protected, from.is_array(),
115               from.is_object())) {
116         // If add_verification_constraint() returns true, the resolution/check should be
117         // delayed until runtime.
118         return true;
119       }
120     }
121 
122     return resolve_and_check_assignability(klass, name(), from.name(),
123           from_field_is_protected, from.is_array(), from.is_object(), THREAD);
124   } else if (is_array() && from.is_array()) {
125     VerificationType comp_this = get_component(context);
126     VerificationType comp_from = from.get_component(context);





























127     if (!comp_this.is_bogus() && !comp_from.is_bogus()) {
128       return comp_this.is_component_assignable_from(comp_from, context,
129                                                     from_field_is_protected, THREAD);
130     }
131   }
132   return false;
133 }
134 







































135 VerificationType VerificationType::get_component(ClassVerifier *context) const {
136   assert(is_array() && name()->utf8_length() >= 2, "Must be a valid array");
137   SignatureStream ss(name(), false);
138   ss.skip_array_prefix(1);
139   switch (ss.type()) {
140     case T_BOOLEAN: return VerificationType(Boolean);
141     case T_BYTE:    return VerificationType(Byte);
142     case T_CHAR:    return VerificationType(Char);
143     case T_SHORT:   return VerificationType(Short);
144     case T_INT:     return VerificationType(Integer);
145     case T_LONG:    return VerificationType(Long);
146     case T_FLOAT:   return VerificationType(Float);
147     case T_DOUBLE:  return VerificationType(Double);
148     case T_ARRAY:
149     case T_OBJECT: {

150       guarantee(ss.is_reference(), "unchecked verifier input?");
151       Symbol* component = ss.as_symbol();
152       // Create another symbol to save as signature stream unreferences this symbol.
153       Symbol* component_copy = context->create_temporary_symbol(component);
154       assert(component_copy == component, "symbols don't match");
155       return VerificationType::reference_type(component_copy);


156    }
157    default:
158      // Met an invalid type signature, e.g. [X
159      return VerificationType::bogus_type();
160   }
161 }
162 
163 void VerificationType::print_on(outputStream* st) const {
164   switch (_u._data) {
165     case Bogus:            st->print("top"); break;
166     case Category1:        st->print("category1"); break;
167     case Category2:        st->print("category2"); break;
168     case Category2_2nd:    st->print("category2_2nd"); break;
169     case Boolean:          st->print("boolean"); break;
170     case Byte:             st->print("byte"); break;
171     case Short:            st->print("short"); break;
172     case Char:             st->print("char"); break;
173     case Integer:          st->print("integer"); break;
174     case Float:            st->print("float"); break;
175     case Long:             st->print("long"); break;
176     case Double:           st->print("double"); break;
177     case Long_2nd:         st->print("long_2nd"); break;
178     case Double_2nd:       st->print("double_2nd"); break;
179     case Null:             st->print("null"); break;
180     case ReferenceQuery:   st->print("reference type"); break;


181     case Category1Query:   st->print("category1 type"); break;
182     case Category2Query:   st->print("category2 type"); break;
183     case Category2_2ndQuery: st->print("category2_2nd type"); break;
184     default:
185       if (is_uninitialized_this()) {
186         st->print("uninitializedThis");
187       } else if (is_uninitialized()) {
188         st->print("uninitialized %d", bci());


189       } else {
190         if (name() != NULL) {
191           name()->print_value_on(st);
192         } else {
193           st->print_cr("NULL");
194         }
195       }
196   }
197 }

  1 /*
  2  * Copyright (c) 2003, 2022, 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  *

 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;

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 (Arguments::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 /*
136     // This code implements non-covariance between inline type arrays and both
137     // arrays of objects and arrays of interface types.  If covariance is
138     // supported for inline type arrays then this code should be removed.
139     if (comp_from.is_inline_type() && !comp_this.is_null() && comp_this.is_reference()) {
140       // An array of inline types is not assignable to an array of java.lang.Objects.
141       if (comp_this.name() == vmSymbols::java_lang_Object()) {
142         return false;
143       }
144 
145       // Need to load 'comp_this' to see if it is an interface.
146       InstanceKlass* klass = context->current_class();
147       {
148         HandleMark hm(THREAD);
149         Klass* comp_this_class = SystemDictionary::resolve_or_fail(
150             comp_this.name(), Handle(THREAD, klass->class_loader()),
151             Handle(THREAD, klass->protection_domain()), true, CHECK_false);
152         klass->class_loader_data()->record_dependency(comp_this_class);
153         if (log_is_enabled(Debug, class, resolve)) {
154           Verifier::trace_class_resolution(comp_this_class, klass);
155         }
156         // An array of inline types is not assignable to an array of interface types.
157         if (comp_this_class->is_interface()) {
158           return false;
159         }
160       }
161     }
162 */
163     if (!comp_this.is_bogus() && !comp_from.is_bogus()) {
164       return comp_this.is_component_assignable_from(comp_from, context,
165                                                     from_field_is_protected, THREAD);
166     }
167   }
168   return false;
169 }
170 
171 bool VerificationType::is_inline_type_assignable_from(const VerificationType& from) const {
172   // Check that 'from' is not null, is an inline type, and is the same inline type.
173   assert(is_inline_type(), "called with a non-inline type");
174   assert(!is_null(), "inline type is not null");
175   return (!from.is_null() && from.is_inline_type() && name() == from.name());
176 }
177 
178 bool VerificationType::is_ref_assignable_from_inline_type(const VerificationType& from, ClassVerifier* context, TRAPS) const {
179   assert(!from.is_null(), "Inline type should not be null");
180   if (!is_null() && (name()->is_same_fundamental_type(from.name()) ||
181       name() == vmSymbols::java_lang_Object())) {
182     return true;
183   }
184 
185   // Need to load 'this' to see if it is an interface or supertype.
186   InstanceKlass* klass = context->current_class();
187   {
188     HandleMark hm(THREAD);
189     Klass* this_class = SystemDictionary::resolve_or_fail(
190         name(), Handle(THREAD, klass->class_loader()),
191         Handle(THREAD, klass->protection_domain()), true, CHECK_false);
192     klass->class_loader_data()->record_dependency(this_class);
193     if (log_is_enabled(Debug, class, resolve)) {
194       Verifier::trace_class_resolution(this_class, klass);
195     }
196     if (this_class->is_interface()) {
197       return true;
198     } else {
199       Klass* from_class = SystemDictionary::resolve_or_fail(
200         from.name(), Handle(THREAD, klass->class_loader()),
201         Handle(THREAD, klass->protection_domain()), true, CHECK_false);
202       if (log_is_enabled(Debug, class, resolve)) {
203         Verifier::trace_class_resolution(from_class, klass);
204       }
205       return from_class->is_subclass_of(this_class);
206     }
207   }
208 }
209 
210 VerificationType VerificationType::get_component(ClassVerifier *context) const {
211   assert(is_array() && name()->utf8_length() >= 2, "Must be a valid array");
212   SignatureStream ss(name(), false);
213   ss.skip_array_prefix(1);
214   switch (ss.type()) {
215     case T_BOOLEAN: return VerificationType(Boolean);
216     case T_BYTE:    return VerificationType(Byte);
217     case T_CHAR:    return VerificationType(Char);
218     case T_SHORT:   return VerificationType(Short);
219     case T_INT:     return VerificationType(Integer);
220     case T_LONG:    return VerificationType(Long);
221     case T_FLOAT:   return VerificationType(Float);
222     case T_DOUBLE:  return VerificationType(Double);
223     case T_ARRAY:
224     case T_OBJECT:
225     case T_PRIMITIVE_OBJECT: {
226       guarantee(ss.is_reference(), "unchecked verifier input?");
227       Symbol* component = ss.as_symbol();
228       // Create another symbol to save as signature stream unreferences this symbol.
229       Symbol* component_copy = context->create_temporary_symbol(component);
230       assert(component_copy == component, "symbols don't match");
231       return (ss.type() == T_PRIMITIVE_OBJECT) ?
232         VerificationType::inline_type(component_copy) :
233         VerificationType::reference_type(component_copy);
234    }
235    default:
236      // Met an invalid type signature, e.g. [X
237      return VerificationType::bogus_type();
238   }
239 }
240 
241 void VerificationType::print_on(outputStream* st) const {
242   switch (_u._data) {
243     case Bogus:            st->print("top"); break;
244     case Category1:        st->print("category1"); break;
245     case Category2:        st->print("category2"); break;
246     case Category2_2nd:    st->print("category2_2nd"); break;
247     case Boolean:          st->print("boolean"); break;
248     case Byte:             st->print("byte"); break;
249     case Short:            st->print("short"); break;
250     case Char:             st->print("char"); break;
251     case Integer:          st->print("integer"); break;
252     case Float:            st->print("float"); break;
253     case Long:             st->print("long"); break;
254     case Double:           st->print("double"); break;
255     case Long_2nd:         st->print("long_2nd"); break;
256     case Double_2nd:       st->print("double_2nd"); break;
257     case Null:             st->print("null"); break;
258     case ReferenceQuery:   st->print("reference type"); break;
259     case InlineTypeQuery:  st->print("inline type"); break;
260     case NonScalarQuery:   st->print("reference or inline type"); break;
261     case Category1Query:   st->print("category1 type"); break;
262     case Category2Query:   st->print("category2 type"); break;
263     case Category2_2ndQuery: st->print("category2_2nd type"); break;
264     default:
265       if (is_uninitialized_this()) {
266         st->print("uninitializedThis");
267       } else if (is_uninitialized()) {
268         st->print("uninitialized %d", bci());
269       } else if (is_inline_type()) {
270         name()->print_Qvalue_on(st);
271       } else {
272         if (name() != NULL) {
273           name()->print_value_on(st);
274         } else {
275           st->print_cr("NULL");
276         }
277       }
278   }
279 }
< prev index next >