< prev index next >

src/hotspot/share/classfile/javaClasses.hpp

Print this page

 235   friend class VMStructs;
 236   friend class JVMCIVMStructs;
 237   friend class HeapShared;
 238 
 239  private:
 240 
 241   // The fake offsets are added by the class loader when java.lang.Class is loaded
 242 
 243   static int _klass_offset;
 244   static int _array_klass_offset;
 245 
 246   static int _oop_size_offset;
 247   static int _static_oop_field_count_offset;
 248 
 249   static int _protection_domain_offset;
 250   static int _init_lock_offset;
 251   static int _signers_offset;
 252   static int _class_loader_offset;
 253   static int _module_offset;
 254   static int _component_mirror_offset;

 255   static int _name_offset;
 256   static int _source_file_offset;
 257   static int _classData_offset;
 258   static int _classRedefinedCount_offset;
 259   static int _reflectionData_offset;
 260   static int _modifiers_offset;
 261   static int _is_primitive_offset;
 262   static int _raw_access_flags_offset;
 263 
 264   static bool _offsets_computed;
 265 
 266   static GrowableArray<Klass*>* _fixup_mirror_list;
 267   static GrowableArray<Klass*>* _fixup_module_field_list;
 268 
 269   static void set_init_lock(oop java_class, oop init_lock);
 270   static void set_protection_domain(oop java_class, oop protection_domain);
 271   static void set_class_loader(oop java_class, oop class_loader);
 272   static void set_component_mirror(oop java_class, oop comp_mirror);
 273   static void initialize_mirror_fields(InstanceKlass* ik, Handle mirror, Handle protection_domain,
 274                                        Handle classData, TRAPS);

 299   static InstanceKlass* as_InstanceKlass(oop java_class);
 300 
 301   static void set_klass(oop java_class, Klass* klass);
 302   static BasicType as_BasicType(oop java_class, Klass** reference_klass = nullptr);
 303   static Symbol* as_signature(oop java_class, bool intern_if_not_found);
 304   static void print_signature(oop java_class, outputStream *st);
 305   static const char* as_external_name(oop java_class);
 306   // Testing
 307   static bool is_instance(oop obj);
 308 
 309   static bool is_primitive(oop java_class);
 310   static void set_is_primitive(oop java_class);
 311   static BasicType primitive_type(oop java_class);
 312   static oop primitive_mirror(BasicType t);
 313   // JVM_NewArray support
 314   static Klass* array_klass_acquire(oop java_class);
 315   static void release_set_array_klass(oop java_class, Klass* klass);
 316   // compiler support for class operations
 317   static int klass_offset()                { CHECK_INIT(_klass_offset); }
 318   static int array_klass_offset()          { CHECK_INIT(_array_klass_offset); }

 319   // Support for classRedefinedCount field
 320   static int classRedefinedCount(oop the_class_mirror);
 321   static void set_classRedefinedCount(oop the_class_mirror, int value);
 322 
 323   // Support for embedded per-class oops
 324   static oop  protection_domain(oop java_class);
 325   static oop  init_lock(oop java_class);
 326   static void clear_init_lock(oop java_class) {
 327     set_init_lock(java_class, nullptr);
 328   }
 329   static oop  component_mirror(oop java_class);
 330   static int component_mirror_offset() { return _component_mirror_offset; }
 331   static objArrayOop signers(oop java_class);
 332   static oop  class_data(oop java_class);
 333   static void set_class_data(oop java_class, oop classData);
 334   static void set_reflection_data(oop java_class, oop reflection_data);
 335   static int reflection_data_offset() { return _reflectionData_offset; }
 336 
 337   static oop class_loader(oop java_class);
 338   static void set_module(oop java_class, oop module);

 813   static void set_signature(oop constructor, oop value);
 814   static void set_annotations(oop constructor, oop value);
 815   static void set_parameter_annotations(oop method, oop value);
 816 
 817   // Debugging
 818   friend class JavaClasses;
 819 };
 820 
 821 
 822 // Interface to java.lang.reflect.Field objects
 823 
 824 class java_lang_reflect_Field : public java_lang_reflect_AccessibleObject {
 825  private:
 826   // Note that to reduce dependencies on the JDK we compute these
 827   // offsets at run-time.
 828   static int _clazz_offset;
 829   static int _name_offset;
 830   static int _type_offset;
 831   static int _slot_offset;
 832   static int _modifiers_offset;
 833   static int _trusted_final_offset;
 834   static int _signature_offset;
 835   static int _annotations_offset;
 836 
 837   static void compute_offsets();
 838 
 839  public:
 840   static void serialize_offsets(SerializeClosure* f) NOT_CDS_RETURN;
 841 
 842   // Allocation
 843   static Handle create(TRAPS);
 844 
 845   // Accessors
 846   static oop clazz(oop reflect);
 847   static void set_clazz(oop reflect, oop value);
 848 
 849   static oop name(oop field);
 850   static void set_name(oop field, oop value);
 851 
 852   static oop type(oop field);
 853   static void set_type(oop field, oop value);
 854 
 855   static int slot(oop reflect);
 856   static void set_slot(oop reflect, int value);
 857 
 858   static int modifiers(oop field);
 859   static void set_modifiers(oop field, int value);
 860 
 861   static void set_trusted_final(oop field);
 862 
 863   static void set_signature(oop constructor, oop value);
 864   static void set_annotations(oop constructor, oop value);
 865 
 866   // Debugging
 867   friend class JavaClasses;
 868 };
 869 
 870 class java_lang_reflect_Parameter {
 871  private:
 872   // Note that to reduce dependencies on the JDK we compute these
 873   // offsets at run-time.
 874   static int _name_offset;
 875   static int _modifiers_offset;
 876   static int _index_offset;
 877   static int _executable_offset;
 878 
 879   static void compute_offsets();
 880 
 881  public:

 963 
 964   // Debugging
 965   friend class JavaClasses;
 966 };
 967 
 968 
 969 // Interface to java.lang primitive type boxing objects:
 970 //  - java.lang.Boolean
 971 //  - java.lang.Character
 972 //  - java.lang.Float
 973 //  - java.lang.Double
 974 //  - java.lang.Byte
 975 //  - java.lang.Short
 976 //  - java.lang.Integer
 977 //  - java.lang.Long
 978 
 979 // This could be separated out into 8 individual classes.
 980 
 981 class java_lang_boxing_object: AllStatic {
 982  private:
 983   static int _value_offset;
 984   static int _long_value_offset;
 985 
 986   static void compute_offsets();
 987   static oop initialize_and_allocate(BasicType type, TRAPS);
 988  public:
 989   // Allocation. Returns a boxed value, or null for invalid type.
 990   static oop create(BasicType type, jvalue* value, TRAPS);
 991   // Accessors. Returns the basic type being boxed, or T_ILLEGAL for invalid oop.
 992   static BasicType get_value(oop box, jvalue* value);
 993   static BasicType set_value(oop box, jvalue* value);
 994   static BasicType basic_type(oop box);
 995   static bool is_instance(oop box)                 { return basic_type(box) != T_ILLEGAL; }
 996   static bool is_instance(oop box, BasicType type) { return basic_type(box) == type; }
 997   static void print(oop box, outputStream* st)     { jvalue value;  print(get_value(box, &value), &value, st); }
 998   static void print(BasicType type, jvalue* value, outputStream* st);
 999 
1000   static int value_offset(BasicType type) {
1001     return is_double_word_type(type) ? _long_value_offset : _value_offset;


1002   }
1003 
1004   static void serialize_offsets(SerializeClosure* f);
1005 
1006   // Debugging
1007   friend class JavaClasses;
1008 };
1009 
1010 
1011 
1012 // Interface to java.lang.ref.Reference objects
1013 
1014 class java_lang_ref_Reference: AllStatic {
1015   static int _referent_offset;
1016   static int _queue_offset;
1017   static int _next_offset;
1018   static int _discovered_offset;
1019 
1020   static bool _offsets_initialized;
1021 

1343   static void       set_flags(oop mname, int flags);
1344 
1345   // Link through ResolvedMethodName field to get Method*
1346   static Method*        vmtarget(oop mname);
1347   static void       set_method(oop mname, oop method);
1348 
1349   static intptr_t       vmindex(oop mname);
1350   static void       set_vmindex(oop mname, intptr_t index);
1351 
1352   // Testers
1353   static bool is_subclass(Klass* klass) {
1354     return klass->is_subclass_of(vmClasses::MemberName_klass());
1355   }
1356   static bool is_instance(oop obj);
1357 
1358   static bool is_method(oop obj);
1359 
1360   // Relevant integer codes (keep these in synch. with MethodHandleNatives.Constants):
1361   enum {
1362     MN_IS_METHOD             = 0x00010000, // method (not constructor)
1363     MN_IS_CONSTRUCTOR        = 0x00020000, // constructor
1364     MN_IS_FIELD              = 0x00040000, // field
1365     MN_IS_TYPE               = 0x00080000, // nested type
1366     MN_CALLER_SENSITIVE      = 0x00100000, // @CallerSensitive annotation detected
1367     MN_TRUSTED_FINAL         = 0x00200000, // trusted final field
1368     MN_HIDDEN_MEMBER         = 0x00400000, // @Hidden annotation detected

1369     MN_REFERENCE_KIND_SHIFT  = 24, // refKind
1370     MN_REFERENCE_KIND_MASK   = 0x0F000000 >> MN_REFERENCE_KIND_SHIFT,


1371     MN_NESTMATE_CLASS        = 0x00000001,
1372     MN_HIDDEN_CLASS          = 0x00000002,
1373     MN_STRONG_LOADER_LINK    = 0x00000004,
1374     MN_ACCESS_VM_ANNOTATIONS = 0x00000008,
1375     // Lookup modes
1376     MN_MODULE_MODE           = 0x00000010,
1377     MN_UNCONDITIONAL_MODE    = 0x00000020,
1378     MN_TRUSTED_MODE          = -1
1379   };
1380 
1381   // Accessors for code generation:
1382   static int clazz_offset()   { CHECK_INIT(_clazz_offset); }
1383   static int type_offset()    { CHECK_INIT(_type_offset); }
1384   static int flags_offset()   { CHECK_INIT(_flags_offset); }
1385   static int method_offset()  { CHECK_INIT(_method_offset); }
1386   static int vmindex_offset() { CHECK_INIT(_vmindex_offset); }
1387 };
1388 
1389 
1390 // Interface to java.lang.invoke.MethodType objects

1854 class java_lang_Short_ShortCache : AllStatic {
1855  private:
1856   static int _static_cache_offset;
1857  public:
1858   static Symbol* symbol();
1859   static void compute_offsets(InstanceKlass* k);
1860   static objArrayOop  cache(InstanceKlass *k);
1861   static void serialize_offsets(SerializeClosure* f) NOT_CDS_RETURN;
1862 };
1863 
1864 class java_lang_Byte_ByteCache : AllStatic {
1865  private:
1866   static int _static_cache_offset;
1867  public:
1868   static Symbol* symbol();
1869   static void compute_offsets(InstanceKlass* k);
1870   static objArrayOop  cache(InstanceKlass *k);
1871   static void serialize_offsets(SerializeClosure* f) NOT_CDS_RETURN;
1872 };
1873 
1874 
1875 // Interface to java.lang.InternalError objects
1876 
1877 #define INTERNALERROR_INJECTED_FIELDS(macro)                      \
1878   macro(java_lang_InternalError, during_unsafe_access, bool_signature, false)
1879 
1880 class java_lang_InternalError : AllStatic {
1881  private:
1882   static int _during_unsafe_access_offset;
1883  public:
1884   static jboolean during_unsafe_access(oop internal_error);
1885   static void set_during_unsafe_access(oop internal_error);
1886   static void compute_offsets();
1887   static void serialize_offsets(SerializeClosure* f) NOT_CDS_RETURN;
1888 };
1889 
1890 // Use to declare fields that need to be injected into Java classes
1891 // for the JVM to use.  The name_index and signature_index are
1892 // declared in vmSymbols.  The may_be_java flag is used to declare
1893 // fields that might already exist in Java but should be injected if
1894 // they don't.  Otherwise the field is unconditionally injected and

 235   friend class VMStructs;
 236   friend class JVMCIVMStructs;
 237   friend class HeapShared;
 238 
 239  private:
 240 
 241   // The fake offsets are added by the class loader when java.lang.Class is loaded
 242 
 243   static int _klass_offset;
 244   static int _array_klass_offset;
 245 
 246   static int _oop_size_offset;
 247   static int _static_oop_field_count_offset;
 248 
 249   static int _protection_domain_offset;
 250   static int _init_lock_offset;
 251   static int _signers_offset;
 252   static int _class_loader_offset;
 253   static int _module_offset;
 254   static int _component_mirror_offset;
 255 
 256   static int _name_offset;
 257   static int _source_file_offset;
 258   static int _classData_offset;
 259   static int _classRedefinedCount_offset;
 260   static int _reflectionData_offset;
 261   static int _modifiers_offset;
 262   static int _is_primitive_offset;
 263   static int _raw_access_flags_offset;
 264 
 265   static bool _offsets_computed;
 266 
 267   static GrowableArray<Klass*>* _fixup_mirror_list;
 268   static GrowableArray<Klass*>* _fixup_module_field_list;
 269 
 270   static void set_init_lock(oop java_class, oop init_lock);
 271   static void set_protection_domain(oop java_class, oop protection_domain);
 272   static void set_class_loader(oop java_class, oop class_loader);
 273   static void set_component_mirror(oop java_class, oop comp_mirror);
 274   static void initialize_mirror_fields(InstanceKlass* ik, Handle mirror, Handle protection_domain,
 275                                        Handle classData, TRAPS);

 300   static InstanceKlass* as_InstanceKlass(oop java_class);
 301 
 302   static void set_klass(oop java_class, Klass* klass);
 303   static BasicType as_BasicType(oop java_class, Klass** reference_klass = nullptr);
 304   static Symbol* as_signature(oop java_class, bool intern_if_not_found);
 305   static void print_signature(oop java_class, outputStream *st);
 306   static const char* as_external_name(oop java_class);
 307   // Testing
 308   static bool is_instance(oop obj);
 309 
 310   static bool is_primitive(oop java_class);
 311   static void set_is_primitive(oop java_class);
 312   static BasicType primitive_type(oop java_class);
 313   static oop primitive_mirror(BasicType t);
 314   // JVM_NewArray support
 315   static Klass* array_klass_acquire(oop java_class);
 316   static void release_set_array_klass(oop java_class, Klass* klass);
 317   // compiler support for class operations
 318   static int klass_offset()                { CHECK_INIT(_klass_offset); }
 319   static int array_klass_offset()          { CHECK_INIT(_array_klass_offset); }
 320 
 321   // Support for classRedefinedCount field
 322   static int classRedefinedCount(oop the_class_mirror);
 323   static void set_classRedefinedCount(oop the_class_mirror, int value);
 324 
 325   // Support for embedded per-class oops
 326   static oop  protection_domain(oop java_class);
 327   static oop  init_lock(oop java_class);
 328   static void clear_init_lock(oop java_class) {
 329     set_init_lock(java_class, nullptr);
 330   }
 331   static oop  component_mirror(oop java_class);
 332   static int component_mirror_offset() { return _component_mirror_offset; }
 333   static objArrayOop signers(oop java_class);
 334   static oop  class_data(oop java_class);
 335   static void set_class_data(oop java_class, oop classData);
 336   static void set_reflection_data(oop java_class, oop reflection_data);
 337   static int reflection_data_offset() { return _reflectionData_offset; }
 338 
 339   static oop class_loader(oop java_class);
 340   static void set_module(oop java_class, oop module);

 815   static void set_signature(oop constructor, oop value);
 816   static void set_annotations(oop constructor, oop value);
 817   static void set_parameter_annotations(oop method, oop value);
 818 
 819   // Debugging
 820   friend class JavaClasses;
 821 };
 822 
 823 
 824 // Interface to java.lang.reflect.Field objects
 825 
 826 class java_lang_reflect_Field : public java_lang_reflect_AccessibleObject {
 827  private:
 828   // Note that to reduce dependencies on the JDK we compute these
 829   // offsets at run-time.
 830   static int _clazz_offset;
 831   static int _name_offset;
 832   static int _type_offset;
 833   static int _slot_offset;
 834   static int _modifiers_offset;
 835   static int _flags_offset;
 836   static int _signature_offset;
 837   static int _annotations_offset;
 838 
 839   static void compute_offsets();
 840 
 841  public:
 842   static void serialize_offsets(SerializeClosure* f) NOT_CDS_RETURN;
 843 
 844   // Allocation
 845   static Handle create(TRAPS);
 846 
 847   // Accessors
 848   static oop clazz(oop reflect);
 849   static void set_clazz(oop reflect, oop value);
 850 
 851   static oop name(oop field);
 852   static void set_name(oop field, oop value);
 853 
 854   static oop type(oop field);
 855   static void set_type(oop field, oop value);
 856 
 857   static int slot(oop reflect);
 858   static void set_slot(oop reflect, int value);
 859 
 860   static int modifiers(oop field);
 861   static void set_modifiers(oop field, int value);
 862 
 863   static void set_flags(oop field, int value);
 864 
 865   static void set_signature(oop constructor, oop value);
 866   static void set_annotations(oop constructor, oop value);
 867 
 868   // Debugging
 869   friend class JavaClasses;
 870 };
 871 
 872 class java_lang_reflect_Parameter {
 873  private:
 874   // Note that to reduce dependencies on the JDK we compute these
 875   // offsets at run-time.
 876   static int _name_offset;
 877   static int _modifiers_offset;
 878   static int _index_offset;
 879   static int _executable_offset;
 880 
 881   static void compute_offsets();
 882 
 883  public:

 965 
 966   // Debugging
 967   friend class JavaClasses;
 968 };
 969 
 970 
 971 // Interface to java.lang primitive type boxing objects:
 972 //  - java.lang.Boolean
 973 //  - java.lang.Character
 974 //  - java.lang.Float
 975 //  - java.lang.Double
 976 //  - java.lang.Byte
 977 //  - java.lang.Short
 978 //  - java.lang.Integer
 979 //  - java.lang.Long
 980 
 981 // This could be separated out into 8 individual classes.
 982 
 983 class java_lang_boxing_object: AllStatic {
 984  private:
 985   static int* _offsets;

 986 
 987   static void compute_offsets();
 988   static oop initialize_and_allocate(BasicType type, TRAPS);
 989  public:
 990   // Allocation. Returns a boxed value, or null for invalid type.
 991   static oop create(BasicType type, jvalue* value, TRAPS);
 992   // Accessors. Returns the basic type being boxed, or T_ILLEGAL for invalid oop.
 993   static BasicType get_value(oop box, jvalue* value);
 994   static BasicType set_value(oop box, jvalue* value);
 995   static BasicType basic_type(oop box);
 996   static bool is_instance(oop box)                 { return basic_type(box) != T_ILLEGAL; }
 997   static bool is_instance(oop box, BasicType type) { return basic_type(box) == type; }
 998   static void print(oop box, outputStream* st)     { jvalue value;  print(get_value(box, &value), &value, st); }
 999   static void print(BasicType type, jvalue* value, outputStream* st);
1000 
1001   static int value_offset(BasicType type) {
1002     assert(type >= T_BOOLEAN && type <= T_LONG, "BasicType out of range");
1003     assert(_offsets != nullptr, "Uninitialized offsets");
1004     return _offsets[type - T_BOOLEAN];
1005   }
1006 
1007   static void serialize_offsets(SerializeClosure* f);
1008 
1009   // Debugging
1010   friend class JavaClasses;
1011 };
1012 
1013 
1014 
1015 // Interface to java.lang.ref.Reference objects
1016 
1017 class java_lang_ref_Reference: AllStatic {
1018   static int _referent_offset;
1019   static int _queue_offset;
1020   static int _next_offset;
1021   static int _discovered_offset;
1022 
1023   static bool _offsets_initialized;
1024 

1346   static void       set_flags(oop mname, int flags);
1347 
1348   // Link through ResolvedMethodName field to get Method*
1349   static Method*        vmtarget(oop mname);
1350   static void       set_method(oop mname, oop method);
1351 
1352   static intptr_t       vmindex(oop mname);
1353   static void       set_vmindex(oop mname, intptr_t index);
1354 
1355   // Testers
1356   static bool is_subclass(Klass* klass) {
1357     return klass->is_subclass_of(vmClasses::MemberName_klass());
1358   }
1359   static bool is_instance(oop obj);
1360 
1361   static bool is_method(oop obj);
1362 
1363   // Relevant integer codes (keep these in synch. with MethodHandleNatives.Constants):
1364   enum {
1365     MN_IS_METHOD             = 0x00010000, // method (not constructor)
1366     MN_IS_OBJECT_CONSTRUCTOR = 0x00020000, // constructor
1367     MN_IS_FIELD              = 0x00040000, // field
1368     MN_IS_TYPE               = 0x00080000, // nested type
1369     MN_CALLER_SENSITIVE      = 0x00100000, // @CallerSensitive annotation detected
1370     MN_TRUSTED_FINAL         = 0x00200000, // trusted final field
1371     MN_HIDDEN_MEMBER         = 0x00400000, // @Hidden annotation detected
1372     MN_NULL_RESTRICTED_FIELD = 0x00800000, // null-restricted field
1373     MN_REFERENCE_KIND_SHIFT  = 24, // refKind
1374     MN_REFERENCE_KIND_MASK   = 0x0F000000 >> MN_REFERENCE_KIND_SHIFT, // 4 bits
1375     MN_LAYOUT_SHIFT          = 28, // field layout
1376     MN_LAYOUT_MASK           = 0x70000000 >> MN_LAYOUT_SHIFT, // 3 bits
1377     MN_NESTMATE_CLASS        = 0x00000001,
1378     MN_HIDDEN_CLASS          = 0x00000002,
1379     MN_STRONG_LOADER_LINK    = 0x00000004,
1380     MN_ACCESS_VM_ANNOTATIONS = 0x00000008,
1381     // Lookup modes
1382     MN_MODULE_MODE           = 0x00000010,
1383     MN_UNCONDITIONAL_MODE    = 0x00000020,
1384     MN_TRUSTED_MODE          = -1
1385   };
1386 
1387   // Accessors for code generation:
1388   static int clazz_offset()   { CHECK_INIT(_clazz_offset); }
1389   static int type_offset()    { CHECK_INIT(_type_offset); }
1390   static int flags_offset()   { CHECK_INIT(_flags_offset); }
1391   static int method_offset()  { CHECK_INIT(_method_offset); }
1392   static int vmindex_offset() { CHECK_INIT(_vmindex_offset); }
1393 };
1394 
1395 
1396 // Interface to java.lang.invoke.MethodType objects

1860 class java_lang_Short_ShortCache : AllStatic {
1861  private:
1862   static int _static_cache_offset;
1863  public:
1864   static Symbol* symbol();
1865   static void compute_offsets(InstanceKlass* k);
1866   static objArrayOop  cache(InstanceKlass *k);
1867   static void serialize_offsets(SerializeClosure* f) NOT_CDS_RETURN;
1868 };
1869 
1870 class java_lang_Byte_ByteCache : AllStatic {
1871  private:
1872   static int _static_cache_offset;
1873  public:
1874   static Symbol* symbol();
1875   static void compute_offsets(InstanceKlass* k);
1876   static objArrayOop  cache(InstanceKlass *k);
1877   static void serialize_offsets(SerializeClosure* f) NOT_CDS_RETURN;
1878 };
1879 

1880 // Interface to java.lang.InternalError objects
1881 
1882 #define INTERNALERROR_INJECTED_FIELDS(macro)                      \
1883   macro(java_lang_InternalError, during_unsafe_access, bool_signature, false)
1884 
1885 class java_lang_InternalError : AllStatic {
1886  private:
1887   static int _during_unsafe_access_offset;
1888  public:
1889   static jboolean during_unsafe_access(oop internal_error);
1890   static void set_during_unsafe_access(oop internal_error);
1891   static void compute_offsets();
1892   static void serialize_offsets(SerializeClosure* f) NOT_CDS_RETURN;
1893 };
1894 
1895 // Use to declare fields that need to be injected into Java classes
1896 // for the JVM to use.  The name_index and signature_index are
1897 // declared in vmSymbols.  The may_be_java flag is used to declare
1898 // fields that might already exist in Java but should be injected if
1899 // they don't.  Otherwise the field is unconditionally injected and
< prev index next >