< prev index next >

src/hotspot/share/cds/finalImageRecipes.hpp

Print this page

 25 #ifndef SHARE_CDS_FINALIMAGERECIPES_HPP
 26 #define SHARE_CDS_FINALIMAGERECIPES_HPP
 27 
 28 #include "oops/oopsHierarchy.hpp"
 29 #include "utilities/exceptions.hpp"
 30 
 31 class InstanceKlass;
 32 class Klass;
 33 
 34 template <typename T> class GrowableArray;
 35 template <typename T> class Array;
 36 
 37 // This class is used for transferring information from the AOTConfiguration file (aka the "preimage")
 38 // to the JVM that creates the AOTCache (aka the "final image").
 39 //   - The recipes are recorded when CDSConfig::is_dumping_preimage_static_archive() is true.
 40 //   - The recipes are applied when CDSConfig::is_dumping_final_static_archive() is true.
 41 // The following information are recorded:
 42 //   - The list of all classes that are stored in the AOTConfiguration file.
 43 //   - The list of all classes that require AOT resolution of invokedynamic call sites.
 44 class FinalImageRecipes {




 45   // A list of all the archived classes from the preimage. We want to transfer all of these
 46   // into the final image.
 47   Array<Klass*>* _all_klasses;
 48 
 49   // The classes who have resolved at least one indy CP entry during the training run.
 50   // _indy_cp_indices[i] is a list of all resolved CP entries for _indy_klasses[i].
 51   Array<InstanceKlass*>* _indy_klasses;
 52   Array<Array<int>*>*    _indy_cp_indices;





























 53 
 54   FinalImageRecipes() : _indy_klasses(nullptr), _indy_cp_indices(nullptr) {}
 55 
 56   void* operator new(size_t size) throw();
 57 
 58   // Called when dumping preimage
 59   void record_recipes_impl();



 60 
 61   // Called when dumping final image
 62   void apply_recipes_impl(TRAPS);
 63   void load_all_classes(TRAPS);
 64   void apply_recipes_for_invokedynamic(TRAPS);


 65 
 66 public:
 67   static void serialize(SerializeClosure* soc);
 68 
 69   // Called when dumping preimage


 70   static void record_recipes();
 71 
 72   // Called when dumping final image
 73   static void apply_recipes(TRAPS);
 74 };
 75 
 76 #endif // SHARE_CDS_FINALIMAGERECIPES_HPP

 25 #ifndef SHARE_CDS_FINALIMAGERECIPES_HPP
 26 #define SHARE_CDS_FINALIMAGERECIPES_HPP
 27 
 28 #include "oops/oopsHierarchy.hpp"
 29 #include "utilities/exceptions.hpp"
 30 
 31 class InstanceKlass;
 32 class Klass;
 33 
 34 template <typename T> class GrowableArray;
 35 template <typename T> class Array;
 36 
 37 // This class is used for transferring information from the AOTConfiguration file (aka the "preimage")
 38 // to the JVM that creates the AOTCache (aka the "final image").
 39 //   - The recipes are recorded when CDSConfig::is_dumping_preimage_static_archive() is true.
 40 //   - The recipes are applied when CDSConfig::is_dumping_final_static_archive() is true.
 41 // The following information are recorded:
 42 //   - The list of all classes that are stored in the AOTConfiguration file.
 43 //   - The list of all classes that require AOT resolution of invokedynamic call sites.
 44 class FinalImageRecipes {
 45   static constexpr int HAS_CLASS            = 0x1;
 46   static constexpr int HAS_FIELD_AND_METHOD = 0x2;
 47   static constexpr int HAS_INDY             = 0x4;
 48 
 49   // A list of all the archived classes from the preimage. We want to transfer all of these
 50   // into the final image.
 51   Array<Klass*>* _all_klasses;
 52 
 53   // For each klass k _all_klasses->at(i), _cp_recipes->at(i) lists all the {klass,field,method,indy}
 54   // cp indices that were resolved for k during the training run.
 55   Array<Array<int>*>* _cp_recipes;
 56   Array<int>* _cp_flags;
 57 
 58   // The RefectionData for  _reflect_klasses[i] should be initialized with _reflect_flags[i]
 59   Array<InstanceKlass*>* _reflect_klasses;
 60   Array<int>*            _reflect_flags;
 61 
 62   static GrowableArray<InstanceKlass*>* _tmp_reflect_klasses;
 63   static GrowableArray<int>* _tmp_reflect_flags;
 64 
 65   struct TmpDynamicProxyClassInfo {
 66     int _loader_type;
 67     int _access_flags;
 68     const char* _proxy_name;
 69     GrowableArray<Klass*>* _interfaces;
 70   };
 71 
 72   struct DynamicProxyClassInfo {
 73     int _loader_type;
 74     int _access_flags;
 75     const char* _proxy_name;
 76     Array<Klass*>* _interfaces;
 77   };
 78 
 79   Array<DynamicProxyClassInfo>* _dynamic_proxy_classes;
 80 
 81   static GrowableArray<TmpDynamicProxyClassInfo>* _tmp_dynamic_proxy_classes;
 82 
 83   FinalImageRecipes() : _all_klasses(nullptr), _cp_recipes(nullptr), _cp_flags(nullptr),
 84                         _reflect_klasses(nullptr), _reflect_flags(nullptr),
 85                         _dynamic_proxy_classes(nullptr) {}
 86 

 87 
 88   void* operator new(size_t size) throw();
 89 
 90   // Called when dumping preimage
 91   void record_all_classes();
 92   void record_recipes_for_constantpool();
 93   void record_recipes_for_reflection_data();
 94   void record_recipes_for_dynamic_proxies();
 95 
 96   // Called when dumping final image
 97   void apply_recipes_impl(TRAPS);
 98   void load_all_classes(TRAPS);
 99   void apply_recipes_for_constantpool(JavaThread* current);
100   void apply_recipes_for_reflection_data(JavaThread* current);
101   void apply_recipes_for_dynamic_proxies(TRAPS);
102 
103 public:
104   static void serialize(SerializeClosure* soc);
105 
106   // Called when dumping preimage
107   static void add_dynamic_proxy_class(oop loader, const char* proxy_name, objArrayOop interfaces, int access_flags);
108   static void add_reflection_data_flags(InstanceKlass* ik, TRAPS);
109   static void record_recipes();
110 
111   // Called when dumping final image
112   static void apply_recipes(TRAPS);
113 };
114 
115 #endif // SHARE_CDS_FINALIMAGERECIPES_HPP
< prev index next >