src/hotspot/share/classfile/systemDictionaryShared.hpp

rev 59477 : [mq]: cds_lambda

*** 103,112 ****
--- 103,113 ----
  #define UNREGISTERED_INDEX -9999
  
  class ClassFileStream;
  class DumpTimeSharedClassInfo;
  class DumpTimeSharedClassTable;
+ class LambdaProxyClassDictionary;
  class RunTimeSharedClassInfo;
  class RunTimeSharedDictionary;
  
  class SystemDictionaryShared: public SystemDictionary {
    friend class ExcludeDumpTimeSharedClasses;
*** 176,186 ****
                                               int shared_path_index,
                                               Handle url,
                                               TRAPS);
    static Handle get_shared_protection_domain(Handle class_loader,
                                               ModuleEntry* mod, TRAPS);
-   static Handle init_security_info(Handle class_loader, InstanceKlass* ik, PackageEntry* pkg_entry, TRAPS);
  
    static void atomic_set_array_index(objArrayOop array, int index, oop o) {
      // Benign race condition:  array.obj_at(index) may already be filled in.
      // The important thing here is that all threads pick up the same result.
      // It doesn't matter which racing thread wins, as long as only one
--- 177,186 ----
*** 211,227 ****
--- 211,232 ----
                                   TRAPS);
    static DumpTimeSharedClassInfo* find_or_allocate_info_for(InstanceKlass* k);
    static void write_dictionary(RunTimeSharedDictionary* dictionary,
                                 bool is_builtin,
                                 bool is_static_archive = true);
+   static void write_lambda_proxy_class_dictionary(LambdaProxyClassDictionary* dictionary);
    static bool is_jfr_event_class(InstanceKlass *k);
+   static bool is_registered_lambda_proxy_class(InstanceKlass* ik);
+   static bool is_in_shared_lambda_proxy_table(InstanceKlass* ik);
    static void warn_excluded(InstanceKlass* k, const char* reason);
    static bool should_be_excluded(InstanceKlass* k);
  
    DEBUG_ONLY(static bool _no_class_loading_should_happen;)
  
  public:
+   static bool is_hidden_lambda_proxy(InstanceKlass* ik);
+   static Handle init_security_info(Handle class_loader, InstanceKlass* ik, PackageEntry* pkg_entry, TRAPS);
    static InstanceKlass* find_builtin_class(Symbol* class_name);
  
    static const RunTimeSharedClassInfo* find_record(RunTimeSharedDictionary* static_dict,
                                                     RunTimeSharedDictionary* dynamic_dict,
                                                     Symbol* name);
*** 283,292 ****
--- 288,313 ----
                    bool from_is_array, bool from_is_object) NOT_CDS_RETURN_(false);
    static void check_verification_constraints(InstanceKlass* klass,
                                               TRAPS) NOT_CDS_RETURN;
    static void set_class_has_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN;
    static bool has_class_failed_verification(InstanceKlass* ik) NOT_CDS_RETURN_(false);
+   static void add_lambda_proxy_class(InstanceKlass* caller_ik,
+                                      InstanceKlass* lambda_ik,
+                                      Symbol* invoked_name,
+                                      Symbol* invoked_type,
+                                      Symbol* method_type,
+                                      Method* member_method,
+                                      Symbol* instantiated_method_type) NOT_CDS_RETURN;
+   static InstanceKlass* get_shared_lambda_proxy_class(InstanceKlass* caller_ik,
+                                                       Symbol* invoked_name,
+                                                       Symbol* invoked_type,
+                                                       Symbol* method_type,
+                                                       Method* member_method,
+                                                       Symbol* instantiated_method_type) NOT_CDS_RETURN_(NULL);
+   static InstanceKlass* get_shared_nest_host(InstanceKlass* lambda_ik) NOT_CDS_RETURN_(NULL);
+   static InstanceKlass* load_shared_lambda_proxy_class(InstanceKlass* lambda_ik,
+                                                        InstanceKlass* caller_ik, TRAPS) NOT_CDS_RETURN_(NULL);
    static bool check_linking_constraints(InstanceKlass* klass, TRAPS) NOT_CDS_RETURN_(false);
    static void record_linking_constraint(Symbol* name, InstanceKlass* klass,
                                       Handle loader1, Handle loader2, TRAPS) NOT_CDS_RETURN;
    static bool is_builtin(InstanceKlass* k) {
      return (k->shared_classpath_index() != UNREGISTERED_INDEX);
*** 295,304 ****
--- 316,326 ----
    static void validate_before_archiving(InstanceKlass* k);
    static bool is_excluded_class(InstanceKlass* k);
    static void dumptime_classes_do(class MetaspaceClosure* it);
    static size_t estimate_size_for_archive();
    static void write_to_archive(bool is_static_archive = true);
+   static void adjust_lambda_proxy_class_dictionary();
    static void serialize_dictionary_headers(class SerializeClosure* soc,
                                             bool is_static_archive = true);
    static void serialize_well_known_klasses(class SerializeClosure* soc);
    static void print() { return print_on(tty); }
    static void print_on(outputStream* st) NOT_CDS_RETURN;