src/hotspot/share/classfile/systemDictionary.hpp

rev 58565 : 8238358: Implementation of JEP 371: Hidden Classes
Reviewed-by: duke
Contributed-by: mandy.chung@oracle.com, lois.foltan@oracle.com, david.holmes@oracle.com, harold.seigel@oracle.com, serguei.spitsyn@oracle.com, alex.buckley@oracle.com, jamsheed.c.m@oracle.com

*** 32,41 ****
--- 32,88 ----
  #include "runtime/mutexLocker.hpp"
  #include "runtime/reflectionUtils.hpp"
  #include "runtime/signature.hpp"
  #include "utilities/hashtable.hpp"
  
+ class ClassInstanceInfo : public StackObj {
+  private:
+   InstanceKlass* _dynamic_nest_host;
+   Handle _class_data;
+ 
+  public:
+   ClassInstanceInfo() {
+     _dynamic_nest_host = NULL;
+     _class_data = Handle();
+   }
+   ClassInstanceInfo(InstanceKlass* dynamic_nest_host, Handle class_data) {
+     _dynamic_nest_host = dynamic_nest_host;
+     _class_data = class_data;
+   }
+ 
+   InstanceKlass* dynamic_nest_host() const { return _dynamic_nest_host; }
+   Handle class_data() const { return _class_data; }
+   friend class ClassLoadInfo;
+ };
+ 
+ class ClassLoadInfo : public StackObj {
+  private:
+   Handle                 _protection_domain;
+   const InstanceKlass*   _unsafe_anonymous_host;
+   GrowableArray<Handle>* _cp_patches;
+   ClassInstanceInfo      _class_hidden_info;
+   bool                   _is_hidden;
+   bool                   _is_strong_hidden;
+   bool                   _can_access_vm_annotations;
+ 
+  public:
+   ClassLoadInfo();
+   ClassLoadInfo(Handle protection_domain);
+   ClassLoadInfo(Handle protection_domain, const InstanceKlass* unsafe_anonymous_host,
+                 GrowableArray<Handle>* cp_patches, InstanceKlass* dynamic_nest_host,
+                 Handle class_data, bool is_hidden, bool is_strong_hidden,
+                 bool can_access_vm_annotations);
+ 
+   Handle protection_domain()             const { return _protection_domain; }
+   const InstanceKlass* unsafe_anonymous_host() const { return _unsafe_anonymous_host; }
+   GrowableArray<Handle>* cp_patches()    const { return _cp_patches; }
+   const ClassInstanceInfo* class_hidden_info_ptr() const { return &_class_hidden_info; }
+   bool is_hidden()                       const { return _is_hidden; }
+   bool is_strong_hidden()                const { return _is_strong_hidden; }
+   bool can_access_vm_annotations()       const { return _can_access_vm_annotations; }
+ };
+ 
  // The dictionary in each ClassLoaderData stores all loaded classes, either
  // initiatied by its class loader or defined by its class loader:
  //
  //   class loader -> ClassLoaderData -> [class, protection domain set]
  //
*** 269,300 ****
                                                Handle class_loader,
                                                Handle protection_domain,
                                                bool is_superclass,
                                                TRAPS);
  
!   // Parse new stream. This won't update the dictionary or
!   // class hierarchy, simply parse the stream. Used by JVMTI RedefineClasses.
!   // Also used by Unsafe_DefineAnonymousClass
    static InstanceKlass* parse_stream(Symbol* class_name,
                                       Handle class_loader,
-                                      Handle protection_domain,
                                       ClassFileStream* st,
!                                      TRAPS) {
!     return parse_stream(class_name,
!                         class_loader,
!                         protection_domain,
!                         st,
!                         NULL, // unsafe_anonymous_host
!                         NULL, // cp_patches
!                         THREAD);
!   }
!   static InstanceKlass* parse_stream(Symbol* class_name,
!                                      Handle class_loader,
!                                      Handle protection_domain,
!                                      ClassFileStream* st,
!                                      const InstanceKlass* unsafe_anonymous_host,
!                                      GrowableArray<Handle>* cp_patches,
                                       TRAPS);
  
    // Resolve from stream (called by jni_DefineClass and JVM_DefineClass)
    static InstanceKlass* resolve_from_stream(Symbol* class_name,
                                              Handle class_loader,
--- 316,332 ----
                                                Handle class_loader,
                                                Handle protection_domain,
                                                bool is_superclass,
                                                TRAPS);
  
!   // Parse new stream. This won't update the dictionary or class
!   // hierarchy, simply parse the stream. Used by JVMTI RedefineClasses
!   // and by Unsafe_DefineAnonymousClass and jvm_lookup_define_class.
    static InstanceKlass* parse_stream(Symbol* class_name,
                                       Handle class_loader,
                                       ClassFileStream* st,
!                                      const ClassLoadInfo& cl_info,
                                       TRAPS);
  
    // Resolve from stream (called by jni_DefineClass and JVM_DefineClass)
    static InstanceKlass* resolve_from_stream(Symbol* class_name,
                                              Handle class_loader,
*** 528,537 ****
--- 560,574 ----
    static void delete_resolution_error(ConstantPool* pool);
    static Symbol* find_resolution_error(const constantPoolHandle& pool, int which,
                                         Symbol** message);
  
  
+   // Record a nest host resolution/validation error
+   static void add_nest_host_error(const constantPoolHandle& pool, int which,
+                                   const char* message);
+   static const char* find_nest_host_error(const constantPoolHandle& pool, int which);
+ 
    static ProtectionDomainCacheEntry* cache_get(Handle protection_domain);
  
   protected:
  
    enum Constants {