< prev index next >

src/hotspot/share/classfile/systemDictionary.hpp

Print this page




 450     return &_well_known_klasses[id];
 451   }
 452   static void well_known_klasses_do(MetaspaceClosure* it);
 453 
 454   // Local definition for direct access to the private array:
 455   #define WK_KLASS(name) _well_known_klasses[SystemDictionary::WK_KLASS_ENUM_NAME(name)]
 456 
 457   static InstanceKlass* box_klass(BasicType t) {
 458     assert((uint)t < T_VOID+1, "range check");
 459     return check_klass(_box_klasses[t]);
 460   }
 461   static BasicType box_klass_type(Klass* k);  // inverse of box_klass
 462 
 463   // methods returning lazily loaded klasses
 464   // The corresponding method to load the class must be called before calling them.
 465   static InstanceKlass* abstract_ownable_synchronizer_klass() { return check_klass(_abstract_ownable_synchronizer_klass); }
 466 
 467   static void load_abstract_ownable_synchronizer_klass(TRAPS);
 468 
 469 protected:
 470   // Tells whether ClassLoader.loadClassInternal is present
 471   static bool has_loadClassInternal()       { return _has_loadClassInternal; }
 472 
 473   // Returns the class loader data to be used when looking up/updating the
 474   // system dictionary.
 475   static ClassLoaderData *class_loader_data(Handle class_loader) {
 476     return ClassLoaderData::class_loader_data(class_loader());
 477   }
 478 
 479 public:
 480   // Tells whether ClassLoader.checkPackageAccess is present
 481   static bool has_checkPackageAccess()      { return _has_checkPackageAccess; }
 482 
 483   static bool Parameter_klass_loaded()      { return WK_KLASS(reflect_Parameter_klass) != NULL; }
 484   static bool Class_klass_loaded()          { return WK_KLASS(Class_klass) != NULL; }
 485   static bool Cloneable_klass_loaded()      { return WK_KLASS(Cloneable_klass) != NULL; }
 486   static bool Object_klass_loaded()         { return WK_KLASS(Object_klass) != NULL; }
 487   static bool ClassLoader_klass_loaded()    { return WK_KLASS(ClassLoader_klass) != NULL; }
 488 
 489   // Returns java system loader
 490   static oop java_system_loader();
 491 
 492   // Returns java platform loader


 729   static void check_constraints(unsigned int hash,
 730                                 InstanceKlass* k, Handle loader,
 731                                 bool defining, TRAPS);
 732   static void update_dictionary(unsigned int d_hash,
 733                                 int p_index, unsigned int p_hash,
 734                                 InstanceKlass* k, Handle loader,
 735                                 TRAPS);
 736 
 737   // Variables holding commonly used klasses (preloaded)
 738   static InstanceKlass* _well_known_klasses[];
 739 
 740   // Lazily loaded klasses
 741   static InstanceKlass* volatile _abstract_ownable_synchronizer_klass;
 742 
 743   // table of box klasses (int_klass, etc.)
 744   static InstanceKlass* _box_klasses[T_VOID+1];
 745 
 746   static oop  _java_system_loader;
 747   static oop  _java_platform_loader;
 748 
 749   static bool _has_loadClassInternal;
 750   static bool _has_checkPackageAccess;
 751 };
 752 
 753 #endif // SHARE_VM_CLASSFILE_SYSTEMDICTIONARY_HPP


 450     return &_well_known_klasses[id];
 451   }
 452   static void well_known_klasses_do(MetaspaceClosure* it);
 453 
 454   // Local definition for direct access to the private array:
 455   #define WK_KLASS(name) _well_known_klasses[SystemDictionary::WK_KLASS_ENUM_NAME(name)]
 456 
 457   static InstanceKlass* box_klass(BasicType t) {
 458     assert((uint)t < T_VOID+1, "range check");
 459     return check_klass(_box_klasses[t]);
 460   }
 461   static BasicType box_klass_type(Klass* k);  // inverse of box_klass
 462 
 463   // methods returning lazily loaded klasses
 464   // The corresponding method to load the class must be called before calling them.
 465   static InstanceKlass* abstract_ownable_synchronizer_klass() { return check_klass(_abstract_ownable_synchronizer_klass); }
 466 
 467   static void load_abstract_ownable_synchronizer_klass(TRAPS);
 468 
 469 protected:



 470   // Returns the class loader data to be used when looking up/updating the
 471   // system dictionary.
 472   static ClassLoaderData *class_loader_data(Handle class_loader) {
 473     return ClassLoaderData::class_loader_data(class_loader());
 474   }
 475 
 476 public:
 477   // Tells whether ClassLoader.checkPackageAccess is present
 478   static bool has_checkPackageAccess()      { return _has_checkPackageAccess; }
 479 
 480   static bool Parameter_klass_loaded()      { return WK_KLASS(reflect_Parameter_klass) != NULL; }
 481   static bool Class_klass_loaded()          { return WK_KLASS(Class_klass) != NULL; }
 482   static bool Cloneable_klass_loaded()      { return WK_KLASS(Cloneable_klass) != NULL; }
 483   static bool Object_klass_loaded()         { return WK_KLASS(Object_klass) != NULL; }
 484   static bool ClassLoader_klass_loaded()    { return WK_KLASS(ClassLoader_klass) != NULL; }
 485 
 486   // Returns java system loader
 487   static oop java_system_loader();
 488 
 489   // Returns java platform loader


 726   static void check_constraints(unsigned int hash,
 727                                 InstanceKlass* k, Handle loader,
 728                                 bool defining, TRAPS);
 729   static void update_dictionary(unsigned int d_hash,
 730                                 int p_index, unsigned int p_hash,
 731                                 InstanceKlass* k, Handle loader,
 732                                 TRAPS);
 733 
 734   // Variables holding commonly used klasses (preloaded)
 735   static InstanceKlass* _well_known_klasses[];
 736 
 737   // Lazily loaded klasses
 738   static InstanceKlass* volatile _abstract_ownable_synchronizer_klass;
 739 
 740   // table of box klasses (int_klass, etc.)
 741   static InstanceKlass* _box_klasses[T_VOID+1];
 742 
 743   static oop  _java_system_loader;
 744   static oop  _java_platform_loader;
 745 

 746   static bool _has_checkPackageAccess;
 747 };
 748 
 749 #endif // SHARE_VM_CLASSFILE_SYSTEMDICTIONARY_HPP
< prev index next >