52                                       PackageEntry* pkg_entry,
  53                                       ModuleEntry* mod_entry,
  54                                       TRAPS) {
  55     return false;
  56   }
  57 
  58   static Klass* dump_time_resolve_super_or_fail(Symbol* child_name,
  59                                                 Symbol* class_name,
  60                                                 Handle class_loader,
  61                                                 Handle protection_domain,
  62                                                 bool is_superclass,
  63                                                 TRAPS) {
  64     return NULL;
  65   }
  66 
  67   static size_t dictionary_entry_size() {
  68     return sizeof(DictionaryEntry);
  69   }
  70 
  71   static void init_shared_dictionary_entry(Klass* k, DictionaryEntry* entry) {}

  72 
  73   static InstanceKlass* lookup_from_stream(Symbol* class_name,
  74                                            Handle class_loader,
  75                                            Handle protection_domain,
  76                                            const ClassFileStream* st,
  77                                            TRAPS) {
  78     return NULL;
  79   }
  80 
  81   // The (non-application) CDS implementation supports only classes in the boot
  82   // class loader, which ensures that the verification constraints are the same
  83   // during archive creation time and runtime. Thus we can do the constraint checks
  84   // entirely during archive creation time.
  85   static bool add_verification_constraint(Klass* k, Symbol* name,
  86                   Symbol* from_name, bool from_field_is_protected,
  87                   bool from_is_array, bool from_is_object) {return false;}
  88   static void finalize_verification_constraints() {}
  89   static void check_verification_constraints(InstanceKlass* klass,
  90                                               TRAPS) {}
  91 };

  52                                       PackageEntry* pkg_entry,
  53                                       ModuleEntry* mod_entry,
  54                                       TRAPS) {
  55     return false;
  56   }
  57 
  58   static Klass* dump_time_resolve_super_or_fail(Symbol* child_name,
  59                                                 Symbol* class_name,
  60                                                 Handle class_loader,
  61                                                 Handle protection_domain,
  62                                                 bool is_superclass,
  63                                                 TRAPS) {
  64     return NULL;
  65   }
  66 
  67   static size_t dictionary_entry_size() {
  68     return sizeof(DictionaryEntry);
  69   }
  70 
  71   static void init_shared_dictionary_entry(Klass* k, DictionaryEntry* entry) {}
  72   static bool is_builtin(DictionaryEntry* entry) { return true; }
  73 
  74   static InstanceKlass* lookup_from_stream(Symbol* class_name,
  75                                            Handle class_loader,
  76                                            Handle protection_domain,
  77                                            const ClassFileStream* st,
  78                                            TRAPS) {
  79     return NULL;
  80   }
  81 
  82   // The (non-application) CDS implementation supports only classes in the boot
  83   // class loader, which ensures that the verification constraints are the same
  84   // during archive creation time and runtime. Thus we can do the constraint checks
  85   // entirely during archive creation time.
  86   static bool add_verification_constraint(Klass* k, Symbol* name,
  87                   Symbol* from_name, bool from_field_is_protected,
  88                   bool from_is_array, bool from_is_object) {return false;}
  89   static void finalize_verification_constraints() {}
  90   static void check_verification_constraints(InstanceKlass* klass,
  91                                               TRAPS) {}
  92 };