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  *
 23  */
 24 
 25 #ifndef SHARE_CLASSFILE_VERIFICATIONTYPE_HPP
 26 #define SHARE_CLASSFILE_VERIFICATIONTYPE_HPP
 27 
 28 #include "oops/instanceKlass.hpp"
 29 #include "oops/oop.hpp"
 30 #include "oops/symbol.hpp"
 31 #include "runtime/handles.hpp"
 32 #include "runtime/signature.hpp"
 33 
 34 enum {
 35   // As specifed in the JVM spec
 36   ITEM_Top = 0,
 37   ITEM_Integer = 1,
 38   ITEM_Float = 2,
 39   ITEM_Double = 3,
 40   ITEM_Long = 4,
 41   ITEM_Null = 5,
 42   ITEM_UninitializedThis = 6,
 43   ITEM_Object = 7,
 44   ITEM_Uninitialized = 8,
 45   ITEM_Bogus = (uint)-1
 46 };
 47 
 48 class ClassVerifier;
 49 
 50 class VerificationType {
 51   private:
 52     // Least significant bits of _handle are always 0, so we use these as
 53     // the indicator that the _handle is valid.  Otherwise, the _data field
 54     // contains encoded data (as specified below).  Should the VM change
 55     // and the lower bits on oops aren't 0, the assert in the constructor
 56     // will catch this and we'll have to add a descriminator tag to this
 57     // structure.
 58     union {
 59       Symbol*   _sym;
 60       uintptr_t _data;
 61     } _u;
 62 
 63     enum {
 64       // These rest are not found in classfiles, but used by the verifier
 65       ITEM_Boolean = 9, ITEM_Byte, ITEM_Short, ITEM_Char,
 66       ITEM_Long_2nd, ITEM_Double_2nd
 67     };
 68 
 69     // Enum for the _data field
 70     enum {
 71       // Bottom three bits determine if the type is a reference, inline type,
 72       // primitive, uninitialized or a query-type.
 73       TypeMask           = 0x00000007,
 74 
 75       // Topmost types encoding
 76       Reference          = 0x0,        // _sym contains the name of an object
 77       Primitive          = 0x1,        // see below for primitive list
 78       Uninitialized      = 0x2,        // 0x00ffff00 contains bci
 79       TypeQuery          = 0x3,        // Meta-types used for category testing
 80       InlineType         = 0x4,        // _sym contains the name of an inline type
 81 
 82       // Utility flags
 83       ReferenceFlag      = 0x00,       // For reference query types
 84       Category1Flag      = 0x01,       // One-word values
 85       Category2Flag      = 0x02,       // First word of a two-word value
 86       Category2_2ndFlag  = 0x04,       // Second word of a two-word value
 87       InlineTypeFlag     = 0x08,       // For inline type query types
 88       NonScalarFlag      = 0x10,       // For either inline type or reference queries
 89 
 90       // special reference values
 91       Null               = 0x00000000, // A reference with a 0 sym is null
 92 
 93       // Primitives categories (the second byte determines the category)
 94       Category1          = (Category1Flag     << 1 * BitsPerByte) | Primitive,
 95       Category2          = (Category2Flag     << 1 * BitsPerByte) | Primitive,
 96       Category2_2nd      = (Category2_2ndFlag << 1 * BitsPerByte) | Primitive,
 97 
 98       // Primitive values (type descriminator stored in most-signifcant bytes)
 99       // Bogus needs the " | Primitive".  Else, is_reference(Bogus) returns TRUE.
100       Bogus              = (ITEM_Bogus      << 2 * BitsPerByte) | Primitive,
101       Boolean            = (ITEM_Boolean    << 2 * BitsPerByte) | Category1,
102       Byte               = (ITEM_Byte       << 2 * BitsPerByte) | Category1,
103       Short              = (ITEM_Short      << 2 * BitsPerByte) | Category1,
104       Char               = (ITEM_Char       << 2 * BitsPerByte) | Category1,
105       Integer            = (ITEM_Integer    << 2 * BitsPerByte) | Category1,
106       Float              = (ITEM_Float      << 2 * BitsPerByte) | Category1,
107       Long               = (ITEM_Long       << 2 * BitsPerByte) | Category2,
108       Double             = (ITEM_Double     << 2 * BitsPerByte) | Category2,
109       Long_2nd           = (ITEM_Long_2nd   << 2 * BitsPerByte) | Category2_2nd,
110       Double_2nd         = (ITEM_Double_2nd << 2 * BitsPerByte) | Category2_2nd,
111 
112       // Used by Uninitialized (second and third bytes hold the bci)
113       BciMask            = 0xffff << 1 * BitsPerByte,
114       BciForThis         = ((u2)-1),   // A bci of -1 is an Unintialized-This
115 
116       // Query values
117       ReferenceQuery     = (ReferenceFlag     << 1 * BitsPerByte) | TypeQuery,
118       Category1Query     = (Category1Flag     << 1 * BitsPerByte) | TypeQuery,
119       Category2Query     = (Category2Flag     << 1 * BitsPerByte) | TypeQuery,
120       Category2_2ndQuery = (Category2_2ndFlag << 1 * BitsPerByte) | TypeQuery,
121       InlineTypeQuery    = (InlineTypeFlag    << 1 * BitsPerByte) | TypeQuery,
122       NonScalarQuery     = (NonScalarFlag     << 1 * BitsPerByte) | TypeQuery
123     };
124 
125   VerificationType(uintptr_t raw_data) {
126     _u._data = raw_data;
127   }
128 
129  public:
130 
131   VerificationType() { *this = bogus_type(); }
132 
133   // Create verification types
134   static VerificationType bogus_type() { return VerificationType(Bogus); }
135   static VerificationType top_type() { return bogus_type(); } // alias
136   static VerificationType null_type() { return VerificationType(Null); }
137   static VerificationType integer_type() { return VerificationType(Integer); }
138   static VerificationType float_type() { return VerificationType(Float); }
139   static VerificationType long_type() { return VerificationType(Long); }
140   static VerificationType long2_type() { return VerificationType(Long_2nd); }
141   static VerificationType double_type() { return VerificationType(Double); }
142   static VerificationType boolean_type() { return VerificationType(Boolean); }
143   static VerificationType byte_type() { return VerificationType(Byte); }
144   static VerificationType char_type() { return VerificationType(Char); }
145   static VerificationType short_type() { return VerificationType(Short); }
146   static VerificationType double2_type()
147     { return VerificationType(Double_2nd); }
148 
149   // "check" types are used for queries.  A "check" type is not assignable
150   // to anything, but the specified types are assignable to a "check".  For
151   // example, any category1 primitive is assignable to category1_check and
152   // any reference is assignable to reference_check.
153   static VerificationType reference_check()
154     { return VerificationType(ReferenceQuery); }
155   static VerificationType inline_type_check()
156     { return VerificationType(InlineTypeQuery); }
157   static VerificationType category1_check()
158     { return VerificationType(Category1Query); }
159   static VerificationType category2_check()
160     { return VerificationType(Category2Query); }
161   static VerificationType category2_2nd_check()
162     { return VerificationType(Category2_2ndQuery); }
163   static VerificationType nonscalar_check()
164     { return VerificationType(NonScalarQuery); }
165 
166   // For reference types, store the actual Symbol
167   static VerificationType reference_type(Symbol* sh) {
168       assert(((uintptr_t)sh & TypeMask) == 0, "Symbols must be aligned");
169       // If the above assert fails in the future because oop* isn't aligned,
170       // then this type encoding system will have to change to have a tag value
171       // to discriminate between oops and primitives.
172       return VerificationType((uintptr_t)sh);
173   }
174   static VerificationType uninitialized_type(u2 bci)
175     { return VerificationType(bci << 1 * BitsPerByte | Uninitialized); }
176   static VerificationType uninitialized_this_type()
177     { return uninitialized_type(BciForThis); }
178 
179   // For inline types, store the actual Symbol* and set the 3rd bit.
180   // Provides a way for an inline type to be distinguished from a reference type.
181   static VerificationType inline_type(Symbol* sh) {
182       assert(((uintptr_t)sh & TypeMask) == 0, "Symbols must be aligned");
183       assert((uintptr_t)sh != 0, "Null is not a valid inline type");
184       // If the above assert fails in the future because oop* isn't aligned,
185       // then this type encoding system will have to change to have a tag value
186       // to discriminate between oops and primitives.
187       return VerificationType((uintptr_t)sh | InlineType);
188   }
189 
190   // Create based on u1 read from classfile
191   static VerificationType from_tag(u1 tag);
192 
193   bool is_bogus() const     { return (_u._data == Bogus); }
194   bool is_null() const      { return (_u._data == Null); }
195   bool is_boolean() const   { return (_u._data == Boolean); }
196   bool is_byte() const      { return (_u._data == Byte); }
197   bool is_char() const      { return (_u._data == Char); }
198   bool is_short() const     { return (_u._data == Short); }
199   bool is_integer() const   { return (_u._data == Integer); }
200   bool is_long() const      { return (_u._data == Long); }
201   bool is_float() const     { return (_u._data == Float); }
202   bool is_double() const    { return (_u._data == Double); }
203   bool is_long2() const     { return (_u._data == Long_2nd); }
204   bool is_double2() const   { return (_u._data == Double_2nd); }
205   bool is_reference() const { return (((_u._data & TypeMask) == Reference) && !is_inline_type_check()); }
206   bool is_inline_type() const { return ((_u._data & TypeMask) == InlineType); }
207   bool is_category1() const {
208     // This should return true for all one-word types, which are category1
209     // primitives, references (including uninitialized refs) and inline types.
210     // Though the 'query' types should technically return 'false' here, if we
211     // allow this to return true, we can perform the test using only
212     // 2 operations rather than 8 (3 masks, 3 compares and 2 logical 'ands').
213     // Since noone should call this on a query type anyway, this is ok.
214     assert(!is_check(), "Must not be a check type (wrong value returned)");
215     return ((_u._data & Category1) != Primitive);
216     // should only return false if it's a primitive, and the category1 flag
217     // is not set.
218   }
219   bool is_category2() const { return ((_u._data & Category2) == Category2); }
220   bool is_category2_2nd() const {
221     return ((_u._data & Category2_2nd) == Category2_2nd);
222   }
223   bool is_reference_check() const { return _u._data == ReferenceQuery; }
224   bool is_inline_type_check() const { return _u._data == InlineTypeQuery; }
225   bool is_nonscalar_check() const { return _u._data == NonScalarQuery; }
226   bool is_category1_check() const { return _u._data == Category1Query; }
227   bool is_category2_check() const { return _u._data == Category2Query; }
228   bool is_category2_2nd_check() const { return _u._data == Category2_2ndQuery; }
229   bool is_check() const { return (_u._data & TypeQuery) == TypeQuery; }
230 
231   bool is_x_array(char sig) const {
232     return is_null() || (is_array() && (name()->char_at(1) == sig));
233   }
234   bool is_int_array() const { return is_x_array(JVM_SIGNATURE_INT); }
235   bool is_byte_array() const { return is_x_array(JVM_SIGNATURE_BYTE); }
236   bool is_bool_array() const { return is_x_array(JVM_SIGNATURE_BOOLEAN); }
237   bool is_char_array() const { return is_x_array(JVM_SIGNATURE_CHAR); }
238   bool is_short_array() const { return is_x_array(JVM_SIGNATURE_SHORT); }
239   bool is_long_array() const { return is_x_array(JVM_SIGNATURE_LONG); }
240   bool is_float_array() const { return is_x_array(JVM_SIGNATURE_FLOAT); }
241   bool is_double_array() const { return is_x_array(JVM_SIGNATURE_DOUBLE); }
242   bool is_object_array() const { return is_x_array(JVM_SIGNATURE_CLASS); }
243   bool is_array_array() const { return is_x_array(JVM_SIGNATURE_ARRAY); }
244   bool is_inline_type_array() const { return is_x_array(JVM_SIGNATURE_INLINE_TYPE); }
245   bool is_reference_array() const
246     { return is_object_array() || is_array_array(); }
247   bool is_nonscalar_array() const
248     { return is_object_array() || is_array_array() || is_inline_type_array(); }
249   bool is_object() const
250     { return (is_reference() && !is_null() && name()->utf8_length() >= 1 &&
251               name()->char_at(0) != JVM_SIGNATURE_ARRAY); }
252   bool is_array() const
253     { return (is_reference() && !is_null() && name()->utf8_length() >= 2 &&
254               name()->char_at(0) == JVM_SIGNATURE_ARRAY); }
255   bool is_uninitialized() const
256     { return ((_u._data & Uninitialized) == Uninitialized); }
257   bool is_uninitialized_this() const
258     { return is_uninitialized() && bci() == BciForThis; }
259 
260   VerificationType to_category2_2nd() const {
261     assert(is_category2(), "Must be a double word");
262     return VerificationType(is_long() ? Long_2nd : Double_2nd);
263   }
264 
265   static VerificationType change_ref_to_inline_type(VerificationType ref) {
266     assert(ref.is_reference(), "Bad arg");
267     assert(!ref.is_null(), "Unexpected NULL");
268     return inline_type(ref.name());
269   }
270 
271   u2 bci() const {
272     assert(is_uninitialized(), "Must be uninitialized type");
273     return ((_u._data & BciMask) >> 1 * BitsPerByte);
274   }
275 
276   Symbol* name() const {
277     assert(!is_null() && (is_reference() || is_inline_type()), "Must be a non-null reference or an inline type");
278     return (is_reference() ? _u._sym : ((Symbol*)(_u._data & ~(uintptr_t)InlineType)));
279   }
280 
281   bool equals(const VerificationType& t) const {
282     return (_u._data == t._u._data ||
283             (((is_reference() && t.is_reference()) ||
284              (is_inline_type() && t.is_inline_type())) &&
285               !is_null() && !t.is_null() && name() == t.name()));
286 
287   }
288 
289   bool operator ==(const VerificationType& t) const {
290     return equals(t);
291   }
292 
293   bool operator !=(const VerificationType& t) const {
294     return !equals(t);
295   }
296 
297   // The whole point of this type system - check to see if one type
298   // is assignable to another.  Returns true if one can assign 'from' to
299   // this.
300   bool is_assignable_from(
301       const VerificationType& from, ClassVerifier* context,
302       bool from_field_is_protected, TRAPS) const {
303     if (equals(from) || is_bogus()) {
304       return true;
305     } else {
306       switch(_u._data) {
307         case Category1Query:
308           return from.is_category1();
309         case Category2Query:
310           return from.is_category2();
311         case Category2_2ndQuery:
312           return from.is_category2_2nd();
313         case ReferenceQuery:
314           return from.is_reference() || from.is_uninitialized();
315         case NonScalarQuery:
316           return from.is_reference() || from.is_uninitialized() ||
317                  from.is_inline_type();
318         case InlineTypeQuery:
319           return from.is_inline_type();
320         case Boolean:
321         case Byte:
322         case Char:
323         case Short:
324           // An int can be assigned to boolean, byte, char or short values.
325           return from.is_integer();
326         default:
327           if (is_inline_type()) {
328             return is_inline_type_assignable_from(from);
329           } else if (is_reference() && from.is_inline_type()) {
330             return is_ref_assignable_from_inline_type(from, context, THREAD);
331           } else if (is_reference() && from.is_reference()) {
332             return is_reference_assignable_from(from, context,
333                                                 from_field_is_protected,
334                                                 THREAD);
335           } else {
336             return false;
337           }
338       }
339     }
340   }
341 
342   // Check to see if one array component type is assignable to another.
343   // Same as is_assignable_from() except int primitives must be identical.
344   bool is_component_assignable_from(
345       const VerificationType& from, ClassVerifier* context,
346       bool from_field_is_protected, TRAPS) const {
347     if (equals(from) || is_bogus()) {
348       return true;
349     } else {
350       switch(_u._data) {
351         case Boolean:
352         case Byte:
353         case Char:
354         case Short:
355           return false;
356         default:
357           return is_assignable_from(from, context, from_field_is_protected, THREAD);
358       }
359     }
360   }
361 
362   VerificationType get_component(ClassVerifier* context) const;
363 
364   int dimensions() const {
365     assert(is_array(), "Must be an array");
366     int index = 0;
367     while (name()->char_at(index) == JVM_SIGNATURE_ARRAY) index++;
368     return index;
369   }
370 
371   void print_on(outputStream* st) const;
372 
373  private:
374 
375   bool is_reference_assignable_from(
376     const VerificationType&, ClassVerifier*, bool from_field_is_protected,
377     TRAPS) const;
378 
379   bool is_inline_type_assignable_from(const VerificationType& from) const;
380 
381   bool is_ref_assignable_from_inline_type(const VerificationType& from, ClassVerifier* context, TRAPS) const;
382 
383 
384  public:
385   static bool resolve_and_check_assignability(InstanceKlass* klass, Symbol* name,
386                                               Symbol* from_name, bool from_field_is_protected,
387                                               bool from_is_array, bool from_is_object,
388                                               TRAPS);
389 };
390 
391 #endif // SHARE_CLASSFILE_VERIFICATIONTYPE_HPP
--- EOF ---