1 /*
   2  * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "jvm.h"
  27 #include "aot/aotLoader.hpp"
  28 #include "classfile/classFileParser.hpp"
  29 #include "classfile/classFileStream.hpp"
  30 #include "classfile/classLoader.hpp"
  31 #include "classfile/classLoaderData.inline.hpp"
  32 #include "classfile/javaClasses.hpp"
  33 #include "classfile/moduleEntry.hpp"
  34 #include "classfile/systemDictionary.hpp"
  35 #include "classfile/systemDictionaryShared.hpp"
  36 #include "classfile/verifier.hpp"
  37 #include "classfile/vmSymbols.hpp"
  38 #include "code/dependencyContext.hpp"
  39 #include "compiler/compileBroker.hpp"
  40 #include "gc/shared/collectedHeap.inline.hpp"
  41 #include "interpreter/oopMapCache.hpp"
  42 #include "interpreter/rewriter.hpp"
  43 #include "jvmtifiles/jvmti.h"
  44 #include "logging/log.hpp"
  45 #include "logging/logMessage.hpp"
  46 #include "logging/logStream.hpp"
  47 #include "memory/allocation.inline.hpp"
  48 #include "memory/heapInspection.hpp"
  49 #include "memory/iterator.inline.hpp"
  50 #include "memory/metadataFactory.hpp"
  51 #include "memory/metaspaceClosure.hpp"
  52 #include "memory/metaspaceShared.hpp"
  53 #include "memory/oopFactory.hpp"
  54 #include "memory/resourceArea.hpp"
  55 #include "oops/fieldStreams.hpp"
  56 #include "oops/instanceClassLoaderKlass.hpp"
  57 #include "oops/instanceKlass.inline.hpp"
  58 #include "oops/instanceMirrorKlass.hpp"
  59 #include "oops/instanceOop.hpp"
  60 #include "oops/klass.inline.hpp"
  61 #include "oops/method.hpp"
  62 #include "oops/oop.inline.hpp"
  63 #include "oops/symbol.hpp"
  64 #include "prims/jvmtiExport.hpp"
  65 #include "prims/jvmtiRedefineClasses.hpp"
  66 #include "prims/jvmtiThreadState.hpp"
  67 #include "prims/methodComparator.hpp"
  68 #include "runtime/atomic.hpp"
  69 #include "runtime/fieldDescriptor.inline.hpp"
  70 #include "runtime/handles.inline.hpp"
  71 #include "runtime/javaCalls.hpp"
  72 #include "runtime/mutexLocker.hpp"
  73 #include "runtime/orderAccess.hpp"
  74 #include "runtime/thread.inline.hpp"
  75 #include "services/classLoadingService.hpp"
  76 #include "services/threadService.hpp"
  77 #include "utilities/dtrace.hpp"
  78 #include "utilities/macros.hpp"
  79 #include "utilities/stringUtils.hpp"
  80 #ifdef COMPILER1
  81 #include "c1/c1_Compiler.hpp"
  82 #endif
  83 #if INCLUDE_JFR
  84 #include "jfr/jfrEvents.hpp"
  85 #endif
  86 
  87 
  88 #ifdef DTRACE_ENABLED
  89 
  90 
  91 #define HOTSPOT_CLASS_INITIALIZATION_required HOTSPOT_CLASS_INITIALIZATION_REQUIRED
  92 #define HOTSPOT_CLASS_INITIALIZATION_recursive HOTSPOT_CLASS_INITIALIZATION_RECURSIVE
  93 #define HOTSPOT_CLASS_INITIALIZATION_concurrent HOTSPOT_CLASS_INITIALIZATION_CONCURRENT
  94 #define HOTSPOT_CLASS_INITIALIZATION_erroneous HOTSPOT_CLASS_INITIALIZATION_ERRONEOUS
  95 #define HOTSPOT_CLASS_INITIALIZATION_super__failed HOTSPOT_CLASS_INITIALIZATION_SUPER_FAILED
  96 #define HOTSPOT_CLASS_INITIALIZATION_clinit HOTSPOT_CLASS_INITIALIZATION_CLINIT
  97 #define HOTSPOT_CLASS_INITIALIZATION_error HOTSPOT_CLASS_INITIALIZATION_ERROR
  98 #define HOTSPOT_CLASS_INITIALIZATION_end HOTSPOT_CLASS_INITIALIZATION_END
  99 #define DTRACE_CLASSINIT_PROBE(type, thread_type)                \
 100   {                                                              \
 101     char* data = NULL;                                           \
 102     int len = 0;                                                 \
 103     Symbol* clss_name = name();                                  \
 104     if (clss_name != NULL) {                                     \
 105       data = (char*)clss_name->bytes();                          \
 106       len = clss_name->utf8_length();                            \
 107     }                                                            \
 108     HOTSPOT_CLASS_INITIALIZATION_##type(                         \
 109       data, len, (void*)class_loader(), thread_type);            \
 110   }
 111 
 112 #define DTRACE_CLASSINIT_PROBE_WAIT(type, thread_type, wait)     \
 113   {                                                              \
 114     char* data = NULL;                                           \
 115     int len = 0;                                                 \
 116     Symbol* clss_name = name();                                  \
 117     if (clss_name != NULL) {                                     \
 118       data = (char*)clss_name->bytes();                          \
 119       len = clss_name->utf8_length();                            \
 120     }                                                            \
 121     HOTSPOT_CLASS_INITIALIZATION_##type(                         \
 122       data, len, (void*)class_loader(), thread_type, wait);      \
 123   }
 124 
 125 #else //  ndef DTRACE_ENABLED
 126 
 127 #define DTRACE_CLASSINIT_PROBE(type, thread_type)
 128 #define DTRACE_CLASSINIT_PROBE_WAIT(type, thread_type, wait)
 129 
 130 #endif //  ndef DTRACE_ENABLED
 131 
 132 static inline bool is_class_loader(const Symbol* class_name,
 133                                    const ClassFileParser& parser) {
 134   assert(class_name != NULL, "invariant");
 135 
 136   if (class_name == vmSymbols::java_lang_ClassLoader()) {
 137     return true;
 138   }
 139 
 140   if (SystemDictionary::ClassLoader_klass_loaded()) {
 141     const Klass* const super_klass = parser.super_klass();
 142     if (super_klass != NULL) {
 143       if (super_klass->is_subtype_of(SystemDictionary::ClassLoader_klass())) {
 144         return true;
 145       }
 146     }
 147   }
 148   return false;
 149 }
 150 
 151 // called to verify that k is a member of this nest
 152 bool InstanceKlass::has_nest_member(InstanceKlass* k, TRAPS) const {
 153   if (_nest_members == NULL || _nest_members == Universe::the_empty_short_array()) {
 154     if (log_is_enabled(Trace, class, nestmates)) {
 155       ResourceMark rm(THREAD);
 156       log_trace(class, nestmates)("Checked nest membership of %s in non-nest-host class %s",
 157                                   k->external_name(), this->external_name());
 158     }
 159     return false;
 160   }
 161 
 162   if (log_is_enabled(Trace, class, nestmates)) {
 163     ResourceMark rm(THREAD);
 164     log_trace(class, nestmates)("Checking nest membership of %s in %s",
 165                                 k->external_name(), this->external_name());
 166   }
 167 
 168   // Check names first and if they match then check actual klass. This avoids
 169   // resolving anything unnecessarily.
 170   for (int i = 0; i < _nest_members->length(); i++) {
 171     int cp_index = _nest_members->at(i);
 172     Symbol* name = _constants->klass_name_at(cp_index);
 173     if (name == k->name()) {
 174       log_trace(class, nestmates)("- Found it at nest_members[%d] => cp[%d]", i, cp_index);
 175 
 176       // names match so check actual klass - this may trigger class loading if
 177       // it doesn't match (but that should be impossible)
 178       Klass* k2 = _constants->klass_at(cp_index, CHECK_false);
 179       if (k2 == k) {
 180         log_trace(class, nestmates)("- class is listed as a nest member");
 181         return true;
 182       } else {
 183         // same name but different klass!
 184         log_trace(class, nestmates)(" - klass comparison failed!");
 185         // can't have different classes for the same name, so we're done
 186         return false;
 187       }
 188     }
 189   }
 190   log_trace(class, nestmates)("- class is NOT a nest member!");
 191   return false;
 192 }
 193 
 194 // Return nest-host class, resolving, validating and saving it if needed.
 195 // In cases where this is called from a thread that can not do classloading
 196 // (such as a native JIT thread) then we simply return NULL, which in turn
 197 // causes the access check to return false. Such code will retry the access
 198 // from a more suitable environment later.
 199 InstanceKlass* InstanceKlass::nest_host(Symbol* validationException, TRAPS) {
 200   InstanceKlass* nest_host_k = _nest_host;
 201   if (nest_host_k == NULL) {
 202     // need to resolve and save our nest-host class. This could be attempted
 203     // concurrently but as the result is idempotent and we don't use the class
 204     // then we do not need any synchronization beyond what is implicitly used
 205     // during class loading.
 206     if (_nest_host_index != 0) { // we have a real nest_host
 207       // Before trying to resolve check if we're in a suitable context
 208       if (!THREAD->can_call_java() && !_constants->tag_at(_nest_host_index).is_klass()) {
 209         if (log_is_enabled(Trace, class, nestmates)) {
 210           ResourceMark rm(THREAD);
 211           log_trace(class, nestmates)("Rejected resolution of nest-host of %s in unsuitable thread",
 212                                       this->external_name());
 213         }
 214         return NULL;
 215       }
 216 
 217       if (log_is_enabled(Trace, class, nestmates)) {
 218         ResourceMark rm(THREAD);
 219         log_trace(class, nestmates)("Resolving nest-host of %s using cp entry for %s",
 220                                     this->external_name(),
 221                                     _constants->klass_name_at(_nest_host_index)->as_C_string());
 222       }
 223 
 224       Klass* k = _constants->klass_at(_nest_host_index, THREAD);
 225       if (HAS_PENDING_EXCEPTION) {
 226         Handle exc_h = Handle(THREAD, PENDING_EXCEPTION);
 227         if (exc_h->is_a(SystemDictionary::NoClassDefFoundError_klass())) {
 228           // throw a new CDNFE with the original as its cause, and a clear msg
 229           ResourceMark rm(THREAD);
 230           char buf[200];
 231           CLEAR_PENDING_EXCEPTION;
 232           jio_snprintf(buf, sizeof(buf),
 233                        "Unable to load nest-host class (%s) of %s",
 234                        _constants->klass_name_at(_nest_host_index)->as_C_string(),
 235                        this->external_name());
 236           log_trace(class, nestmates)("%s - NoClassDefFoundError", buf);
 237           THROW_MSG_CAUSE_NULL(vmSymbols::java_lang_NoClassDefFoundError(), buf, exc_h);
 238         }
 239         // All other exceptions pass through (OOME, StackOverflowError, LinkageErrors etc).
 240         return NULL;
 241       }
 242 
 243       // A valid nest-host is an instance class in the current package that lists this
 244       // class as a nest member. If any of these conditions are not met we post the
 245       // requested exception type (if any) and return NULL
 246 
 247       const char* error = NULL;
 248 
 249       // JVMS 5.4.4 indicates package check comes first
 250       if (is_same_class_package(k)) {
 251 
 252         // Now check actual membership. We can't be a member if our "host" is
 253         // not an instance class.
 254         if (k->is_instance_klass()) {
 255           nest_host_k = InstanceKlass::cast(k);
 256 
 257           bool is_member = nest_host_k->has_nest_member(this, CHECK_NULL);
 258           if (is_member) {
 259             // save resolved nest-host value
 260             _nest_host = nest_host_k;
 261 
 262             if (log_is_enabled(Trace, class, nestmates)) {
 263               ResourceMark rm(THREAD);
 264               log_trace(class, nestmates)("Resolved nest-host of %s to %s",
 265                                           this->external_name(), k->external_name());
 266             }
 267             return nest_host_k;
 268           }
 269         }
 270         error = "current type is not listed as a nest member";
 271       } else {
 272         error = "types are in different packages";
 273       }
 274 
 275       if (log_is_enabled(Trace, class, nestmates)) {
 276         ResourceMark rm(THREAD);
 277         log_trace(class, nestmates)("Type %s is not a nest member of resolved type %s: %s",
 278                                     this->external_name(),
 279                                     k->external_name(),
 280                                     error);
 281       }
 282 
 283       if (validationException != NULL) {
 284         ResourceMark rm(THREAD);
 285         Exceptions::fthrow(THREAD_AND_LOCATION,
 286                            validationException,
 287                            "Type %s is not a nest member of %s: %s",
 288                            this->external_name(),
 289                            k->external_name(),
 290                            error
 291                            );
 292       }
 293       return NULL;
 294     } else {
 295       if (log_is_enabled(Trace, class, nestmates)) {
 296         ResourceMark rm(THREAD);
 297         log_trace(class, nestmates)("Type %s is not part of a nest: setting nest-host to self",
 298                                     this->external_name());
 299       }
 300       // save resolved nest-host value
 301       return (_nest_host = this);
 302     }
 303   }
 304   return nest_host_k;
 305 }
 306 
 307 // check if 'this' and k are nestmates (same nest_host), or k is our nest_host,
 308 // or we are k's nest_host - all of which is covered by comparing the two
 309 // resolved_nest_hosts
 310 bool InstanceKlass::has_nestmate_access_to(InstanceKlass* k, TRAPS) {
 311 
 312   assert(this != k, "this should be handled by higher-level code");
 313 
 314   // Per JVMS 5.4.4 we first resolve and validate the current class, then
 315   // the target class k. Resolution exceptions will be passed on by upper
 316   // layers. IncompatibleClassChangeErrors from membership validation failures
 317   // will also be passed through.
 318 
 319   Symbol* icce = vmSymbols::java_lang_IncompatibleClassChangeError();
 320   InstanceKlass* cur_host = nest_host(icce, CHECK_false);
 321   if (cur_host == NULL) {
 322     return false;
 323   }
 324 
 325   Klass* k_nest_host = k->nest_host(icce, CHECK_false);
 326   if (k_nest_host == NULL) {
 327     return false;
 328   }
 329 
 330   bool access = (cur_host == k_nest_host);
 331 
 332   if (log_is_enabled(Trace, class, nestmates)) {
 333     ResourceMark rm(THREAD);
 334     log_trace(class, nestmates)("Class %s does %shave nestmate access to %s",
 335                                 this->external_name(),
 336                                 access ? "" : "NOT ",
 337                                 k->external_name());
 338   }
 339 
 340   return access;
 341 }
 342 
 343 InstanceKlass* InstanceKlass::allocate_instance_klass(const ClassFileParser& parser, TRAPS) {
 344   const int size = InstanceKlass::size(parser.vtable_size(),
 345                                        parser.itable_size(),
 346                                        nonstatic_oop_map_size(parser.total_oop_map_count()),
 347                                        parser.is_interface(),
 348                                        parser.is_unsafe_anonymous(),
 349                                        should_store_fingerprint(parser.is_unsafe_anonymous()));
 350 
 351   const Symbol* const class_name = parser.class_name();
 352   assert(class_name != NULL, "invariant");
 353   ClassLoaderData* loader_data = parser.loader_data();
 354   assert(loader_data != NULL, "invariant");
 355 
 356   InstanceKlass* ik;
 357 
 358   // Allocation
 359   if (REF_NONE == parser.reference_type()) {
 360     if (class_name == vmSymbols::java_lang_Class()) {
 361       // mirror
 362       ik = new (loader_data, size, THREAD) InstanceMirrorKlass(parser);
 363     }
 364     else if (is_class_loader(class_name, parser)) {
 365       // class loader
 366       ik = new (loader_data, size, THREAD) InstanceClassLoaderKlass(parser);
 367     } else {
 368       // normal
 369       ik = new (loader_data, size, THREAD) InstanceKlass(parser, InstanceKlass::_misc_kind_other);
 370     }
 371   } else {
 372     // reference
 373     ik = new (loader_data, size, THREAD) InstanceRefKlass(parser);
 374   }
 375 
 376   // Check for pending exception before adding to the loader data and incrementing
 377   // class count.  Can get OOM here.
 378   if (HAS_PENDING_EXCEPTION) {
 379     return NULL;
 380   }
 381 
 382   return ik;
 383 }
 384 
 385 
 386 // copy method ordering from resource area to Metaspace
 387 void InstanceKlass::copy_method_ordering(const intArray* m, TRAPS) {
 388   if (m != NULL) {
 389     // allocate a new array and copy contents (memcpy?)
 390     _method_ordering = MetadataFactory::new_array<int>(class_loader_data(), m->length(), CHECK);
 391     for (int i = 0; i < m->length(); i++) {
 392       _method_ordering->at_put(i, m->at(i));
 393     }
 394   } else {
 395     _method_ordering = Universe::the_empty_int_array();
 396   }
 397 }
 398 
 399 // create a new array of vtable_indices for default methods
 400 Array<int>* InstanceKlass::create_new_default_vtable_indices(int len, TRAPS) {
 401   Array<int>* vtable_indices = MetadataFactory::new_array<int>(class_loader_data(), len, CHECK_NULL);
 402   assert(default_vtable_indices() == NULL, "only create once");
 403   set_default_vtable_indices(vtable_indices);
 404   return vtable_indices;
 405 }
 406 
 407 InstanceKlass::InstanceKlass(const ClassFileParser& parser, unsigned kind, KlassID id) :
 408   Klass(id),
 409   _nest_members(NULL),
 410   _nest_host_index(0),
 411   _nest_host(NULL),
 412   _static_field_size(parser.static_field_size()),
 413   _nonstatic_oop_map_size(nonstatic_oop_map_size(parser.total_oop_map_count())),
 414   _itable_len(parser.itable_size()),
 415   _reference_type(parser.reference_type()) {
 416     set_vtable_length(parser.vtable_size());
 417     set_kind(kind);
 418     set_access_flags(parser.access_flags());
 419     set_is_unsafe_anonymous(parser.is_unsafe_anonymous());
 420     set_layout_helper(Klass::instance_layout_helper(parser.layout_size(),
 421                                                     false));
 422 
 423     assert(NULL == _methods, "underlying memory not zeroed?");
 424     assert(is_instance_klass(), "is layout incorrect?");
 425     assert(size_helper() == parser.layout_size(), "incorrect size_helper?");
 426 }
 427 
 428 void InstanceKlass::deallocate_methods(ClassLoaderData* loader_data,
 429                                        Array<Method*>* methods) {
 430   if (methods != NULL && methods != Universe::the_empty_method_array() &&
 431       !methods->is_shared()) {
 432     for (int i = 0; i < methods->length(); i++) {
 433       Method* method = methods->at(i);
 434       if (method == NULL) continue;  // maybe null if error processing
 435       // Only want to delete methods that are not executing for RedefineClasses.
 436       // The previous version will point to them so they're not totally dangling
 437       assert (!method->on_stack(), "shouldn't be called with methods on stack");
 438       MetadataFactory::free_metadata(loader_data, method);
 439     }
 440     MetadataFactory::free_array<Method*>(loader_data, methods);
 441   }
 442 }
 443 
 444 void InstanceKlass::deallocate_interfaces(ClassLoaderData* loader_data,
 445                                           const Klass* super_klass,
 446                                           Array<InstanceKlass*>* local_interfaces,
 447                                           Array<InstanceKlass*>* transitive_interfaces) {
 448   // Only deallocate transitive interfaces if not empty, same as super class
 449   // or same as local interfaces.  See code in parseClassFile.
 450   Array<InstanceKlass*>* ti = transitive_interfaces;
 451   if (ti != Universe::the_empty_instance_klass_array() && ti != local_interfaces) {
 452     // check that the interfaces don't come from super class
 453     Array<InstanceKlass*>* sti = (super_klass == NULL) ? NULL :
 454                     InstanceKlass::cast(super_klass)->transitive_interfaces();
 455     if (ti != sti && ti != NULL && !ti->is_shared()) {
 456       MetadataFactory::free_array<InstanceKlass*>(loader_data, ti);
 457     }
 458   }
 459 
 460   // local interfaces can be empty
 461   if (local_interfaces != Universe::the_empty_instance_klass_array() &&
 462       local_interfaces != NULL && !local_interfaces->is_shared()) {
 463     MetadataFactory::free_array<InstanceKlass*>(loader_data, local_interfaces);
 464   }
 465 }
 466 
 467 // This function deallocates the metadata and C heap pointers that the
 468 // InstanceKlass points to.
 469 void InstanceKlass::deallocate_contents(ClassLoaderData* loader_data) {
 470 
 471   // Orphan the mirror first, CMS thinks it's still live.
 472   if (java_mirror() != NULL) {
 473     java_lang_Class::set_klass(java_mirror(), NULL);
 474   }
 475 
 476   // Also remove mirror from handles
 477   loader_data->remove_handle(_java_mirror);
 478 
 479   // Need to take this class off the class loader data list.
 480   loader_data->remove_class(this);
 481 
 482   // The array_klass for this class is created later, after error handling.
 483   // For class redefinition, we keep the original class so this scratch class
 484   // doesn't have an array class.  Either way, assert that there is nothing
 485   // to deallocate.
 486   assert(array_klasses() == NULL, "array classes shouldn't be created for this class yet");
 487 
 488   // Release C heap allocated data that this might point to, which includes
 489   // reference counting symbol names.
 490   release_C_heap_structures();
 491 
 492   deallocate_methods(loader_data, methods());
 493   set_methods(NULL);
 494 
 495   if (method_ordering() != NULL &&
 496       method_ordering() != Universe::the_empty_int_array() &&
 497       !method_ordering()->is_shared()) {
 498     MetadataFactory::free_array<int>(loader_data, method_ordering());
 499   }
 500   set_method_ordering(NULL);
 501 
 502   // default methods can be empty
 503   if (default_methods() != NULL &&
 504       default_methods() != Universe::the_empty_method_array() &&
 505       !default_methods()->is_shared()) {
 506     MetadataFactory::free_array<Method*>(loader_data, default_methods());
 507   }
 508   // Do NOT deallocate the default methods, they are owned by superinterfaces.
 509   set_default_methods(NULL);
 510 
 511   // default methods vtable indices can be empty
 512   if (default_vtable_indices() != NULL &&
 513       !default_vtable_indices()->is_shared()) {
 514     MetadataFactory::free_array<int>(loader_data, default_vtable_indices());
 515   }
 516   set_default_vtable_indices(NULL);
 517 
 518 
 519   // This array is in Klass, but remove it with the InstanceKlass since
 520   // this place would be the only caller and it can share memory with transitive
 521   // interfaces.
 522   if (secondary_supers() != NULL &&
 523       secondary_supers() != Universe::the_empty_klass_array() &&
 524       // see comments in compute_secondary_supers about the following cast
 525       (address)(secondary_supers()) != (address)(transitive_interfaces()) &&
 526       !secondary_supers()->is_shared()) {
 527     MetadataFactory::free_array<Klass*>(loader_data, secondary_supers());
 528   }
 529   set_secondary_supers(NULL);
 530 
 531   deallocate_interfaces(loader_data, super(), local_interfaces(), transitive_interfaces());
 532   set_transitive_interfaces(NULL);
 533   set_local_interfaces(NULL);
 534 
 535   if (fields() != NULL && !fields()->is_shared()) {
 536     MetadataFactory::free_array<jushort>(loader_data, fields());
 537   }
 538   set_fields(NULL, 0);
 539 
 540   // If a method from a redefined class is using this constant pool, don't
 541   // delete it, yet.  The new class's previous version will point to this.
 542   if (constants() != NULL) {
 543     assert (!constants()->on_stack(), "shouldn't be called if anything is onstack");
 544     if (!constants()->is_shared()) {
 545       MetadataFactory::free_metadata(loader_data, constants());
 546     }
 547     // Delete any cached resolution errors for the constant pool
 548     SystemDictionary::delete_resolution_error(constants());
 549 
 550     set_constants(NULL);
 551   }
 552 
 553   if (inner_classes() != NULL &&
 554       inner_classes() != Universe::the_empty_short_array() &&
 555       !inner_classes()->is_shared()) {
 556     MetadataFactory::free_array<jushort>(loader_data, inner_classes());
 557   }
 558   set_inner_classes(NULL);
 559 
 560   if (nest_members() != NULL &&
 561       nest_members() != Universe::the_empty_short_array() &&
 562       !nest_members()->is_shared()) {
 563     MetadataFactory::free_array<jushort>(loader_data, nest_members());
 564   }
 565   set_nest_members(NULL);
 566 
 567   // We should deallocate the Annotations instance if it's not in shared spaces.
 568   if (annotations() != NULL && !annotations()->is_shared()) {
 569     MetadataFactory::free_metadata(loader_data, annotations());
 570   }
 571   set_annotations(NULL);
 572 }
 573 
 574 bool InstanceKlass::should_be_initialized() const {
 575   return !is_initialized();
 576 }
 577 
 578 klassItable InstanceKlass::itable() const {
 579   return klassItable(const_cast<InstanceKlass*>(this));
 580 }
 581 
 582 void InstanceKlass::eager_initialize(Thread *thread) {
 583   if (!EagerInitialization) return;
 584 
 585   if (this->is_not_initialized()) {
 586     // abort if the the class has a class initializer
 587     if (this->class_initializer() != NULL) return;
 588 
 589     // abort if it is java.lang.Object (initialization is handled in genesis)
 590     Klass* super_klass = super();
 591     if (super_klass == NULL) return;
 592 
 593     // abort if the super class should be initialized
 594     if (!InstanceKlass::cast(super_klass)->is_initialized()) return;
 595 
 596     // call body to expose the this pointer
 597     eager_initialize_impl();
 598   }
 599 }
 600 
 601 // JVMTI spec thinks there are signers and protection domain in the
 602 // instanceKlass.  These accessors pretend these fields are there.
 603 // The hprof specification also thinks these fields are in InstanceKlass.
 604 oop InstanceKlass::protection_domain() const {
 605   // return the protection_domain from the mirror
 606   return java_lang_Class::protection_domain(java_mirror());
 607 }
 608 
 609 // To remove these from requires an incompatible change and CCC request.
 610 objArrayOop InstanceKlass::signers() const {
 611   // return the signers from the mirror
 612   return java_lang_Class::signers(java_mirror());
 613 }
 614 
 615 oop InstanceKlass::init_lock() const {
 616   // return the init lock from the mirror
 617   oop lock = java_lang_Class::init_lock(java_mirror());
 618   // Prevent reordering with any access of initialization state
 619   OrderAccess::loadload();
 620   assert((oop)lock != NULL || !is_not_initialized(), // initialized or in_error state
 621          "only fully initialized state can have a null lock");
 622   return lock;
 623 }
 624 
 625 // Set the initialization lock to null so the object can be GC'ed.  Any racing
 626 // threads to get this lock will see a null lock and will not lock.
 627 // That's okay because they all check for initialized state after getting
 628 // the lock and return.
 629 void InstanceKlass::fence_and_clear_init_lock() {
 630   // make sure previous stores are all done, notably the init_state.
 631   OrderAccess::storestore();
 632   java_lang_Class::set_init_lock(java_mirror(), NULL);
 633   assert(!is_not_initialized(), "class must be initialized now");
 634 }
 635 
 636 void InstanceKlass::eager_initialize_impl() {
 637   EXCEPTION_MARK;
 638   HandleMark hm(THREAD);
 639   Handle h_init_lock(THREAD, init_lock());
 640   ObjectLocker ol(h_init_lock, THREAD, h_init_lock() != NULL);
 641 
 642   // abort if someone beat us to the initialization
 643   if (!is_not_initialized()) return;  // note: not equivalent to is_initialized()
 644 
 645   ClassState old_state = init_state();
 646   link_class_impl(THREAD);
 647   if (HAS_PENDING_EXCEPTION) {
 648     CLEAR_PENDING_EXCEPTION;
 649     // Abort if linking the class throws an exception.
 650 
 651     // Use a test to avoid redundantly resetting the state if there's
 652     // no change.  Set_init_state() asserts that state changes make
 653     // progress, whereas here we might just be spinning in place.
 654     if (old_state != _init_state)
 655       set_init_state(old_state);
 656   } else {
 657     // linking successfull, mark class as initialized
 658     set_init_state(fully_initialized);
 659     fence_and_clear_init_lock();
 660     // trace
 661     if (log_is_enabled(Info, class, init)) {
 662       ResourceMark rm(THREAD);
 663       log_info(class, init)("[Initialized %s without side effects]", external_name());
 664     }
 665   }
 666 }
 667 
 668 
 669 // See "The Virtual Machine Specification" section 2.16.5 for a detailed explanation of the class initialization
 670 // process. The step comments refers to the procedure described in that section.
 671 // Note: implementation moved to static method to expose the this pointer.
 672 void InstanceKlass::initialize(TRAPS) {
 673   if (this->should_be_initialized()) {
 674     initialize_impl(CHECK);
 675     // Note: at this point the class may be initialized
 676     //       OR it may be in the state of being initialized
 677     //       in case of recursive initialization!
 678   } else {
 679     assert(is_initialized(), "sanity check");
 680   }
 681 }
 682 
 683 
 684 bool InstanceKlass::verify_code(TRAPS) {
 685   // 1) Verify the bytecodes
 686   return Verifier::verify(this, should_verify_class(), THREAD);
 687 }
 688 
 689 
 690 // Used exclusively by the shared spaces dump mechanism to prevent
 691 // classes mapped into the shared regions in new VMs from appearing linked.
 692 
 693 void InstanceKlass::unlink_class() {
 694   assert(is_linked(), "must be linked");
 695   _init_state = loaded;
 696 }
 697 
 698 void InstanceKlass::link_class(TRAPS) {
 699   assert(is_loaded(), "must be loaded");
 700   if (!is_linked()) {
 701     link_class_impl(CHECK);
 702   }
 703 }
 704 
 705 // Called to verify that a class can link during initialization, without
 706 // throwing a VerifyError.
 707 bool InstanceKlass::link_class_or_fail(TRAPS) {
 708   assert(is_loaded(), "must be loaded");
 709   if (!is_linked()) {
 710     link_class_impl(CHECK_false);
 711   }
 712   return is_linked();
 713 }
 714 
 715 bool InstanceKlass::link_class_impl(TRAPS) {
 716   if (DumpSharedSpaces && is_in_error_state()) {
 717     // This is for CDS dumping phase only -- we use the in_error_state to indicate that
 718     // the class has failed verification. Throwing the NoClassDefFoundError here is just
 719     // a convenient way to stop repeat attempts to verify the same (bad) class.
 720     //
 721     // Note that the NoClassDefFoundError is not part of the JLS, and should not be thrown
 722     // if we are executing Java code. This is not a problem for CDS dumping phase since
 723     // it doesn't execute any Java code.
 724     ResourceMark rm(THREAD);
 725     Exceptions::fthrow(THREAD_AND_LOCATION,
 726                        vmSymbols::java_lang_NoClassDefFoundError(),
 727                        "Class %s, or one of its supertypes, failed class initialization",
 728                        external_name());
 729     return false;
 730   }
 731   // return if already verified
 732   if (is_linked()) {
 733     return true;
 734   }
 735 
 736   // Timing
 737   // timer handles recursion
 738   assert(THREAD->is_Java_thread(), "non-JavaThread in link_class_impl");
 739   JavaThread* jt = (JavaThread*)THREAD;
 740 
 741   // link super class before linking this class
 742   Klass* super_klass = super();
 743   if (super_klass != NULL) {
 744     if (super_klass->is_interface()) {  // check if super class is an interface
 745       ResourceMark rm(THREAD);
 746       Exceptions::fthrow(
 747         THREAD_AND_LOCATION,
 748         vmSymbols::java_lang_IncompatibleClassChangeError(),
 749         "class %s has interface %s as super class",
 750         external_name(),
 751         super_klass->external_name()
 752       );
 753       return false;
 754     }
 755 
 756     InstanceKlass* ik_super = InstanceKlass::cast(super_klass);
 757     ik_super->link_class_impl(CHECK_false);
 758   }
 759 
 760   // link all interfaces implemented by this class before linking this class
 761   Array<InstanceKlass*>* interfaces = local_interfaces();
 762   int num_interfaces = interfaces->length();
 763   for (int index = 0; index < num_interfaces; index++) {
 764     InstanceKlass* interk = interfaces->at(index);
 765     interk->link_class_impl(CHECK_false);
 766   }
 767 
 768   // in case the class is linked in the process of linking its superclasses
 769   if (is_linked()) {
 770     return true;
 771   }
 772 
 773   // trace only the link time for this klass that includes
 774   // the verification time
 775   PerfClassTraceTime vmtimer(ClassLoader::perf_class_link_time(),
 776                              ClassLoader::perf_class_link_selftime(),
 777                              ClassLoader::perf_classes_linked(),
 778                              jt->get_thread_stat()->perf_recursion_counts_addr(),
 779                              jt->get_thread_stat()->perf_timers_addr(),
 780                              PerfClassTraceTime::CLASS_LINK);
 781 
 782   // verification & rewriting
 783   {
 784     HandleMark hm(THREAD);
 785     Handle h_init_lock(THREAD, init_lock());
 786     ObjectLocker ol(h_init_lock, THREAD, h_init_lock() != NULL);
 787     // rewritten will have been set if loader constraint error found
 788     // on an earlier link attempt
 789     // don't verify or rewrite if already rewritten
 790     //
 791 
 792     if (!is_linked()) {
 793       if (!is_rewritten()) {
 794         {
 795           bool verify_ok = verify_code(THREAD);
 796           if (!verify_ok) {
 797             return false;
 798           }
 799         }
 800 
 801         // Just in case a side-effect of verify linked this class already
 802         // (which can sometimes happen since the verifier loads classes
 803         // using custom class loaders, which are free to initialize things)
 804         if (is_linked()) {
 805           return true;
 806         }
 807 
 808         // also sets rewritten
 809         rewrite_class(CHECK_false);
 810       } else if (is_shared()) {
 811         SystemDictionaryShared::check_verification_constraints(this, CHECK_false);
 812       }
 813 
 814       // relocate jsrs and link methods after they are all rewritten
 815       link_methods(CHECK_false);
 816 
 817       // Initialize the vtable and interface table after
 818       // methods have been rewritten since rewrite may
 819       // fabricate new Method*s.
 820       // also does loader constraint checking
 821       //
 822       // initialize_vtable and initialize_itable need to be rerun for
 823       // a shared class if the class is not loaded by the NULL classloader.
 824       ClassLoaderData * loader_data = class_loader_data();
 825       if (!(is_shared() &&
 826             loader_data->is_the_null_class_loader_data())) {
 827         vtable().initialize_vtable(true, CHECK_false);
 828         itable().initialize_itable(true, CHECK_false);
 829       }
 830 #ifdef ASSERT
 831       else {
 832         vtable().verify(tty, true);
 833         // In case itable verification is ever added.
 834         // itable().verify(tty, true);
 835       }
 836 #endif
 837       set_init_state(linked);
 838       if (JvmtiExport::should_post_class_prepare()) {
 839         Thread *thread = THREAD;
 840         assert(thread->is_Java_thread(), "thread->is_Java_thread()");
 841         JvmtiExport::post_class_prepare((JavaThread *) thread, this);
 842       }
 843     }
 844   }
 845   return true;
 846 }
 847 
 848 // Rewrite the byte codes of all of the methods of a class.
 849 // The rewriter must be called exactly once. Rewriting must happen after
 850 // verification but before the first method of the class is executed.
 851 void InstanceKlass::rewrite_class(TRAPS) {
 852   assert(is_loaded(), "must be loaded");
 853   if (is_rewritten()) {
 854     assert(is_shared(), "rewriting an unshared class?");
 855     return;
 856   }
 857   Rewriter::rewrite(this, CHECK);
 858   set_rewritten();
 859 }
 860 
 861 // Now relocate and link method entry points after class is rewritten.
 862 // This is outside is_rewritten flag. In case of an exception, it can be
 863 // executed more than once.
 864 void InstanceKlass::link_methods(TRAPS) {
 865   int len = methods()->length();
 866   for (int i = len-1; i >= 0; i--) {
 867     methodHandle m(THREAD, methods()->at(i));
 868 
 869     // Set up method entry points for compiler and interpreter    .
 870     m->link_method(m, CHECK);
 871   }
 872 }
 873 
 874 // Eagerly initialize superinterfaces that declare default methods (concrete instance: any access)
 875 void InstanceKlass::initialize_super_interfaces(TRAPS) {
 876   assert (has_nonstatic_concrete_methods(), "caller should have checked this");
 877   for (int i = 0; i < local_interfaces()->length(); ++i) {
 878     InstanceKlass* ik = local_interfaces()->at(i);
 879 
 880     // Initialization is depth first search ie. we start with top of the inheritance tree
 881     // has_nonstatic_concrete_methods drives searching superinterfaces since it
 882     // means has_nonstatic_concrete_methods in its superinterface hierarchy
 883     if (ik->has_nonstatic_concrete_methods()) {
 884       ik->initialize_super_interfaces(CHECK);
 885     }
 886 
 887     // Only initialize() interfaces that "declare" concrete methods.
 888     if (ik->should_be_initialized() && ik->declares_nonstatic_concrete_methods()) {
 889       ik->initialize(CHECK);
 890     }
 891   }
 892 }
 893 
 894 void InstanceKlass::initialize_impl(TRAPS) {
 895   HandleMark hm(THREAD);
 896 
 897   // Make sure klass is linked (verified) before initialization
 898   // A class could already be verified, since it has been reflected upon.
 899   link_class(CHECK);
 900 
 901   DTRACE_CLASSINIT_PROBE(required, -1);
 902 
 903   bool wait = false;
 904 
 905   // refer to the JVM book page 47 for description of steps
 906   // Step 1
 907   {
 908     Handle h_init_lock(THREAD, init_lock());
 909     ObjectLocker ol(h_init_lock, THREAD, h_init_lock() != NULL);
 910 
 911     Thread *self = THREAD; // it's passed the current thread
 912 
 913     // Step 2
 914     // If we were to use wait() instead of waitInterruptibly() then
 915     // we might end up throwing IE from link/symbol resolution sites
 916     // that aren't expected to throw.  This would wreak havoc.  See 6320309.
 917     while(is_being_initialized() && !is_reentrant_initialization(self)) {
 918         wait = true;
 919       ol.waitUninterruptibly(CHECK);
 920     }
 921 
 922     // Step 3
 923     if (is_being_initialized() && is_reentrant_initialization(self)) {
 924       DTRACE_CLASSINIT_PROBE_WAIT(recursive, -1, wait);
 925       return;
 926     }
 927 
 928     // Step 4
 929     if (is_initialized()) {
 930       DTRACE_CLASSINIT_PROBE_WAIT(concurrent, -1, wait);
 931       return;
 932     }
 933 
 934     // Step 5
 935     if (is_in_error_state()) {
 936       DTRACE_CLASSINIT_PROBE_WAIT(erroneous, -1, wait);
 937       ResourceMark rm(THREAD);
 938       const char* desc = "Could not initialize class ";
 939       const char* className = external_name();
 940       size_t msglen = strlen(desc) + strlen(className) + 1;
 941       char* message = NEW_RESOURCE_ARRAY(char, msglen);
 942       if (NULL == message) {
 943         // Out of memory: can't create detailed error message
 944           THROW_MSG(vmSymbols::java_lang_NoClassDefFoundError(), className);
 945       } else {
 946         jio_snprintf(message, msglen, "%s%s", desc, className);
 947           THROW_MSG(vmSymbols::java_lang_NoClassDefFoundError(), message);
 948       }
 949     }
 950 
 951     // Step 6
 952     set_init_state(being_initialized);
 953     set_init_thread(self);
 954   }
 955 
 956   // Step 7
 957   // Next, if C is a class rather than an interface, initialize it's super class and super
 958   // interfaces.
 959   if (!is_interface()) {
 960     Klass* super_klass = super();
 961     if (super_klass != NULL && super_klass->should_be_initialized()) {
 962       super_klass->initialize(THREAD);
 963     }
 964     // If C implements any interface that declares a non-static, concrete method,
 965     // the initialization of C triggers initialization of its super interfaces.
 966     // Only need to recurse if has_nonstatic_concrete_methods which includes declaring and
 967     // having a superinterface that declares, non-static, concrete methods
 968     if (!HAS_PENDING_EXCEPTION && has_nonstatic_concrete_methods()) {
 969       initialize_super_interfaces(THREAD);
 970     }
 971 
 972     // If any exceptions, complete abruptly, throwing the same exception as above.
 973     if (HAS_PENDING_EXCEPTION) {
 974       Handle e(THREAD, PENDING_EXCEPTION);
 975       CLEAR_PENDING_EXCEPTION;
 976       {
 977         EXCEPTION_MARK;
 978         // Locks object, set state, and notify all waiting threads
 979         set_initialization_state_and_notify(initialization_error, THREAD);
 980         CLEAR_PENDING_EXCEPTION;
 981       }
 982       DTRACE_CLASSINIT_PROBE_WAIT(super__failed, -1, wait);
 983       THROW_OOP(e());
 984     }
 985   }
 986 
 987 
 988   // Look for aot compiled methods for this klass, including class initializer.
 989   AOTLoader::load_for_klass(this, THREAD);
 990 
 991   // Step 8
 992   {
 993     assert(THREAD->is_Java_thread(), "non-JavaThread in initialize_impl");
 994     JavaThread* jt = (JavaThread*)THREAD;
 995     DTRACE_CLASSINIT_PROBE_WAIT(clinit, -1, wait);
 996     // Timer includes any side effects of class initialization (resolution,
 997     // etc), but not recursive entry into call_class_initializer().
 998     PerfClassTraceTime timer(ClassLoader::perf_class_init_time(),
 999                              ClassLoader::perf_class_init_selftime(),
1000                              ClassLoader::perf_classes_inited(),
1001                              jt->get_thread_stat()->perf_recursion_counts_addr(),
1002                              jt->get_thread_stat()->perf_timers_addr(),
1003                              PerfClassTraceTime::CLASS_CLINIT);
1004     call_class_initializer(THREAD);
1005   }
1006 
1007   // Step 9
1008   if (!HAS_PENDING_EXCEPTION) {
1009     set_initialization_state_and_notify(fully_initialized, CHECK);
1010     {
1011       debug_only(vtable().verify(tty, true);)
1012     }
1013   }
1014   else {
1015     // Step 10 and 11
1016     Handle e(THREAD, PENDING_EXCEPTION);
1017     CLEAR_PENDING_EXCEPTION;
1018     // JVMTI has already reported the pending exception
1019     // JVMTI internal flag reset is needed in order to report ExceptionInInitializerError
1020     JvmtiExport::clear_detected_exception((JavaThread*)THREAD);
1021     {
1022       EXCEPTION_MARK;
1023       set_initialization_state_and_notify(initialization_error, THREAD);
1024       CLEAR_PENDING_EXCEPTION;   // ignore any exception thrown, class initialization error is thrown below
1025       // JVMTI has already reported the pending exception
1026       // JVMTI internal flag reset is needed in order to report ExceptionInInitializerError
1027       JvmtiExport::clear_detected_exception((JavaThread*)THREAD);
1028     }
1029     DTRACE_CLASSINIT_PROBE_WAIT(error, -1, wait);
1030     if (e->is_a(SystemDictionary::Error_klass())) {
1031       THROW_OOP(e());
1032     } else {
1033       JavaCallArguments args(e);
1034       THROW_ARG(vmSymbols::java_lang_ExceptionInInitializerError(),
1035                 vmSymbols::throwable_void_signature(),
1036                 &args);
1037     }
1038   }
1039   DTRACE_CLASSINIT_PROBE_WAIT(end, -1, wait);
1040 }
1041 
1042 
1043 void InstanceKlass::set_initialization_state_and_notify(ClassState state, TRAPS) {
1044   Handle h_init_lock(THREAD, init_lock());
1045   if (h_init_lock() != NULL) {
1046     ObjectLocker ol(h_init_lock, THREAD);
1047     set_init_state(state);
1048     fence_and_clear_init_lock();
1049     ol.notify_all(CHECK);
1050   } else {
1051     assert(h_init_lock() != NULL, "The initialization state should never be set twice");
1052     set_init_state(state);
1053   }
1054 }
1055 
1056 Klass* InstanceKlass::implementor() const {
1057   assert_locked_or_safepoint(Compile_lock);
1058   Klass** k = adr_implementor();
1059   if (k == NULL) {
1060     return NULL;
1061   } else {
1062     return *k;
1063   }
1064 }
1065 
1066 void InstanceKlass::set_implementor(Klass* k) {
1067   assert_lock_strong(Compile_lock);
1068   assert(is_interface(), "not interface");
1069   Klass** addr = adr_implementor();
1070   assert(addr != NULL, "null addr");
1071   if (addr != NULL) {
1072     *addr = k;
1073   }
1074 }
1075 
1076 int  InstanceKlass::nof_implementors() const {
1077   assert_lock_strong(Compile_lock);
1078   Klass* k = implementor();
1079   if (k == NULL) {
1080     return 0;
1081   } else if (k != this) {
1082     return 1;
1083   } else {
1084     return 2;
1085   }
1086 }
1087 
1088 // The embedded _implementor field can only record one implementor.
1089 // When there are more than one implementors, the _implementor field
1090 // is set to the interface Klass* itself. Following are the possible
1091 // values for the _implementor field:
1092 //   NULL                  - no implementor
1093 //   implementor Klass*    - one implementor
1094 //   self                  - more than one implementor
1095 //
1096 // The _implementor field only exists for interfaces.
1097 void InstanceKlass::add_implementor(Klass* k) {
1098   assert_lock_strong(Compile_lock);
1099   assert(is_interface(), "not interface");
1100   // Filter out my subinterfaces.
1101   // (Note: Interfaces are never on the subklass list.)
1102   if (InstanceKlass::cast(k)->is_interface()) return;
1103 
1104   // Filter out subclasses whose supers already implement me.
1105   // (Note: CHA must walk subclasses of direct implementors
1106   // in order to locate indirect implementors.)
1107   Klass* sk = k->super();
1108   if (sk != NULL && InstanceKlass::cast(sk)->implements_interface(this))
1109     // We only need to check one immediate superclass, since the
1110     // implements_interface query looks at transitive_interfaces.
1111     // Any supers of the super have the same (or fewer) transitive_interfaces.
1112     return;
1113 
1114   Klass* ik = implementor();
1115   if (ik == NULL) {
1116     set_implementor(k);
1117   } else if (ik != this) {
1118     // There is already an implementor. Use itself as an indicator of
1119     // more than one implementors.
1120     set_implementor(this);
1121   }
1122 
1123   // The implementor also implements the transitive_interfaces
1124   for (int index = 0; index < local_interfaces()->length(); index++) {
1125     InstanceKlass::cast(local_interfaces()->at(index))->add_implementor(k);
1126   }
1127 }
1128 
1129 void InstanceKlass::init_implementor() {
1130   if (is_interface()) {
1131     set_implementor(NULL);
1132   }
1133 }
1134 
1135 
1136 void InstanceKlass::process_interfaces(Thread *thread) {
1137   // link this class into the implementors list of every interface it implements
1138   for (int i = local_interfaces()->length() - 1; i >= 0; i--) {
1139     assert(local_interfaces()->at(i)->is_klass(), "must be a klass");
1140     InstanceKlass* interf = InstanceKlass::cast(local_interfaces()->at(i));
1141     assert(interf->is_interface(), "expected interface");
1142     interf->add_implementor(this);
1143   }
1144 }
1145 
1146 bool InstanceKlass::can_be_primary_super_slow() const {
1147   if (is_interface())
1148     return false;
1149   else
1150     return Klass::can_be_primary_super_slow();
1151 }
1152 
1153 GrowableArray<Klass*>* InstanceKlass::compute_secondary_supers(int num_extra_slots,
1154                                                                Array<InstanceKlass*>* transitive_interfaces) {
1155   // The secondaries are the implemented interfaces.
1156   Array<InstanceKlass*>* interfaces = transitive_interfaces;
1157   int num_secondaries = num_extra_slots + interfaces->length();
1158   if (num_secondaries == 0) {
1159     // Must share this for correct bootstrapping!
1160     set_secondary_supers(Universe::the_empty_klass_array());
1161     return NULL;
1162   } else if (num_extra_slots == 0) {
1163     // The secondary super list is exactly the same as the transitive interfaces, so
1164     // let's use it instead of making a copy.
1165     // Redefine classes has to be careful not to delete this!
1166     // We need the cast because Array<Klass*> is NOT a supertype of Array<InstanceKlass*>,
1167     // (but it's safe to do here because we won't write into _secondary_supers from this point on).
1168     set_secondary_supers((Array<Klass*>*)(address)interfaces);
1169     return NULL;
1170   } else {
1171     // Copy transitive interfaces to a temporary growable array to be constructed
1172     // into the secondary super list with extra slots.
1173     GrowableArray<Klass*>* secondaries = new GrowableArray<Klass*>(interfaces->length());
1174     for (int i = 0; i < interfaces->length(); i++) {
1175       secondaries->push(interfaces->at(i));
1176     }
1177     return secondaries;
1178   }
1179 }
1180 
1181 bool InstanceKlass::compute_is_subtype_of(Klass* k) {
1182   if (k->is_interface()) {
1183     return implements_interface(k);
1184   } else {
1185     return Klass::compute_is_subtype_of(k);
1186   }
1187 }
1188 
1189 bool InstanceKlass::implements_interface(Klass* k) const {
1190   if (this == k) return true;
1191   assert(k->is_interface(), "should be an interface class");
1192   for (int i = 0; i < transitive_interfaces()->length(); i++) {
1193     if (transitive_interfaces()->at(i) == k) {
1194       return true;
1195     }
1196   }
1197   return false;
1198 }
1199 
1200 bool InstanceKlass::is_same_or_direct_interface(Klass *k) const {
1201   // Verify direct super interface
1202   if (this == k) return true;
1203   assert(k->is_interface(), "should be an interface class");
1204   for (int i = 0; i < local_interfaces()->length(); i++) {
1205     if (local_interfaces()->at(i) == k) {
1206       return true;
1207     }
1208   }
1209   return false;
1210 }
1211 
1212 objArrayOop InstanceKlass::allocate_objArray(int n, int length, TRAPS) {
1213   if (length < 0)  {
1214     THROW_MSG_0(vmSymbols::java_lang_NegativeArraySizeException(), err_msg("%d", length));
1215   }
1216   if (length > arrayOopDesc::max_array_length(T_OBJECT)) {
1217     report_java_out_of_memory("Requested array size exceeds VM limit");
1218     JvmtiExport::post_array_size_exhausted();
1219     THROW_OOP_0(Universe::out_of_memory_error_array_size());
1220   }
1221   int size = objArrayOopDesc::object_size(length);
1222   Klass* ak = array_klass(n, CHECK_NULL);
1223   objArrayOop o = (objArrayOop)Universe::heap()->array_allocate(ak, size, length,
1224                                                                 /* do_zero */ true, CHECK_NULL);
1225   return o;
1226 }
1227 
1228 instanceOop InstanceKlass::register_finalizer(instanceOop i, TRAPS) {
1229   if (TraceFinalizerRegistration) {
1230     tty->print("Registered ");
1231     i->print_value_on(tty);
1232     tty->print_cr(" (" INTPTR_FORMAT ") as finalizable", p2i(i));
1233   }
1234   instanceHandle h_i(THREAD, i);
1235   // Pass the handle as argument, JavaCalls::call expects oop as jobjects
1236   JavaValue result(T_VOID);
1237   JavaCallArguments args(h_i);
1238   methodHandle mh (THREAD, Universe::finalizer_register_method());
1239   JavaCalls::call(&result, mh, &args, CHECK_NULL);
1240   return h_i();
1241 }
1242 
1243 instanceOop InstanceKlass::allocate_instance(TRAPS) {
1244   bool has_finalizer_flag = has_finalizer(); // Query before possible GC
1245   int size = size_helper();  // Query before forming handle.
1246 
1247   instanceOop i;
1248 
1249   i = (instanceOop)Universe::heap()->obj_allocate(this, size, CHECK_NULL);
1250   if (has_finalizer_flag && !RegisterFinalizersAtInit) {
1251     i = register_finalizer(i, CHECK_NULL);
1252   }
1253   return i;
1254 }
1255 
1256 instanceHandle InstanceKlass::allocate_instance_handle(TRAPS) {
1257   return instanceHandle(THREAD, allocate_instance(THREAD));
1258 }
1259 
1260 void InstanceKlass::check_valid_for_instantiation(bool throwError, TRAPS) {
1261   if (is_interface() || is_abstract()) {
1262     ResourceMark rm(THREAD);
1263     THROW_MSG(throwError ? vmSymbols::java_lang_InstantiationError()
1264               : vmSymbols::java_lang_InstantiationException(), external_name());
1265   }
1266   if (this == SystemDictionary::Class_klass()) {
1267     ResourceMark rm(THREAD);
1268     THROW_MSG(throwError ? vmSymbols::java_lang_IllegalAccessError()
1269               : vmSymbols::java_lang_IllegalAccessException(), external_name());
1270   }
1271 }
1272 
1273 Klass* InstanceKlass::array_klass_impl(bool or_null, int n, TRAPS) {
1274   // Need load-acquire for lock-free read
1275   if (array_klasses_acquire() == NULL) {
1276     if (or_null) return NULL;
1277 
1278     ResourceMark rm;
1279     JavaThread *jt = (JavaThread *)THREAD;
1280     {
1281       // Atomic creation of array_klasses
1282       MutexLocker mc(Compile_lock, THREAD);   // for vtables
1283       MutexLocker ma(MultiArray_lock, THREAD);
1284 
1285       // Check if update has already taken place
1286       if (array_klasses() == NULL) {
1287         Klass*    k = ObjArrayKlass::allocate_objArray_klass(class_loader_data(), 1, this, CHECK_NULL);
1288         // use 'release' to pair with lock-free load
1289         release_set_array_klasses(k);
1290       }
1291     }
1292   }
1293   // _this will always be set at this point
1294   ObjArrayKlass* oak = (ObjArrayKlass*)array_klasses();
1295   if (or_null) {
1296     return oak->array_klass_or_null(n);
1297   }
1298   return oak->array_klass(n, THREAD);
1299 }
1300 
1301 Klass* InstanceKlass::array_klass_impl(bool or_null, TRAPS) {
1302   return array_klass_impl(or_null, 1, THREAD);
1303 }
1304 
1305 static int call_class_initializer_counter = 0;   // for debugging
1306 
1307 Method* InstanceKlass::class_initializer() const {
1308   Method* clinit = find_method(
1309       vmSymbols::class_initializer_name(), vmSymbols::void_method_signature());
1310   if (clinit != NULL && clinit->has_valid_initializer_flags()) {
1311     return clinit;
1312   }
1313   return NULL;
1314 }
1315 
1316 void InstanceKlass::call_class_initializer(TRAPS) {
1317   if (ReplayCompiles &&
1318       (ReplaySuppressInitializers == 1 ||
1319        (ReplaySuppressInitializers >= 2 && class_loader() != NULL))) {
1320     // Hide the existence of the initializer for the purpose of replaying the compile
1321     return;
1322   }
1323 
1324   methodHandle h_method(THREAD, class_initializer());
1325   assert(!is_initialized(), "we cannot initialize twice");
1326   LogTarget(Info, class, init) lt;
1327   if (lt.is_enabled()) {
1328     ResourceMark rm;
1329     LogStream ls(lt);
1330     ls.print("%d Initializing ", call_class_initializer_counter++);
1331     name()->print_value_on(&ls);
1332     ls.print_cr("%s (" INTPTR_FORMAT ")", h_method() == NULL ? "(no method)" : "", p2i(this));
1333   }
1334   if (h_method() != NULL) {
1335     JavaCallArguments args; // No arguments
1336     JavaValue result(T_VOID);
1337     JavaCalls::call(&result, h_method, &args, CHECK); // Static call (no args)
1338   }
1339 }
1340 
1341 
1342 void InstanceKlass::mask_for(const methodHandle& method, int bci,
1343   InterpreterOopMap* entry_for) {
1344   // Lazily create the _oop_map_cache at first request
1345   // Lock-free access requires load_acquire.
1346   OopMapCache* oop_map_cache = OrderAccess::load_acquire(&_oop_map_cache);
1347   if (oop_map_cache == NULL) {
1348     MutexLocker x(OopMapCacheAlloc_lock);
1349     // Check if _oop_map_cache was allocated while we were waiting for this lock
1350     if ((oop_map_cache = _oop_map_cache) == NULL) {
1351       oop_map_cache = new OopMapCache();
1352       // Ensure _oop_map_cache is stable, since it is examined without a lock
1353       OrderAccess::release_store(&_oop_map_cache, oop_map_cache);
1354     }
1355   }
1356   // _oop_map_cache is constant after init; lookup below does its own locking.
1357   oop_map_cache->lookup(method, bci, entry_for);
1358 }
1359 
1360 
1361 bool InstanceKlass::find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const {
1362   for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
1363     Symbol* f_name = fs.name();
1364     Symbol* f_sig  = fs.signature();
1365     if (f_name == name && f_sig == sig) {
1366       fd->reinitialize(const_cast<InstanceKlass*>(this), fs.index());
1367       return true;
1368     }
1369   }
1370   return false;
1371 }
1372 
1373 
1374 Klass* InstanceKlass::find_interface_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const {
1375   const int n = local_interfaces()->length();
1376   for (int i = 0; i < n; i++) {
1377     Klass* intf1 = local_interfaces()->at(i);
1378     assert(intf1->is_interface(), "just checking type");
1379     // search for field in current interface
1380     if (InstanceKlass::cast(intf1)->find_local_field(name, sig, fd)) {
1381       assert(fd->is_static(), "interface field must be static");
1382       return intf1;
1383     }
1384     // search for field in direct superinterfaces
1385     Klass* intf2 = InstanceKlass::cast(intf1)->find_interface_field(name, sig, fd);
1386     if (intf2 != NULL) return intf2;
1387   }
1388   // otherwise field lookup fails
1389   return NULL;
1390 }
1391 
1392 
1393 Klass* InstanceKlass::find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const {
1394   // search order according to newest JVM spec (5.4.3.2, p.167).
1395   // 1) search for field in current klass
1396   if (find_local_field(name, sig, fd)) {
1397     return const_cast<InstanceKlass*>(this);
1398   }
1399   // 2) search for field recursively in direct superinterfaces
1400   { Klass* intf = find_interface_field(name, sig, fd);
1401     if (intf != NULL) return intf;
1402   }
1403   // 3) apply field lookup recursively if superclass exists
1404   { Klass* supr = super();
1405     if (supr != NULL) return InstanceKlass::cast(supr)->find_field(name, sig, fd);
1406   }
1407   // 4) otherwise field lookup fails
1408   return NULL;
1409 }
1410 
1411 
1412 Klass* InstanceKlass::find_field(Symbol* name, Symbol* sig, bool is_static, fieldDescriptor* fd) const {
1413   // search order according to newest JVM spec (5.4.3.2, p.167).
1414   // 1) search for field in current klass
1415   if (find_local_field(name, sig, fd)) {
1416     if (fd->is_static() == is_static) return const_cast<InstanceKlass*>(this);
1417   }
1418   // 2) search for field recursively in direct superinterfaces
1419   if (is_static) {
1420     Klass* intf = find_interface_field(name, sig, fd);
1421     if (intf != NULL) return intf;
1422   }
1423   // 3) apply field lookup recursively if superclass exists
1424   { Klass* supr = super();
1425     if (supr != NULL) return InstanceKlass::cast(supr)->find_field(name, sig, is_static, fd);
1426   }
1427   // 4) otherwise field lookup fails
1428   return NULL;
1429 }
1430 
1431 
1432 bool InstanceKlass::find_local_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const {
1433   for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
1434     if (fs.offset() == offset) {
1435       fd->reinitialize(const_cast<InstanceKlass*>(this), fs.index());
1436       if (fd->is_static() == is_static) return true;
1437     }
1438   }
1439   return false;
1440 }
1441 
1442 
1443 bool InstanceKlass::find_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const {
1444   Klass* klass = const_cast<InstanceKlass*>(this);
1445   while (klass != NULL) {
1446     if (InstanceKlass::cast(klass)->find_local_field_from_offset(offset, is_static, fd)) {
1447       return true;
1448     }
1449     klass = klass->super();
1450   }
1451   return false;
1452 }
1453 
1454 
1455 void InstanceKlass::methods_do(void f(Method* method)) {
1456   // Methods aren't stable until they are loaded.  This can be read outside
1457   // a lock through the ClassLoaderData for profiling
1458   if (!is_loaded()) {
1459     return;
1460   }
1461 
1462   int len = methods()->length();
1463   for (int index = 0; index < len; index++) {
1464     Method* m = methods()->at(index);
1465     assert(m->is_method(), "must be method");
1466     f(m);
1467   }
1468 }
1469 
1470 
1471 void InstanceKlass::do_local_static_fields(FieldClosure* cl) {
1472   for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
1473     if (fs.access_flags().is_static()) {
1474       fieldDescriptor& fd = fs.field_descriptor();
1475       cl->do_field(&fd);
1476     }
1477   }
1478 }
1479 
1480 
1481 void InstanceKlass::do_local_static_fields(void f(fieldDescriptor*, Handle, TRAPS), Handle mirror, TRAPS) {
1482   for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
1483     if (fs.access_flags().is_static()) {
1484       fieldDescriptor& fd = fs.field_descriptor();
1485       f(&fd, mirror, CHECK);
1486     }
1487   }
1488 }
1489 
1490 
1491 static int compare_fields_by_offset(int* a, int* b) {
1492   return a[0] - b[0];
1493 }
1494 
1495 void InstanceKlass::do_nonstatic_fields(FieldClosure* cl) {
1496   InstanceKlass* super = superklass();
1497   if (super != NULL) {
1498     super->do_nonstatic_fields(cl);
1499   }
1500   fieldDescriptor fd;
1501   int length = java_fields_count();
1502   // In DebugInfo nonstatic fields are sorted by offset.
1503   int* fields_sorted = NEW_C_HEAP_ARRAY(int, 2*(length+1), mtClass);
1504   int j = 0;
1505   for (int i = 0; i < length; i += 1) {
1506     fd.reinitialize(this, i);
1507     if (!fd.is_static()) {
1508       fields_sorted[j + 0] = fd.offset();
1509       fields_sorted[j + 1] = i;
1510       j += 2;
1511     }
1512   }
1513   if (j > 0) {
1514     length = j;
1515     // _sort_Fn is defined in growableArray.hpp.
1516     qsort(fields_sorted, length/2, 2*sizeof(int), (_sort_Fn)compare_fields_by_offset);
1517     for (int i = 0; i < length; i += 2) {
1518       fd.reinitialize(this, fields_sorted[i + 1]);
1519       assert(!fd.is_static() && fd.offset() == fields_sorted[i], "only nonstatic fields");
1520       cl->do_field(&fd);
1521     }
1522   }
1523   FREE_C_HEAP_ARRAY(int, fields_sorted);
1524 }
1525 
1526 
1527 void InstanceKlass::array_klasses_do(void f(Klass* k, TRAPS), TRAPS) {
1528   if (array_klasses() != NULL)
1529     ArrayKlass::cast(array_klasses())->array_klasses_do(f, THREAD);
1530 }
1531 
1532 void InstanceKlass::array_klasses_do(void f(Klass* k)) {
1533   if (array_klasses() != NULL)
1534     ArrayKlass::cast(array_klasses())->array_klasses_do(f);
1535 }
1536 
1537 #ifdef ASSERT
1538 static int linear_search(const Array<Method*>* methods,
1539                          const Symbol* name,
1540                          const Symbol* signature) {
1541   const int len = methods->length();
1542   for (int index = 0; index < len; index++) {
1543     const Method* const m = methods->at(index);
1544     assert(m->is_method(), "must be method");
1545     if (m->signature() == signature && m->name() == name) {
1546        return index;
1547     }
1548   }
1549   return -1;
1550 }
1551 #endif
1552 
1553 static int binary_search(const Array<Method*>* methods, const Symbol* name) {
1554   int len = methods->length();
1555   // methods are sorted, so do binary search
1556   int l = 0;
1557   int h = len - 1;
1558   while (l <= h) {
1559     int mid = (l + h) >> 1;
1560     Method* m = methods->at(mid);
1561     assert(m->is_method(), "must be method");
1562     int res = m->name()->fast_compare(name);
1563     if (res == 0) {
1564       return mid;
1565     } else if (res < 0) {
1566       l = mid + 1;
1567     } else {
1568       h = mid - 1;
1569     }
1570   }
1571   return -1;
1572 }
1573 
1574 // find_method looks up the name/signature in the local methods array
1575 Method* InstanceKlass::find_method(const Symbol* name,
1576                                    const Symbol* signature) const {
1577   return find_method_impl(name, signature, find_overpass, find_static, find_private);
1578 }
1579 
1580 Method* InstanceKlass::find_method_impl(const Symbol* name,
1581                                         const Symbol* signature,
1582                                         OverpassLookupMode overpass_mode,
1583                                         StaticLookupMode static_mode,
1584                                         PrivateLookupMode private_mode) const {
1585   return InstanceKlass::find_method_impl(methods(),
1586                                          name,
1587                                          signature,
1588                                          overpass_mode,
1589                                          static_mode,
1590                                          private_mode);
1591 }
1592 
1593 // find_instance_method looks up the name/signature in the local methods array
1594 // and skips over static methods
1595 Method* InstanceKlass::find_instance_method(const Array<Method*>* methods,
1596                                             const Symbol* name,
1597                                             const Symbol* signature,
1598                                             PrivateLookupMode private_mode) {
1599   Method* const meth = InstanceKlass::find_method_impl(methods,
1600                                                  name,
1601                                                  signature,
1602                                                  find_overpass,
1603                                                  skip_static,
1604                                                  private_mode);
1605   assert(((meth == NULL) || !meth->is_static()),
1606     "find_instance_method should have skipped statics");
1607   return meth;
1608 }
1609 
1610 // find_instance_method looks up the name/signature in the local methods array
1611 // and skips over static methods
1612 Method* InstanceKlass::find_instance_method(const Symbol* name,
1613                                             const Symbol* signature,
1614                                             PrivateLookupMode private_mode) const {
1615   return InstanceKlass::find_instance_method(methods(), name, signature, private_mode);
1616 }
1617 
1618 // Find looks up the name/signature in the local methods array
1619 // and filters on the overpass, static and private flags
1620 // This returns the first one found
1621 // note that the local methods array can have up to one overpass, one static
1622 // and one instance (private or not) with the same name/signature
1623 Method* InstanceKlass::find_local_method(const Symbol* name,
1624                                          const Symbol* signature,
1625                                          OverpassLookupMode overpass_mode,
1626                                          StaticLookupMode static_mode,
1627                                          PrivateLookupMode private_mode) const {
1628   return InstanceKlass::find_method_impl(methods(),
1629                                          name,
1630                                          signature,
1631                                          overpass_mode,
1632                                          static_mode,
1633                                          private_mode);
1634 }
1635 
1636 // Find looks up the name/signature in the local methods array
1637 // and filters on the overpass, static and private flags
1638 // This returns the first one found
1639 // note that the local methods array can have up to one overpass, one static
1640 // and one instance (private or not) with the same name/signature
1641 Method* InstanceKlass::find_local_method(const Array<Method*>* methods,
1642                                          const Symbol* name,
1643                                          const Symbol* signature,
1644                                          OverpassLookupMode overpass_mode,
1645                                          StaticLookupMode static_mode,
1646                                          PrivateLookupMode private_mode) {
1647   return InstanceKlass::find_method_impl(methods,
1648                                          name,
1649                                          signature,
1650                                          overpass_mode,
1651                                          static_mode,
1652                                          private_mode);
1653 }
1654 
1655 Method* InstanceKlass::find_method(const Array<Method*>* methods,
1656                                    const Symbol* name,
1657                                    const Symbol* signature) {
1658   return InstanceKlass::find_method_impl(methods,
1659                                          name,
1660                                          signature,
1661                                          find_overpass,
1662                                          find_static,
1663                                          find_private);
1664 }
1665 
1666 Method* InstanceKlass::find_method_impl(const Array<Method*>* methods,
1667                                         const Symbol* name,
1668                                         const Symbol* signature,
1669                                         OverpassLookupMode overpass_mode,
1670                                         StaticLookupMode static_mode,
1671                                         PrivateLookupMode private_mode) {
1672   int hit = find_method_index(methods, name, signature, overpass_mode, static_mode, private_mode);
1673   return hit >= 0 ? methods->at(hit): NULL;
1674 }
1675 
1676 // true if method matches signature and conforms to skipping_X conditions.
1677 static bool method_matches(const Method* m,
1678                            const Symbol* signature,
1679                            bool skipping_overpass,
1680                            bool skipping_static,
1681                            bool skipping_private) {
1682   return ((m->signature() == signature) &&
1683     (!skipping_overpass || !m->is_overpass()) &&
1684     (!skipping_static || !m->is_static()) &&
1685     (!skipping_private || !m->is_private()));
1686 }
1687 
1688 // Used directly for default_methods to find the index into the
1689 // default_vtable_indices, and indirectly by find_method
1690 // find_method_index looks in the local methods array to return the index
1691 // of the matching name/signature. If, overpass methods are being ignored,
1692 // the search continues to find a potential non-overpass match.  This capability
1693 // is important during method resolution to prefer a static method, for example,
1694 // over an overpass method.
1695 // There is the possibility in any _method's array to have the same name/signature
1696 // for a static method, an overpass method and a local instance method
1697 // To correctly catch a given method, the search criteria may need
1698 // to explicitly skip the other two. For local instance methods, it
1699 // is often necessary to skip private methods
1700 int InstanceKlass::find_method_index(const Array<Method*>* methods,
1701                                      const Symbol* name,
1702                                      const Symbol* signature,
1703                                      OverpassLookupMode overpass_mode,
1704                                      StaticLookupMode static_mode,
1705                                      PrivateLookupMode private_mode) {
1706   const bool skipping_overpass = (overpass_mode == skip_overpass);
1707   const bool skipping_static = (static_mode == skip_static);
1708   const bool skipping_private = (private_mode == skip_private);
1709   const int hit = binary_search(methods, name);
1710   if (hit != -1) {
1711     const Method* const m = methods->at(hit);
1712 
1713     // Do linear search to find matching signature.  First, quick check
1714     // for common case, ignoring overpasses if requested.
1715     if (method_matches(m, signature, skipping_overpass, skipping_static, skipping_private)) {
1716       return hit;
1717     }
1718 
1719     // search downwards through overloaded methods
1720     int i;
1721     for (i = hit - 1; i >= 0; --i) {
1722         const Method* const m = methods->at(i);
1723         assert(m->is_method(), "must be method");
1724         if (m->name() != name) {
1725           break;
1726         }
1727         if (method_matches(m, signature, skipping_overpass, skipping_static, skipping_private)) {
1728           return i;
1729         }
1730     }
1731     // search upwards
1732     for (i = hit + 1; i < methods->length(); ++i) {
1733         const Method* const m = methods->at(i);
1734         assert(m->is_method(), "must be method");
1735         if (m->name() != name) {
1736           break;
1737         }
1738         if (method_matches(m, signature, skipping_overpass, skipping_static, skipping_private)) {
1739           return i;
1740         }
1741     }
1742     // not found
1743 #ifdef ASSERT
1744     const int index = (skipping_overpass || skipping_static || skipping_private) ? -1 :
1745       linear_search(methods, name, signature);
1746     assert(-1 == index, "binary search should have found entry %d", index);
1747 #endif
1748   }
1749   return -1;
1750 }
1751 
1752 int InstanceKlass::find_method_by_name(const Symbol* name, int* end) const {
1753   return find_method_by_name(methods(), name, end);
1754 }
1755 
1756 int InstanceKlass::find_method_by_name(const Array<Method*>* methods,
1757                                        const Symbol* name,
1758                                        int* end_ptr) {
1759   assert(end_ptr != NULL, "just checking");
1760   int start = binary_search(methods, name);
1761   int end = start + 1;
1762   if (start != -1) {
1763     while (start - 1 >= 0 && (methods->at(start - 1))->name() == name) --start;
1764     while (end < methods->length() && (methods->at(end))->name() == name) ++end;
1765     *end_ptr = end;
1766     return start;
1767   }
1768   return -1;
1769 }
1770 
1771 // uncached_lookup_method searches both the local class methods array and all
1772 // superclasses methods arrays, skipping any overpass methods in superclasses,
1773 // and possibly skipping private methods.
1774 Method* InstanceKlass::uncached_lookup_method(const Symbol* name,
1775                                               const Symbol* signature,
1776                                               OverpassLookupMode overpass_mode,
1777                                               PrivateLookupMode private_mode) const {
1778   OverpassLookupMode overpass_local_mode = overpass_mode;
1779   const Klass* klass = this;
1780   while (klass != NULL) {
1781     Method* const method = InstanceKlass::cast(klass)->find_method_impl(name,
1782                                                                         signature,
1783                                                                         overpass_local_mode,
1784                                                                         find_static,
1785                                                                         private_mode);
1786     if (method != NULL) {
1787       return method;
1788     }
1789     klass = klass->super();
1790     overpass_local_mode = skip_overpass;   // Always ignore overpass methods in superclasses
1791   }
1792   return NULL;
1793 }
1794 
1795 #ifdef ASSERT
1796 // search through class hierarchy and return true if this class or
1797 // one of the superclasses was redefined
1798 bool InstanceKlass::has_redefined_this_or_super() const {
1799   const Klass* klass = this;
1800   while (klass != NULL) {
1801     if (InstanceKlass::cast(klass)->has_been_redefined()) {
1802       return true;
1803     }
1804     klass = klass->super();
1805   }
1806   return false;
1807 }
1808 #endif
1809 
1810 // lookup a method in the default methods list then in all transitive interfaces
1811 // Do NOT return private or static methods
1812 Method* InstanceKlass::lookup_method_in_ordered_interfaces(Symbol* name,
1813                                                          Symbol* signature) const {
1814   Method* m = NULL;
1815   if (default_methods() != NULL) {
1816     m = find_method(default_methods(), name, signature);
1817   }
1818   // Look up interfaces
1819   if (m == NULL) {
1820     m = lookup_method_in_all_interfaces(name, signature, find_defaults);
1821   }
1822   return m;
1823 }
1824 
1825 // lookup a method in all the interfaces that this class implements
1826 // Do NOT return private or static methods, new in JDK8 which are not externally visible
1827 // They should only be found in the initial InterfaceMethodRef
1828 Method* InstanceKlass::lookup_method_in_all_interfaces(Symbol* name,
1829                                                        Symbol* signature,
1830                                                        DefaultsLookupMode defaults_mode) const {
1831   Array<InstanceKlass*>* all_ifs = transitive_interfaces();
1832   int num_ifs = all_ifs->length();
1833   InstanceKlass *ik = NULL;
1834   for (int i = 0; i < num_ifs; i++) {
1835     ik = all_ifs->at(i);
1836     Method* m = ik->lookup_method(name, signature);
1837     if (m != NULL && m->is_public() && !m->is_static() &&
1838         ((defaults_mode != skip_defaults) || !m->is_default_method())) {
1839       return m;
1840     }
1841   }
1842   return NULL;
1843 }
1844 
1845 /* jni_id_for_impl for jfieldIds only */
1846 JNIid* InstanceKlass::jni_id_for_impl(int offset) {
1847   MutexLocker ml(JfieldIdCreation_lock);
1848   // Retry lookup after we got the lock
1849   JNIid* probe = jni_ids() == NULL ? NULL : jni_ids()->find(offset);
1850   if (probe == NULL) {
1851     // Slow case, allocate new static field identifier
1852     probe = new JNIid(this, offset, jni_ids());
1853     set_jni_ids(probe);
1854   }
1855   return probe;
1856 }
1857 
1858 
1859 /* jni_id_for for jfieldIds only */
1860 JNIid* InstanceKlass::jni_id_for(int offset) {
1861   JNIid* probe = jni_ids() == NULL ? NULL : jni_ids()->find(offset);
1862   if (probe == NULL) {
1863     probe = jni_id_for_impl(offset);
1864   }
1865   return probe;
1866 }
1867 
1868 u2 InstanceKlass::enclosing_method_data(int offset) const {
1869   const Array<jushort>* const inner_class_list = inner_classes();
1870   if (inner_class_list == NULL) {
1871     return 0;
1872   }
1873   const int length = inner_class_list->length();
1874   if (length % inner_class_next_offset == 0) {
1875     return 0;
1876   }
1877   const int index = length - enclosing_method_attribute_size;
1878   assert(offset < enclosing_method_attribute_size, "invalid offset");
1879   return inner_class_list->at(index + offset);
1880 }
1881 
1882 void InstanceKlass::set_enclosing_method_indices(u2 class_index,
1883                                                  u2 method_index) {
1884   Array<jushort>* inner_class_list = inner_classes();
1885   assert (inner_class_list != NULL, "_inner_classes list is not set up");
1886   int length = inner_class_list->length();
1887   if (length % inner_class_next_offset == enclosing_method_attribute_size) {
1888     int index = length - enclosing_method_attribute_size;
1889     inner_class_list->at_put(
1890       index + enclosing_method_class_index_offset, class_index);
1891     inner_class_list->at_put(
1892       index + enclosing_method_method_index_offset, method_index);
1893   }
1894 }
1895 
1896 // Lookup or create a jmethodID.
1897 // This code is called by the VMThread and JavaThreads so the
1898 // locking has to be done very carefully to avoid deadlocks
1899 // and/or other cache consistency problems.
1900 //
1901 jmethodID InstanceKlass::get_jmethod_id(const methodHandle& method_h) {
1902   size_t idnum = (size_t)method_h->method_idnum();
1903   jmethodID* jmeths = methods_jmethod_ids_acquire();
1904   size_t length = 0;
1905   jmethodID id = NULL;
1906 
1907   // We use a double-check locking idiom here because this cache is
1908   // performance sensitive. In the normal system, this cache only
1909   // transitions from NULL to non-NULL which is safe because we use
1910   // release_set_methods_jmethod_ids() to advertise the new cache.
1911   // A partially constructed cache should never be seen by a racing
1912   // thread. We also use release_store() to save a new jmethodID
1913   // in the cache so a partially constructed jmethodID should never be
1914   // seen either. Cache reads of existing jmethodIDs proceed without a
1915   // lock, but cache writes of a new jmethodID requires uniqueness and
1916   // creation of the cache itself requires no leaks so a lock is
1917   // generally acquired in those two cases.
1918   //
1919   // If the RedefineClasses() API has been used, then this cache can
1920   // grow and we'll have transitions from non-NULL to bigger non-NULL.
1921   // Cache creation requires no leaks and we require safety between all
1922   // cache accesses and freeing of the old cache so a lock is generally
1923   // acquired when the RedefineClasses() API has been used.
1924 
1925   if (jmeths != NULL) {
1926     // the cache already exists
1927     if (!idnum_can_increment()) {
1928       // the cache can't grow so we can just get the current values
1929       get_jmethod_id_length_value(jmeths, idnum, &length, &id);
1930     } else {
1931       // cache can grow so we have to be more careful
1932       if (Threads::number_of_threads() == 0 ||
1933           SafepointSynchronize::is_at_safepoint()) {
1934         // we're single threaded or at a safepoint - no locking needed
1935         get_jmethod_id_length_value(jmeths, idnum, &length, &id);
1936       } else {
1937         MutexLocker ml(JmethodIdCreation_lock);
1938         get_jmethod_id_length_value(jmeths, idnum, &length, &id);
1939       }
1940     }
1941   }
1942   // implied else:
1943   // we need to allocate a cache so default length and id values are good
1944 
1945   if (jmeths == NULL ||   // no cache yet
1946       length <= idnum ||  // cache is too short
1947       id == NULL) {       // cache doesn't contain entry
1948 
1949     // This function can be called by the VMThread so we have to do all
1950     // things that might block on a safepoint before grabbing the lock.
1951     // Otherwise, we can deadlock with the VMThread or have a cache
1952     // consistency issue. These vars keep track of what we might have
1953     // to free after the lock is dropped.
1954     jmethodID  to_dealloc_id     = NULL;
1955     jmethodID* to_dealloc_jmeths = NULL;
1956 
1957     // may not allocate new_jmeths or use it if we allocate it
1958     jmethodID* new_jmeths = NULL;
1959     if (length <= idnum) {
1960       // allocate a new cache that might be used
1961       size_t size = MAX2(idnum+1, (size_t)idnum_allocated_count());
1962       new_jmeths = NEW_C_HEAP_ARRAY(jmethodID, size+1, mtClass);
1963       memset(new_jmeths, 0, (size+1)*sizeof(jmethodID));
1964       // cache size is stored in element[0], other elements offset by one
1965       new_jmeths[0] = (jmethodID)size;
1966     }
1967 
1968     // allocate a new jmethodID that might be used
1969     jmethodID new_id = NULL;
1970     if (method_h->is_old() && !method_h->is_obsolete()) {
1971       // The method passed in is old (but not obsolete), we need to use the current version
1972       Method* current_method = method_with_idnum((int)idnum);
1973       assert(current_method != NULL, "old and but not obsolete, so should exist");
1974       new_id = Method::make_jmethod_id(class_loader_data(), current_method);
1975     } else {
1976       // It is the current version of the method or an obsolete method,
1977       // use the version passed in
1978       new_id = Method::make_jmethod_id(class_loader_data(), method_h());
1979     }
1980 
1981     if (Threads::number_of_threads() == 0 ||
1982         SafepointSynchronize::is_at_safepoint()) {
1983       // we're single threaded or at a safepoint - no locking needed
1984       id = get_jmethod_id_fetch_or_update(idnum, new_id, new_jmeths,
1985                                           &to_dealloc_id, &to_dealloc_jmeths);
1986     } else {
1987       MutexLocker ml(JmethodIdCreation_lock);
1988       id = get_jmethod_id_fetch_or_update(idnum, new_id, new_jmeths,
1989                                           &to_dealloc_id, &to_dealloc_jmeths);
1990     }
1991 
1992     // The lock has been dropped so we can free resources.
1993     // Free up either the old cache or the new cache if we allocated one.
1994     if (to_dealloc_jmeths != NULL) {
1995       FreeHeap(to_dealloc_jmeths);
1996     }
1997     // free up the new ID since it wasn't needed
1998     if (to_dealloc_id != NULL) {
1999       Method::destroy_jmethod_id(class_loader_data(), to_dealloc_id);
2000     }
2001   }
2002   return id;
2003 }
2004 
2005 // Figure out how many jmethodIDs haven't been allocated, and make
2006 // sure space for them is pre-allocated.  This makes getting all
2007 // method ids much, much faster with classes with more than 8
2008 // methods, and has a *substantial* effect on performance with jvmti
2009 // code that loads all jmethodIDs for all classes.
2010 void InstanceKlass::ensure_space_for_methodids(int start_offset) {
2011   int new_jmeths = 0;
2012   int length = methods()->length();
2013   for (int index = start_offset; index < length; index++) {
2014     Method* m = methods()->at(index);
2015     jmethodID id = m->find_jmethod_id_or_null();
2016     if (id == NULL) {
2017       new_jmeths++;
2018     }
2019   }
2020   if (new_jmeths != 0) {
2021     Method::ensure_jmethod_ids(class_loader_data(), new_jmeths);
2022   }
2023 }
2024 
2025 // Common code to fetch the jmethodID from the cache or update the
2026 // cache with the new jmethodID. This function should never do anything
2027 // that causes the caller to go to a safepoint or we can deadlock with
2028 // the VMThread or have cache consistency issues.
2029 //
2030 jmethodID InstanceKlass::get_jmethod_id_fetch_or_update(
2031             size_t idnum, jmethodID new_id,
2032             jmethodID* new_jmeths, jmethodID* to_dealloc_id_p,
2033             jmethodID** to_dealloc_jmeths_p) {
2034   assert(new_id != NULL, "sanity check");
2035   assert(to_dealloc_id_p != NULL, "sanity check");
2036   assert(to_dealloc_jmeths_p != NULL, "sanity check");
2037   assert(Threads::number_of_threads() == 0 ||
2038          SafepointSynchronize::is_at_safepoint() ||
2039          JmethodIdCreation_lock->owned_by_self(), "sanity check");
2040 
2041   // reacquire the cache - we are locked, single threaded or at a safepoint
2042   jmethodID* jmeths = methods_jmethod_ids_acquire();
2043   jmethodID  id     = NULL;
2044   size_t     length = 0;
2045 
2046   if (jmeths == NULL ||                         // no cache yet
2047       (length = (size_t)jmeths[0]) <= idnum) {  // cache is too short
2048     if (jmeths != NULL) {
2049       // copy any existing entries from the old cache
2050       for (size_t index = 0; index < length; index++) {
2051         new_jmeths[index+1] = jmeths[index+1];
2052       }
2053       *to_dealloc_jmeths_p = jmeths;  // save old cache for later delete
2054     }
2055     release_set_methods_jmethod_ids(jmeths = new_jmeths);
2056   } else {
2057     // fetch jmethodID (if any) from the existing cache
2058     id = jmeths[idnum+1];
2059     *to_dealloc_jmeths_p = new_jmeths;  // save new cache for later delete
2060   }
2061   if (id == NULL) {
2062     // No matching jmethodID in the existing cache or we have a new
2063     // cache or we just grew the cache. This cache write is done here
2064     // by the first thread to win the foot race because a jmethodID
2065     // needs to be unique once it is generally available.
2066     id = new_id;
2067 
2068     // The jmethodID cache can be read while unlocked so we have to
2069     // make sure the new jmethodID is complete before installing it
2070     // in the cache.
2071     OrderAccess::release_store(&jmeths[idnum+1], id);
2072   } else {
2073     *to_dealloc_id_p = new_id; // save new id for later delete
2074   }
2075   return id;
2076 }
2077 
2078 
2079 // Common code to get the jmethodID cache length and the jmethodID
2080 // value at index idnum if there is one.
2081 //
2082 void InstanceKlass::get_jmethod_id_length_value(jmethodID* cache,
2083        size_t idnum, size_t *length_p, jmethodID* id_p) {
2084   assert(cache != NULL, "sanity check");
2085   assert(length_p != NULL, "sanity check");
2086   assert(id_p != NULL, "sanity check");
2087 
2088   // cache size is stored in element[0], other elements offset by one
2089   *length_p = (size_t)cache[0];
2090   if (*length_p <= idnum) {  // cache is too short
2091     *id_p = NULL;
2092   } else {
2093     *id_p = cache[idnum+1];  // fetch jmethodID (if any)
2094   }
2095 }
2096 
2097 
2098 // Lookup a jmethodID, NULL if not found.  Do no blocking, no allocations, no handles
2099 jmethodID InstanceKlass::jmethod_id_or_null(Method* method) {
2100   size_t idnum = (size_t)method->method_idnum();
2101   jmethodID* jmeths = methods_jmethod_ids_acquire();
2102   size_t length;                                // length assigned as debugging crumb
2103   jmethodID id = NULL;
2104   if (jmeths != NULL &&                         // If there is a cache
2105       (length = (size_t)jmeths[0]) > idnum) {   // and if it is long enough,
2106     id = jmeths[idnum+1];                       // Look up the id (may be NULL)
2107   }
2108   return id;
2109 }
2110 
2111 inline DependencyContext InstanceKlass::dependencies() {
2112   DependencyContext dep_context(&_dep_context);
2113   return dep_context;
2114 }
2115 
2116 int InstanceKlass::mark_dependent_nmethods(KlassDepChange& changes) {
2117   return dependencies().mark_dependent_nmethods(changes);
2118 }
2119 
2120 void InstanceKlass::add_dependent_nmethod(nmethod* nm) {
2121   dependencies().add_dependent_nmethod(nm);
2122 }
2123 
2124 void InstanceKlass::remove_dependent_nmethod(nmethod* nm, bool delete_immediately) {
2125   dependencies().remove_dependent_nmethod(nm, delete_immediately);
2126 }
2127 
2128 #ifndef PRODUCT
2129 void InstanceKlass::print_dependent_nmethods(bool verbose) {
2130   dependencies().print_dependent_nmethods(verbose);
2131 }
2132 
2133 bool InstanceKlass::is_dependent_nmethod(nmethod* nm) {
2134   return dependencies().is_dependent_nmethod(nm);
2135 }
2136 #endif //PRODUCT
2137 
2138 void InstanceKlass::clean_weak_instanceklass_links() {
2139   clean_implementors_list();
2140   clean_method_data();
2141 
2142   // Since GC iterates InstanceKlasses sequentially, it is safe to remove stale entries here.
2143   DependencyContext dep_context(&_dep_context);
2144   dep_context.expunge_stale_entries();
2145 }
2146 
2147 void InstanceKlass::clean_implementors_list() {
2148   assert(is_loader_alive(), "this klass should be live");
2149   if (is_interface()) {
2150     if (ClassUnloading) {
2151       Klass* impl = implementor();
2152       if (impl != NULL) {
2153         if (!impl->is_loader_alive()) {
2154           // remove this guy
2155           Klass** klass = adr_implementor();
2156           assert(klass != NULL, "null klass");
2157           if (klass != NULL) {
2158             *klass = NULL;
2159           }
2160         }
2161       }
2162     }
2163   }
2164 }
2165 
2166 void InstanceKlass::clean_method_data() {
2167   for (int m = 0; m < methods()->length(); m++) {
2168     MethodData* mdo = methods()->at(m)->method_data();
2169     if (mdo != NULL) {
2170       mdo->clean_method_data(/*always_clean*/false);
2171     }
2172   }
2173 }
2174 
2175 bool InstanceKlass::supers_have_passed_fingerprint_checks() {
2176   if (java_super() != NULL && !java_super()->has_passed_fingerprint_check()) {
2177     ResourceMark rm;
2178     log_trace(class, fingerprint)("%s : super %s not fingerprinted", external_name(), java_super()->external_name());
2179     return false;
2180   }
2181 
2182   Array<InstanceKlass*>* local_interfaces = this->local_interfaces();
2183   if (local_interfaces != NULL) {
2184     int length = local_interfaces->length();
2185     for (int i = 0; i < length; i++) {
2186       InstanceKlass* intf = local_interfaces->at(i);
2187       if (!intf->has_passed_fingerprint_check()) {
2188         ResourceMark rm;
2189         log_trace(class, fingerprint)("%s : interface %s not fingerprinted", external_name(), intf->external_name());
2190         return false;
2191       }
2192     }
2193   }
2194 
2195   return true;
2196 }
2197 
2198 bool InstanceKlass::should_store_fingerprint(bool is_unsafe_anonymous) {
2199 #if INCLUDE_AOT
2200   // We store the fingerprint into the InstanceKlass only in the following 2 cases:
2201   if (CalculateClassFingerprint) {
2202     // (1) We are running AOT to generate a shared library.
2203     return true;
2204   }
2205   if (DumpSharedSpaces) {
2206     // (2) We are running -Xshare:dump to create a shared archive
2207     return true;
2208   }
2209   if (UseAOT && is_unsafe_anonymous) {
2210     // (3) We are using AOT code from a shared library and see an unsafe anonymous class
2211     return true;
2212   }
2213 #endif
2214 
2215   // In all other cases we might set the _misc_has_passed_fingerprint_check bit,
2216   // but do not store the 64-bit fingerprint to save space.
2217   return false;
2218 }
2219 
2220 bool InstanceKlass::has_stored_fingerprint() const {
2221 #if INCLUDE_AOT
2222   return should_store_fingerprint() || is_shared();
2223 #else
2224   return false;
2225 #endif
2226 }
2227 
2228 uint64_t InstanceKlass::get_stored_fingerprint() const {
2229   address adr = adr_fingerprint();
2230   if (adr != NULL) {
2231     return (uint64_t)Bytes::get_native_u8(adr); // adr may not be 64-bit aligned
2232   }
2233   return 0;
2234 }
2235 
2236 void InstanceKlass::store_fingerprint(uint64_t fingerprint) {
2237   address adr = adr_fingerprint();
2238   if (adr != NULL) {
2239     Bytes::put_native_u8(adr, (u8)fingerprint); // adr may not be 64-bit aligned
2240 
2241     ResourceMark rm;
2242     log_trace(class, fingerprint)("stored as " PTR64_FORMAT " for class %s", fingerprint, external_name());
2243   }
2244 }
2245 
2246 void InstanceKlass::metaspace_pointers_do(MetaspaceClosure* it) {
2247   Klass::metaspace_pointers_do(it);
2248 
2249   if (log_is_enabled(Trace, cds)) {
2250     ResourceMark rm;
2251     log_trace(cds)("Iter(InstanceKlass): %p (%s)", this, external_name());
2252   }
2253 
2254   it->push(&_annotations);
2255   it->push((Klass**)&_array_klasses);
2256   it->push(&_constants);
2257   it->push(&_inner_classes);
2258   it->push(&_array_name);
2259 #if INCLUDE_JVMTI
2260   it->push(&_previous_versions);
2261 #endif
2262   it->push(&_methods);
2263   it->push(&_default_methods);
2264   it->push(&_local_interfaces);
2265   it->push(&_transitive_interfaces);
2266   it->push(&_method_ordering);
2267   it->push(&_default_vtable_indices);
2268   it->push(&_fields);
2269 
2270   if (itable_length() > 0) {
2271     itableOffsetEntry* ioe = (itableOffsetEntry*)start_of_itable();
2272     int method_table_offset_in_words = ioe->offset()/wordSize;
2273     int nof_interfaces = (method_table_offset_in_words - itable_offset_in_words())
2274                          / itableOffsetEntry::size();
2275 
2276     for (int i = 0; i < nof_interfaces; i ++, ioe ++) {
2277       if (ioe->interface_klass() != NULL) {
2278         it->push(ioe->interface_klass_addr());
2279         itableMethodEntry* ime = ioe->first_method_entry(this);
2280         int n = klassItable::method_count_for_interface(ioe->interface_klass());
2281         for (int index = 0; index < n; index ++) {
2282           it->push(ime[index].method_addr());
2283         }
2284       }
2285     }
2286   }
2287 
2288   it->push(&_nest_members);
2289 }
2290 
2291 void InstanceKlass::remove_unshareable_info() {
2292   Klass::remove_unshareable_info();
2293 
2294   if (is_in_error_state()) {
2295     // Classes are attempted to link during dumping and may fail,
2296     // but these classes are still in the dictionary and class list in CLD.
2297     // Check in_error state first because in_error is > linked state, so
2298     // is_linked() is true.
2299     // If there's a linking error, there is nothing else to remove.
2300     return;
2301   }
2302 
2303   // Unlink the class
2304   if (is_linked()) {
2305     unlink_class();
2306   }
2307   {
2308     MutexLocker ml(Compile_lock);
2309     init_implementor();
2310   }
2311 
2312   constants()->remove_unshareable_info();
2313 
2314   for (int i = 0; i < methods()->length(); i++) {
2315     Method* m = methods()->at(i);
2316     m->remove_unshareable_info();
2317   }
2318 
2319   // do array classes also.
2320   if (array_klasses() != NULL) {
2321     array_klasses()->remove_unshareable_info();
2322   }
2323 
2324   // These are not allocated from metaspace, but they should should all be empty
2325   // during dump time, so we don't need to worry about them in InstanceKlass::iterate().
2326   guarantee(_source_debug_extension == NULL, "must be");
2327   guarantee(_dep_context == DependencyContext::EMPTY, "must be");
2328   guarantee(_osr_nmethods_head == NULL, "must be");
2329 
2330 #if INCLUDE_JVMTI
2331   guarantee(_breakpoints == NULL, "must be");
2332   guarantee(_previous_versions == NULL, "must be");
2333 #endif
2334 
2335   _init_thread = NULL;
2336   _methods_jmethod_ids = NULL;
2337   _jni_ids = NULL;
2338   _oop_map_cache = NULL;
2339   // clear _nest_host to ensure re-load at runtime
2340   _nest_host = NULL;
2341 }
2342 
2343 void InstanceKlass::remove_java_mirror() {
2344   Klass::remove_java_mirror();
2345 
2346   // do array classes also.
2347   if (array_klasses() != NULL) {
2348     array_klasses()->remove_java_mirror();
2349   }
2350 }
2351 
2352 void InstanceKlass::restore_unshareable_info(ClassLoaderData* loader_data, Handle protection_domain, TRAPS) {
2353   set_package(loader_data, CHECK);
2354   Klass::restore_unshareable_info(loader_data, protection_domain, CHECK);
2355 
2356   Array<Method*>* methods = this->methods();
2357   int num_methods = methods->length();
2358   for (int index2 = 0; index2 < num_methods; ++index2) {
2359     methodHandle m(THREAD, methods->at(index2));
2360     m->restore_unshareable_info(CHECK);
2361   }
2362   if (JvmtiExport::has_redefined_a_class()) {
2363     // Reinitialize vtable because RedefineClasses may have changed some
2364     // entries in this vtable for super classes so the CDS vtable might
2365     // point to old or obsolete entries.  RedefineClasses doesn't fix up
2366     // vtables in the shared system dictionary, only the main one.
2367     // It also redefines the itable too so fix that too.
2368     vtable().initialize_vtable(false, CHECK);
2369     itable().initialize_itable(false, CHECK);
2370   }
2371 
2372   // restore constant pool resolved references
2373   constants()->restore_unshareable_info(CHECK);
2374 
2375   if (array_klasses() != NULL) {
2376     // Array classes have null protection domain.
2377     // --> see ArrayKlass::complete_create_array_klass()
2378     array_klasses()->restore_unshareable_info(ClassLoaderData::the_null_class_loader_data(), Handle(), CHECK);
2379   }
2380 }
2381 
2382 // returns true IFF is_in_error_state() has been changed as a result of this call.
2383 bool InstanceKlass::check_sharing_error_state() {
2384   assert(DumpSharedSpaces, "should only be called during dumping");
2385   bool old_state = is_in_error_state();
2386 
2387   if (!is_in_error_state()) {
2388     bool bad = false;
2389     for (InstanceKlass* sup = java_super(); sup; sup = sup->java_super()) {
2390       if (sup->is_in_error_state()) {
2391         bad = true;
2392         break;
2393       }
2394     }
2395     if (!bad) {
2396       Array<InstanceKlass*>* interfaces = transitive_interfaces();
2397       for (int i = 0; i < interfaces->length(); i++) {
2398         InstanceKlass* iface = interfaces->at(i);
2399         if (iface->is_in_error_state()) {
2400           bad = true;
2401           break;
2402         }
2403       }
2404     }
2405 
2406     if (bad) {
2407       set_in_error_state();
2408     }
2409   }
2410 
2411   return (old_state != is_in_error_state());
2412 }
2413 
2414 #if INCLUDE_JVMTI
2415 static void clear_all_breakpoints(Method* m) {
2416   m->clear_all_breakpoints();
2417 }
2418 #endif
2419 
2420 void InstanceKlass::notify_unload_class(InstanceKlass* ik) {
2421   // notify the debugger
2422   if (JvmtiExport::should_post_class_unload()) {
2423     JvmtiExport::post_class_unload(ik);
2424   }
2425 
2426   // notify ClassLoadingService of class unload
2427   ClassLoadingService::notify_class_unloaded(ik);
2428 
2429 #if INCLUDE_JFR
2430   assert(ik != NULL, "invariant");
2431   EventClassUnload event;
2432   event.set_unloadedClass(ik);
2433   event.set_definingClassLoader(ik->class_loader_data());
2434   event.commit();
2435 #endif
2436 }
2437 
2438 void InstanceKlass::release_C_heap_structures(InstanceKlass* ik) {
2439   // Clean up C heap
2440   ik->release_C_heap_structures();
2441   ik->constants()->release_C_heap_structures();
2442 }
2443 
2444 void InstanceKlass::release_C_heap_structures() {
2445   // Can't release the constant pool here because the constant pool can be
2446   // deallocated separately from the InstanceKlass for default methods and
2447   // redefine classes.
2448 
2449   // Deallocate oop map cache
2450   if (_oop_map_cache != NULL) {
2451     delete _oop_map_cache;
2452     _oop_map_cache = NULL;
2453   }
2454 
2455   // Deallocate JNI identifiers for jfieldIDs
2456   JNIid::deallocate(jni_ids());
2457   set_jni_ids(NULL);
2458 
2459   jmethodID* jmeths = methods_jmethod_ids_acquire();
2460   if (jmeths != (jmethodID*)NULL) {
2461     release_set_methods_jmethod_ids(NULL);
2462     FreeHeap(jmeths);
2463   }
2464 
2465   // Release dependencies.
2466   // It is desirable to use DC::remove_all_dependents() here, but, unfortunately,
2467   // it is not safe (see JDK-8143408). The problem is that the klass dependency
2468   // context can contain live dependencies, since there's a race between nmethod &
2469   // klass unloading. If the klass is dead when nmethod unloading happens, relevant
2470   // dependencies aren't removed from the context associated with the class (see
2471   // nmethod::flush_dependencies). It ends up during klass unloading as seemingly
2472   // live dependencies pointing to unloaded nmethods and causes a crash in
2473   // DC::remove_all_dependents() when it touches unloaded nmethod.
2474   dependencies().wipe();
2475 
2476 #if INCLUDE_JVMTI
2477   // Deallocate breakpoint records
2478   if (breakpoints() != 0x0) {
2479     methods_do(clear_all_breakpoints);
2480     assert(breakpoints() == 0x0, "should have cleared breakpoints");
2481   }
2482 
2483   // deallocate the cached class file
2484   if (_cached_class_file != NULL && !MetaspaceShared::is_in_shared_metaspace(_cached_class_file)) {
2485     os::free(_cached_class_file);
2486     _cached_class_file = NULL;
2487   }
2488 #endif
2489 
2490   // Decrement symbol reference counts associated with the unloaded class.
2491   if (_name != NULL) _name->decrement_refcount();
2492   // unreference array name derived from this class name (arrays of an unloaded
2493   // class can't be referenced anymore).
2494   if (_array_name != NULL)  _array_name->decrement_refcount();
2495   if (_source_debug_extension != NULL) FREE_C_HEAP_ARRAY(char, _source_debug_extension);
2496 }
2497 
2498 void InstanceKlass::set_source_debug_extension(const char* array, int length) {
2499   if (array == NULL) {
2500     _source_debug_extension = NULL;
2501   } else {
2502     // Adding one to the attribute length in order to store a null terminator
2503     // character could cause an overflow because the attribute length is
2504     // already coded with an u4 in the classfile, but in practice, it's
2505     // unlikely to happen.
2506     assert((length+1) > length, "Overflow checking");
2507     char* sde = NEW_C_HEAP_ARRAY(char, (length + 1), mtClass);
2508     for (int i = 0; i < length; i++) {
2509       sde[i] = array[i];
2510     }
2511     sde[length] = '\0';
2512     _source_debug_extension = sde;
2513   }
2514 }
2515 
2516 const char* InstanceKlass::signature_name() const {
2517   int hash_len = 0;
2518   char hash_buf[40];
2519 
2520   // If this is an unsafe anonymous class, append a hash to make the name unique
2521   if (is_unsafe_anonymous()) {
2522     intptr_t hash = (java_mirror() != NULL) ? java_mirror()->identity_hash() : 0;
2523     jio_snprintf(hash_buf, sizeof(hash_buf), "/" UINTX_FORMAT, (uintx)hash);
2524     hash_len = (int)strlen(hash_buf);
2525   }
2526 
2527   // Get the internal name as a c string
2528   const char* src = (const char*) (name()->as_C_string());
2529   const int src_length = (int)strlen(src);
2530 
2531   char* dest = NEW_RESOURCE_ARRAY(char, src_length + hash_len + 3);
2532 
2533   // Add L as type indicator
2534   int dest_index = 0;
2535   dest[dest_index++] = 'L';
2536 
2537   // Add the actual class name
2538   for (int src_index = 0; src_index < src_length; ) {
2539     dest[dest_index++] = src[src_index++];
2540   }
2541 
2542   // If we have a hash, append it
2543   for (int hash_index = 0; hash_index < hash_len; ) {
2544     dest[dest_index++] = hash_buf[hash_index++];
2545   }
2546 
2547   // Add the semicolon and the NULL
2548   dest[dest_index++] = ';';
2549   dest[dest_index] = '\0';
2550   return dest;
2551 }
2552 
2553 // Used to obtain the package name from a fully qualified class name.
2554 Symbol* InstanceKlass::package_from_name(const Symbol* name, TRAPS) {
2555   if (name == NULL) {
2556     return NULL;
2557   } else {
2558     if (name->utf8_length() <= 0) {
2559       return NULL;
2560     }
2561     ResourceMark rm;
2562     const char* package_name = ClassLoader::package_from_name((const char*) name->as_C_string());
2563     if (package_name == NULL) {
2564       return NULL;
2565     }
2566     Symbol* pkg_name = SymbolTable::new_symbol(package_name, THREAD);
2567     return pkg_name;
2568   }
2569 }
2570 
2571 ModuleEntry* InstanceKlass::module() const {
2572   // For an unsafe anonymous class return the host class' module
2573   if (is_unsafe_anonymous()) {
2574     assert(unsafe_anonymous_host() != NULL, "unsafe anonymous class must have a host class");
2575     return unsafe_anonymous_host()->module();
2576   }
2577 
2578   // Class is in a named package
2579   if (!in_unnamed_package()) {
2580     return _package_entry->module();
2581   }
2582 
2583   // Class is in an unnamed package, return its loader's unnamed module
2584   return class_loader_data()->unnamed_module();
2585 }
2586 
2587 void InstanceKlass::set_package(ClassLoaderData* loader_data, TRAPS) {
2588 
2589   // ensure java/ packages only loaded by boot or platform builtin loaders
2590   check_prohibited_package(name(), loader_data, CHECK);
2591 
2592   TempNewSymbol pkg_name = package_from_name(name(), CHECK);
2593 
2594   if (pkg_name != NULL && loader_data != NULL) {
2595 
2596     // Find in class loader's package entry table.
2597     _package_entry = loader_data->packages()->lookup_only(pkg_name);
2598 
2599     // If the package name is not found in the loader's package
2600     // entry table, it is an indication that the package has not
2601     // been defined. Consider it defined within the unnamed module.
2602     if (_package_entry == NULL) {
2603       ResourceMark rm;
2604 
2605       if (!ModuleEntryTable::javabase_defined()) {
2606         // Before java.base is defined during bootstrapping, define all packages in
2607         // the java.base module.  If a non-java.base package is erroneously placed
2608         // in the java.base module it will be caught later when java.base
2609         // is defined by ModuleEntryTable::verify_javabase_packages check.
2610         assert(ModuleEntryTable::javabase_moduleEntry() != NULL, JAVA_BASE_NAME " module is NULL");
2611         _package_entry = loader_data->packages()->lookup(pkg_name, ModuleEntryTable::javabase_moduleEntry());
2612       } else {
2613         assert(loader_data->unnamed_module() != NULL, "unnamed module is NULL");
2614         _package_entry = loader_data->packages()->lookup(pkg_name,
2615                                                          loader_data->unnamed_module());
2616       }
2617 
2618       // A package should have been successfully created
2619       assert(_package_entry != NULL, "Package entry for class %s not found, loader %s",
2620              name()->as_C_string(), loader_data->loader_name_and_id());
2621     }
2622 
2623     if (log_is_enabled(Debug, module)) {
2624       ResourceMark rm;
2625       ModuleEntry* m = _package_entry->module();
2626       log_trace(module)("Setting package: class: %s, package: %s, loader: %s, module: %s",
2627                         external_name(),
2628                         pkg_name->as_C_string(),
2629                         loader_data->loader_name_and_id(),
2630                         (m->is_named() ? m->name()->as_C_string() : UNNAMED_MODULE));
2631     }
2632   } else {
2633     ResourceMark rm;
2634     log_trace(module)("Setting package: class: %s, package: unnamed, loader: %s, module: %s",
2635                       external_name(),
2636                       (loader_data != NULL) ? loader_data->loader_name_and_id() : "NULL",
2637                       UNNAMED_MODULE);
2638   }
2639 }
2640 
2641 
2642 // different versions of is_same_class_package
2643 
2644 bool InstanceKlass::is_same_class_package(const Klass* class2) const {
2645   oop classloader1 = this->class_loader();
2646   PackageEntry* classpkg1 = this->package();
2647   if (class2->is_objArray_klass()) {
2648     class2 = ObjArrayKlass::cast(class2)->bottom_klass();
2649   }
2650 
2651   oop classloader2;
2652   PackageEntry* classpkg2;
2653   if (class2->is_instance_klass()) {
2654     classloader2 = class2->class_loader();
2655     classpkg2 = class2->package();
2656   } else {
2657     assert(class2->is_typeArray_klass(), "should be type array");
2658     classloader2 = NULL;
2659     classpkg2 = NULL;
2660   }
2661 
2662   // Same package is determined by comparing class loader
2663   // and package entries. Both must be the same. This rule
2664   // applies even to classes that are defined in the unnamed
2665   // package, they still must have the same class loader.
2666   if (oopDesc::equals(classloader1, classloader2) && (classpkg1 == classpkg2)) {
2667     return true;
2668   }
2669 
2670   return false;
2671 }
2672 
2673 // return true if this class and other_class are in the same package. Classloader
2674 // and classname information is enough to determine a class's package
2675 bool InstanceKlass::is_same_class_package(oop other_class_loader,
2676                                           const Symbol* other_class_name) const {
2677   if (!oopDesc::equals(class_loader(), other_class_loader)) {
2678     return false;
2679   }
2680   if (name()->fast_compare(other_class_name) == 0) {
2681      return true;
2682   }
2683 
2684   {
2685     ResourceMark rm;
2686 
2687     bool bad_class_name = false;
2688     const char* other_pkg =
2689       ClassLoader::package_from_name((const char*) other_class_name->as_C_string(), &bad_class_name);
2690     if (bad_class_name) {
2691       return false;
2692     }
2693     // Check that package_from_name() returns NULL, not "", if there is no package.
2694     assert(other_pkg == NULL || strlen(other_pkg) > 0, "package name is empty string");
2695 
2696     const Symbol* const this_package_name =
2697       this->package() != NULL ? this->package()->name() : NULL;
2698 
2699     if (this_package_name == NULL || other_pkg == NULL) {
2700       // One of the two doesn't have a package.  Only return true if the other
2701       // one also doesn't have a package.
2702       return (const char*)this_package_name == other_pkg;
2703     }
2704 
2705     // Check if package is identical
2706     return this_package_name->equals(other_pkg);
2707   }
2708 }
2709 
2710 // Returns true iff super_method can be overridden by a method in targetclassname
2711 // See JLS 3rd edition 8.4.6.1
2712 // Assumes name-signature match
2713 // "this" is InstanceKlass of super_method which must exist
2714 // note that the InstanceKlass of the method in the targetclassname has not always been created yet
2715 bool InstanceKlass::is_override(const methodHandle& super_method, Handle targetclassloader, Symbol* targetclassname, TRAPS) {
2716    // Private methods can not be overridden
2717    if (super_method->is_private()) {
2718      return false;
2719    }
2720    // If super method is accessible, then override
2721    if ((super_method->is_protected()) ||
2722        (super_method->is_public())) {
2723      return true;
2724    }
2725    // Package-private methods are not inherited outside of package
2726    assert(super_method->is_package_private(), "must be package private");
2727    return(is_same_class_package(targetclassloader(), targetclassname));
2728 }
2729 
2730 // Only boot and platform class loaders can define classes in "java/" packages.
2731 void InstanceKlass::check_prohibited_package(Symbol* class_name,
2732                                              ClassLoaderData* loader_data,
2733                                              TRAPS) {
2734   if (!loader_data->is_boot_class_loader_data() &&
2735       !loader_data->is_platform_class_loader_data() &&
2736       class_name != NULL) {
2737     ResourceMark rm(THREAD);
2738     char* name = class_name->as_C_string();
2739     if (strncmp(name, JAVAPKG, JAVAPKG_LEN) == 0 && name[JAVAPKG_LEN] == '/') {
2740       TempNewSymbol pkg_name = InstanceKlass::package_from_name(class_name, CHECK);
2741       assert(pkg_name != NULL, "Error in parsing package name starting with 'java/'");
2742       name = pkg_name->as_C_string();
2743       const char* class_loader_name = loader_data->loader_name_and_id();
2744       StringUtils::replace_no_expand(name, "/", ".");
2745       const char* msg_text1 = "Class loader (instance of): ";
2746       const char* msg_text2 = " tried to load prohibited package name: ";
2747       size_t len = strlen(msg_text1) + strlen(class_loader_name) + strlen(msg_text2) + strlen(name) + 1;
2748       char* message = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, len);
2749       jio_snprintf(message, len, "%s%s%s%s", msg_text1, class_loader_name, msg_text2, name);
2750       THROW_MSG(vmSymbols::java_lang_SecurityException(), message);
2751     }
2752   }
2753   return;
2754 }
2755 
2756 // tell if two classes have the same enclosing class (at package level)
2757 bool InstanceKlass::is_same_package_member(const Klass* class2, TRAPS) const {
2758   if (class2 == this) return true;
2759   if (!class2->is_instance_klass())  return false;
2760 
2761   // must be in same package before we try anything else
2762   if (!is_same_class_package(class2))
2763     return false;
2764 
2765   // As long as there is an outer_this.getEnclosingClass,
2766   // shift the search outward.
2767   const InstanceKlass* outer_this = this;
2768   for (;;) {
2769     // As we walk along, look for equalities between outer_this and class2.
2770     // Eventually, the walks will terminate as outer_this stops
2771     // at the top-level class around the original class.
2772     bool ignore_inner_is_member;
2773     const Klass* next = outer_this->compute_enclosing_class(&ignore_inner_is_member,
2774                                                             CHECK_false);
2775     if (next == NULL)  break;
2776     if (next == class2)  return true;
2777     outer_this = InstanceKlass::cast(next);
2778   }
2779 
2780   // Now do the same for class2.
2781   const InstanceKlass* outer2 = InstanceKlass::cast(class2);
2782   for (;;) {
2783     bool ignore_inner_is_member;
2784     Klass* next = outer2->compute_enclosing_class(&ignore_inner_is_member,
2785                                                     CHECK_false);
2786     if (next == NULL)  break;
2787     // Might as well check the new outer against all available values.
2788     if (next == this)  return true;
2789     if (next == outer_this)  return true;
2790     outer2 = InstanceKlass::cast(next);
2791   }
2792 
2793   // If by this point we have not found an equality between the
2794   // two classes, we know they are in separate package members.
2795   return false;
2796 }
2797 
2798 bool InstanceKlass::find_inner_classes_attr(int* ooff, int* noff, TRAPS) const {
2799   constantPoolHandle i_cp(THREAD, constants());
2800   for (InnerClassesIterator iter(this); !iter.done(); iter.next()) {
2801     int ioff = iter.inner_class_info_index();
2802     if (ioff != 0) {
2803       // Check to see if the name matches the class we're looking for
2804       // before attempting to find the class.
2805       if (i_cp->klass_name_at_matches(this, ioff)) {
2806         Klass* inner_klass = i_cp->klass_at(ioff, CHECK_false);
2807         if (this == inner_klass) {
2808           *ooff = iter.outer_class_info_index();
2809           *noff = iter.inner_name_index();
2810           return true;
2811         }
2812       }
2813     }
2814   }
2815   return false;
2816 }
2817 
2818 InstanceKlass* InstanceKlass::compute_enclosing_class(bool* inner_is_member, TRAPS) const {
2819   InstanceKlass* outer_klass = NULL;
2820   *inner_is_member = false;
2821   int ooff = 0, noff = 0;
2822   bool has_inner_classes_attr = find_inner_classes_attr(&ooff, &noff, THREAD);
2823   if (has_inner_classes_attr) {
2824     constantPoolHandle i_cp(THREAD, constants());
2825     if (ooff != 0) {
2826       Klass* ok = i_cp->klass_at(ooff, CHECK_NULL);
2827       outer_klass = InstanceKlass::cast(ok);
2828       *inner_is_member = true;
2829     }
2830     if (NULL == outer_klass) {
2831       // It may be unsafe anonymous; try for that.
2832       int encl_method_class_idx = enclosing_method_class_index();
2833       if (encl_method_class_idx != 0) {
2834         Klass* ok = i_cp->klass_at(encl_method_class_idx, CHECK_NULL);
2835         outer_klass = InstanceKlass::cast(ok);
2836         *inner_is_member = false;
2837       }
2838     }
2839   }
2840 
2841   // If no inner class attribute found for this class.
2842   if (NULL == outer_klass) return NULL;
2843 
2844   // Throws an exception if outer klass has not declared k as an inner klass
2845   // We need evidence that each klass knows about the other, or else
2846   // the system could allow a spoof of an inner class to gain access rights.
2847   Reflection::check_for_inner_class(outer_klass, this, *inner_is_member, CHECK_NULL);
2848   return outer_klass;
2849 }
2850 
2851 jint InstanceKlass::compute_modifier_flags(TRAPS) const {
2852   jint access = access_flags().as_int();
2853 
2854   // But check if it happens to be member class.
2855   InnerClassesIterator iter(this);
2856   for (; !iter.done(); iter.next()) {
2857     int ioff = iter.inner_class_info_index();
2858     // Inner class attribute can be zero, skip it.
2859     // Strange but true:  JVM spec. allows null inner class refs.
2860     if (ioff == 0) continue;
2861 
2862     // only look at classes that are already loaded
2863     // since we are looking for the flags for our self.
2864     Symbol* inner_name = constants()->klass_name_at(ioff);
2865     if (name() == inner_name) {
2866       // This is really a member class.
2867       access = iter.inner_access_flags();
2868       break;
2869     }
2870   }
2871   // Remember to strip ACC_SUPER bit
2872   return (access & (~JVM_ACC_SUPER)) & JVM_ACC_WRITTEN_FLAGS;
2873 }
2874 
2875 jint InstanceKlass::jvmti_class_status() const {
2876   jint result = 0;
2877 
2878   if (is_linked()) {
2879     result |= JVMTI_CLASS_STATUS_VERIFIED | JVMTI_CLASS_STATUS_PREPARED;
2880   }
2881 
2882   if (is_initialized()) {
2883     assert(is_linked(), "Class status is not consistent");
2884     result |= JVMTI_CLASS_STATUS_INITIALIZED;
2885   }
2886   if (is_in_error_state()) {
2887     result |= JVMTI_CLASS_STATUS_ERROR;
2888   }
2889   return result;
2890 }
2891 
2892 Method* InstanceKlass::method_at_itable(Klass* holder, int index, TRAPS) {
2893   itableOffsetEntry* ioe = (itableOffsetEntry*)start_of_itable();
2894   int method_table_offset_in_words = ioe->offset()/wordSize;
2895   int nof_interfaces = (method_table_offset_in_words - itable_offset_in_words())
2896                        / itableOffsetEntry::size();
2897 
2898   for (int cnt = 0 ; ; cnt ++, ioe ++) {
2899     // If the interface isn't implemented by the receiver class,
2900     // the VM should throw IncompatibleClassChangeError.
2901     if (cnt >= nof_interfaces) {
2902       ResourceMark rm(THREAD);
2903       stringStream ss;
2904       bool same_module = (module() == holder->module());
2905       ss.print("Receiver class %s does not implement "
2906                "the interface %s defining the method to be called "
2907                "(%s%s%s)",
2908                external_name(), holder->external_name(),
2909                (same_module) ? joint_in_module_of_loader(holder) : class_in_module_of_loader(),
2910                (same_module) ? "" : "; ",
2911                (same_module) ? "" : holder->class_in_module_of_loader());
2912       THROW_MSG_NULL(vmSymbols::java_lang_IncompatibleClassChangeError(), ss.as_string());
2913     }
2914 
2915     Klass* ik = ioe->interface_klass();
2916     if (ik == holder) break;
2917   }
2918 
2919   itableMethodEntry* ime = ioe->first_method_entry(this);
2920   Method* m = ime[index].method();
2921   if (m == NULL) {
2922     THROW_NULL(vmSymbols::java_lang_AbstractMethodError());
2923   }
2924   return m;
2925 }
2926 
2927 
2928 #if INCLUDE_JVMTI
2929 // update default_methods for redefineclasses for methods that are
2930 // not yet in the vtable due to concurrent subclass define and superinterface
2931 // redefinition
2932 // Note: those in the vtable, should have been updated via adjust_method_entries
2933 void InstanceKlass::adjust_default_methods(InstanceKlass* holder, bool* trace_name_printed) {
2934   // search the default_methods for uses of either obsolete or EMCP methods
2935   if (default_methods() != NULL) {
2936     for (int index = 0; index < default_methods()->length(); index ++) {
2937       Method* old_method = default_methods()->at(index);
2938       if (old_method == NULL || old_method->method_holder() != holder || !old_method->is_old()) {
2939         continue; // skip uninteresting entries
2940       }
2941       assert(!old_method->is_deleted(), "default methods may not be deleted");
2942 
2943       Method* new_method = holder->method_with_idnum(old_method->orig_method_idnum());
2944 
2945       assert(new_method != NULL, "method_with_idnum() should not be NULL");
2946       assert(old_method != new_method, "sanity check");
2947 
2948       default_methods()->at_put(index, new_method);
2949       if (log_is_enabled(Info, redefine, class, update)) {
2950         ResourceMark rm;
2951         if (!(*trace_name_printed)) {
2952           log_info(redefine, class, update)
2953             ("adjust: klassname=%s default methods from name=%s",
2954              external_name(), old_method->method_holder()->external_name());
2955           *trace_name_printed = true;
2956         }
2957         log_debug(redefine, class, update, vtables)
2958           ("default method update: %s(%s) ",
2959            new_method->name()->as_C_string(), new_method->signature()->as_C_string());
2960       }
2961     }
2962   }
2963 }
2964 #endif // INCLUDE_JVMTI
2965 
2966 // On-stack replacement stuff
2967 void InstanceKlass::add_osr_nmethod(nmethod* n) {
2968   // only one compilation can be active
2969   {
2970     // This is a short non-blocking critical region, so the no safepoint check is ok.
2971     MutexLockerEx ml(OsrList_lock, Mutex::_no_safepoint_check_flag);
2972     assert(n->is_osr_method(), "wrong kind of nmethod");
2973     n->set_osr_link(osr_nmethods_head());
2974     set_osr_nmethods_head(n);
2975     // Raise the highest osr level if necessary
2976     if (TieredCompilation) {
2977       Method* m = n->method();
2978       m->set_highest_osr_comp_level(MAX2(m->highest_osr_comp_level(), n->comp_level()));
2979     }
2980   }
2981 
2982   // Get rid of the osr methods for the same bci that have lower levels.
2983   if (TieredCompilation) {
2984     for (int l = CompLevel_limited_profile; l < n->comp_level(); l++) {
2985       nmethod *inv = lookup_osr_nmethod(n->method(), n->osr_entry_bci(), l, true);
2986       if (inv != NULL && inv->is_in_use()) {
2987         inv->make_not_entrant();
2988       }
2989     }
2990   }
2991 }
2992 
2993 // Remove osr nmethod from the list. Return true if found and removed.
2994 bool InstanceKlass::remove_osr_nmethod(nmethod* n) {
2995   // This is a short non-blocking critical region, so the no safepoint check is ok.
2996   MutexLockerEx ml(OsrList_lock, Mutex::_no_safepoint_check_flag);
2997   assert(n->is_osr_method(), "wrong kind of nmethod");
2998   nmethod* last = NULL;
2999   nmethod* cur  = osr_nmethods_head();
3000   int max_level = CompLevel_none;  // Find the max comp level excluding n
3001   Method* m = n->method();
3002   // Search for match
3003   bool found = false;
3004   while(cur != NULL && cur != n) {
3005     if (TieredCompilation && m == cur->method()) {
3006       // Find max level before n
3007       max_level = MAX2(max_level, cur->comp_level());
3008     }
3009     last = cur;
3010     cur = cur->osr_link();
3011   }
3012   nmethod* next = NULL;
3013   if (cur == n) {
3014     found = true;
3015     next = cur->osr_link();
3016     if (last == NULL) {
3017       // Remove first element
3018       set_osr_nmethods_head(next);
3019     } else {
3020       last->set_osr_link(next);
3021     }
3022   }
3023   n->set_osr_link(NULL);
3024   if (TieredCompilation) {
3025     cur = next;
3026     while (cur != NULL) {
3027       // Find max level after n
3028       if (m == cur->method()) {
3029         max_level = MAX2(max_level, cur->comp_level());
3030       }
3031       cur = cur->osr_link();
3032     }
3033     m->set_highest_osr_comp_level(max_level);
3034   }
3035   return found;
3036 }
3037 
3038 int InstanceKlass::mark_osr_nmethods(const Method* m) {
3039   // This is a short non-blocking critical region, so the no safepoint check is ok.
3040   MutexLockerEx ml(OsrList_lock, Mutex::_no_safepoint_check_flag);
3041   nmethod* osr = osr_nmethods_head();
3042   int found = 0;
3043   while (osr != NULL) {
3044     assert(osr->is_osr_method(), "wrong kind of nmethod found in chain");
3045     if (osr->method() == m) {
3046       osr->mark_for_deoptimization();
3047       found++;
3048     }
3049     osr = osr->osr_link();
3050   }
3051   return found;
3052 }
3053 
3054 nmethod* InstanceKlass::lookup_osr_nmethod(const Method* m, int bci, int comp_level, bool match_level) const {
3055   // This is a short non-blocking critical region, so the no safepoint check is ok.
3056   MutexLockerEx ml(OsrList_lock, Mutex::_no_safepoint_check_flag);
3057   nmethod* osr = osr_nmethods_head();
3058   nmethod* best = NULL;
3059   while (osr != NULL) {
3060     assert(osr->is_osr_method(), "wrong kind of nmethod found in chain");
3061     // There can be a time when a c1 osr method exists but we are waiting
3062     // for a c2 version. When c2 completes its osr nmethod we will trash
3063     // the c1 version and only be able to find the c2 version. However
3064     // while we overflow in the c1 code at back branches we don't want to
3065     // try and switch to the same code as we are already running
3066 
3067     if (osr->method() == m &&
3068         (bci == InvocationEntryBci || osr->osr_entry_bci() == bci)) {
3069       if (match_level) {
3070         if (osr->comp_level() == comp_level) {
3071           // Found a match - return it.
3072           return osr;
3073         }
3074       } else {
3075         if (best == NULL || (osr->comp_level() > best->comp_level())) {
3076           if (osr->comp_level() == CompLevel_highest_tier) {
3077             // Found the best possible - return it.
3078             return osr;
3079           }
3080           best = osr;
3081         }
3082       }
3083     }
3084     osr = osr->osr_link();
3085   }
3086   if (best != NULL && best->comp_level() >= comp_level && match_level == false) {
3087     return best;
3088   }
3089   return NULL;
3090 }
3091 
3092 // -----------------------------------------------------------------------------------------------------
3093 // Printing
3094 
3095 #ifndef PRODUCT
3096 
3097 #define BULLET  " - "
3098 
3099 static const char* state_names[] = {
3100   "allocated", "loaded", "linked", "being_initialized", "fully_initialized", "initialization_error"
3101 };
3102 
3103 static void print_vtable(intptr_t* start, int len, outputStream* st) {
3104   for (int i = 0; i < len; i++) {
3105     intptr_t e = start[i];
3106     st->print("%d : " INTPTR_FORMAT, i, e);
3107     if (e != 0 && ((Metadata*)e)->is_metaspace_object()) {
3108       st->print(" ");
3109       ((Metadata*)e)->print_value_on(st);
3110     }
3111     st->cr();
3112   }
3113 }
3114 
3115 static void print_vtable(vtableEntry* start, int len, outputStream* st) {
3116   return print_vtable(reinterpret_cast<intptr_t*>(start), len, st);
3117 }
3118 
3119 void InstanceKlass::print_on(outputStream* st) const {
3120   assert(is_klass(), "must be klass");
3121   Klass::print_on(st);
3122 
3123   st->print(BULLET"instance size:     %d", size_helper());                        st->cr();
3124   st->print(BULLET"klass size:        %d", size());                               st->cr();
3125   st->print(BULLET"access:            "); access_flags().print_on(st);            st->cr();
3126   st->print(BULLET"state:             "); st->print_cr("%s", state_names[_init_state]);
3127   st->print(BULLET"name:              "); name()->print_value_on(st);             st->cr();
3128   st->print(BULLET"super:             "); Metadata::print_value_on_maybe_null(st, super()); st->cr();
3129   st->print(BULLET"sub:               ");
3130   Klass* sub = subklass();
3131   int n;
3132   for (n = 0; sub != NULL; n++, sub = sub->next_sibling()) {
3133     if (n < MaxSubklassPrintSize) {
3134       sub->print_value_on(st);
3135       st->print("   ");
3136     }
3137   }
3138   if (n >= MaxSubklassPrintSize) st->print("(" INTX_FORMAT " more klasses...)", n - MaxSubklassPrintSize);
3139   st->cr();
3140 
3141   if (is_interface()) {
3142     MutexLocker ml(Compile_lock);
3143     st->print_cr(BULLET"nof implementors:  %d", nof_implementors());
3144     if (nof_implementors() == 1) {
3145       st->print_cr(BULLET"implementor:    ");
3146       st->print("   ");
3147       implementor()->print_value_on(st);
3148       st->cr();
3149     }
3150   }
3151 
3152   st->print(BULLET"arrays:            "); Metadata::print_value_on_maybe_null(st, array_klasses()); st->cr();
3153   st->print(BULLET"methods:           "); methods()->print_value_on(st);                  st->cr();
3154   if (Verbose || WizardMode) {
3155     Array<Method*>* method_array = methods();
3156     for (int i = 0; i < method_array->length(); i++) {
3157       st->print("%d : ", i); method_array->at(i)->print_value(); st->cr();
3158     }
3159   }
3160   st->print(BULLET"method ordering:   "); method_ordering()->print_value_on(st);      st->cr();
3161   st->print(BULLET"default_methods:   "); default_methods()->print_value_on(st);      st->cr();
3162   if (Verbose && default_methods() != NULL) {
3163     Array<Method*>* method_array = default_methods();
3164     for (int i = 0; i < method_array->length(); i++) {
3165       st->print("%d : ", i); method_array->at(i)->print_value(); st->cr();
3166     }
3167   }
3168   if (default_vtable_indices() != NULL) {
3169     st->print(BULLET"default vtable indices:   "); default_vtable_indices()->print_value_on(st);       st->cr();
3170   }
3171   st->print(BULLET"local interfaces:  "); local_interfaces()->print_value_on(st);      st->cr();
3172   st->print(BULLET"trans. interfaces: "); transitive_interfaces()->print_value_on(st); st->cr();
3173   st->print(BULLET"constants:         "); constants()->print_value_on(st);         st->cr();
3174   if (class_loader_data() != NULL) {
3175     st->print(BULLET"class loader data:  ");
3176     class_loader_data()->print_value_on(st);
3177     st->cr();
3178   }
3179   st->print(BULLET"unsafe anonymous host class:        "); Metadata::print_value_on_maybe_null(st, unsafe_anonymous_host()); st->cr();
3180   if (source_file_name() != NULL) {
3181     st->print(BULLET"source file:       ");
3182     source_file_name()->print_value_on(st);
3183     st->cr();
3184   }
3185   if (source_debug_extension() != NULL) {
3186     st->print(BULLET"source debug extension:       ");
3187     st->print("%s", source_debug_extension());
3188     st->cr();
3189   }
3190   st->print(BULLET"class annotations:       "); class_annotations()->print_value_on(st); st->cr();
3191   st->print(BULLET"class type annotations:  "); class_type_annotations()->print_value_on(st); st->cr();
3192   st->print(BULLET"field annotations:       "); fields_annotations()->print_value_on(st); st->cr();
3193   st->print(BULLET"field type annotations:  "); fields_type_annotations()->print_value_on(st); st->cr();
3194   {
3195     bool have_pv = false;
3196     // previous versions are linked together through the InstanceKlass
3197     for (InstanceKlass* pv_node = previous_versions();
3198          pv_node != NULL;
3199          pv_node = pv_node->previous_versions()) {
3200       if (!have_pv)
3201         st->print(BULLET"previous version:  ");
3202       have_pv = true;
3203       pv_node->constants()->print_value_on(st);
3204     }
3205     if (have_pv) st->cr();
3206   }
3207 
3208   if (generic_signature() != NULL) {
3209     st->print(BULLET"generic signature: ");
3210     generic_signature()->print_value_on(st);
3211     st->cr();
3212   }
3213   st->print(BULLET"inner classes:     "); inner_classes()->print_value_on(st);     st->cr();
3214   st->print(BULLET"nest members:     "); nest_members()->print_value_on(st);     st->cr();
3215   if (java_mirror() != NULL) {
3216     st->print(BULLET"java mirror:       ");
3217     java_mirror()->print_value_on(st);
3218     st->cr();
3219   } else {
3220     st->print_cr(BULLET"java mirror:       NULL");
3221   }
3222   st->print(BULLET"vtable length      %d  (start addr: " INTPTR_FORMAT ")", vtable_length(), p2i(start_of_vtable())); st->cr();
3223   if (vtable_length() > 0 && (Verbose || WizardMode))  print_vtable(start_of_vtable(), vtable_length(), st);
3224   st->print(BULLET"itable length      %d (start addr: " INTPTR_FORMAT ")", itable_length(), p2i(start_of_itable())); st->cr();
3225   if (itable_length() > 0 && (Verbose || WizardMode))  print_vtable(start_of_itable(), itable_length(), st);
3226   st->print_cr(BULLET"---- static fields (%d words):", static_field_size());
3227   FieldPrinter print_static_field(st);
3228   ((InstanceKlass*)this)->do_local_static_fields(&print_static_field);
3229   st->print_cr(BULLET"---- non-static fields (%d words):", nonstatic_field_size());
3230   FieldPrinter print_nonstatic_field(st);
3231   InstanceKlass* ik = const_cast<InstanceKlass*>(this);
3232   ik->do_nonstatic_fields(&print_nonstatic_field);
3233 
3234   st->print(BULLET"non-static oop maps: ");
3235   OopMapBlock* map     = start_of_nonstatic_oop_maps();
3236   OopMapBlock* end_map = map + nonstatic_oop_map_count();
3237   while (map < end_map) {
3238     st->print("%d-%d ", map->offset(), map->offset() + heapOopSize*(map->count() - 1));
3239     map++;
3240   }
3241   st->cr();
3242 }
3243 
3244 #endif //PRODUCT
3245 
3246 void InstanceKlass::print_value_on(outputStream* st) const {
3247   assert(is_klass(), "must be klass");
3248   if (Verbose || WizardMode)  access_flags().print_on(st);
3249   name()->print_value_on(st);
3250 }
3251 
3252 #ifndef PRODUCT
3253 
3254 void FieldPrinter::do_field(fieldDescriptor* fd) {
3255   _st->print(BULLET);
3256    if (_obj == NULL) {
3257      fd->print_on(_st);
3258      _st->cr();
3259    } else {
3260      fd->print_on_for(_st, _obj);
3261      _st->cr();
3262    }
3263 }
3264 
3265 
3266 void InstanceKlass::oop_print_on(oop obj, outputStream* st) {
3267   Klass::oop_print_on(obj, st);
3268 
3269   if (this == SystemDictionary::String_klass()) {
3270     typeArrayOop value  = java_lang_String::value(obj);
3271     juint        length = java_lang_String::length(obj);
3272     if (value != NULL &&
3273         value->is_typeArray() &&
3274         length <= (juint) value->length()) {
3275       st->print(BULLET"string: ");
3276       java_lang_String::print(obj, st);
3277       st->cr();
3278       if (!WizardMode)  return;  // that is enough
3279     }
3280   }
3281 
3282   st->print_cr(BULLET"---- fields (total size %d words):", oop_size(obj));
3283   FieldPrinter print_field(st, obj);
3284   do_nonstatic_fields(&print_field);
3285 
3286   if (this == SystemDictionary::Class_klass()) {
3287     st->print(BULLET"signature: ");
3288     java_lang_Class::print_signature(obj, st);
3289     st->cr();
3290     Klass* mirrored_klass = java_lang_Class::as_Klass(obj);
3291     st->print(BULLET"fake entry for mirror: ");
3292     Metadata::print_value_on_maybe_null(st, mirrored_klass);
3293     st->cr();
3294     Klass* array_klass = java_lang_Class::array_klass_acquire(obj);
3295     st->print(BULLET"fake entry for array: ");
3296     Metadata::print_value_on_maybe_null(st, array_klass);
3297     st->cr();
3298     st->print_cr(BULLET"fake entry for oop_size: %d", java_lang_Class::oop_size(obj));
3299     st->print_cr(BULLET"fake entry for static_oop_field_count: %d", java_lang_Class::static_oop_field_count(obj));
3300     Klass* real_klass = java_lang_Class::as_Klass(obj);
3301     if (real_klass != NULL && real_klass->is_instance_klass()) {
3302       InstanceKlass::cast(real_klass)->do_local_static_fields(&print_field);
3303     }
3304   } else if (this == SystemDictionary::MethodType_klass()) {
3305     st->print(BULLET"signature: ");
3306     java_lang_invoke_MethodType::print_signature(obj, st);
3307     st->cr();
3308   }
3309 }
3310 
3311 bool InstanceKlass::verify_itable_index(int i) {
3312   int method_count = klassItable::method_count_for_interface(this);
3313   assert(i >= 0 && i < method_count, "index out of bounds");
3314   return true;
3315 }
3316 
3317 #endif //PRODUCT
3318 
3319 void InstanceKlass::oop_print_value_on(oop obj, outputStream* st) {
3320   st->print("a ");
3321   name()->print_value_on(st);
3322   obj->print_address_on(st);
3323   if (this == SystemDictionary::String_klass()
3324       && java_lang_String::value(obj) != NULL) {
3325     ResourceMark rm;
3326     int len = java_lang_String::length(obj);
3327     int plen = (len < 24 ? len : 12);
3328     char* str = java_lang_String::as_utf8_string(obj, 0, plen);
3329     st->print(" = \"%s\"", str);
3330     if (len > plen)
3331       st->print("...[%d]", len);
3332   } else if (this == SystemDictionary::Class_klass()) {
3333     Klass* k = java_lang_Class::as_Klass(obj);
3334     st->print(" = ");
3335     if (k != NULL) {
3336       k->print_value_on(st);
3337     } else {
3338       const char* tname = type2name(java_lang_Class::primitive_type(obj));
3339       st->print("%s", tname ? tname : "type?");
3340     }
3341   } else if (this == SystemDictionary::MethodType_klass()) {
3342     st->print(" = ");
3343     java_lang_invoke_MethodType::print_signature(obj, st);
3344   } else if (java_lang_boxing_object::is_instance(obj)) {
3345     st->print(" = ");
3346     java_lang_boxing_object::print(obj, st);
3347   } else if (this == SystemDictionary::LambdaForm_klass()) {
3348     oop vmentry = java_lang_invoke_LambdaForm::vmentry(obj);
3349     if (vmentry != NULL) {
3350       st->print(" => ");
3351       vmentry->print_value_on(st);
3352     }
3353   } else if (this == SystemDictionary::MemberName_klass()) {
3354     Metadata* vmtarget = java_lang_invoke_MemberName::vmtarget(obj);
3355     if (vmtarget != NULL) {
3356       st->print(" = ");
3357       vmtarget->print_value_on(st);
3358     } else {
3359       java_lang_invoke_MemberName::clazz(obj)->print_value_on(st);
3360       st->print(".");
3361       java_lang_invoke_MemberName::name(obj)->print_value_on(st);
3362     }
3363   }
3364 }
3365 
3366 const char* InstanceKlass::internal_name() const {
3367   return external_name();
3368 }
3369 
3370 void InstanceKlass::print_class_load_logging(ClassLoaderData* loader_data,
3371                                              const char* module_name,
3372                                              const ClassFileStream* cfs) const {
3373   if (!log_is_enabled(Info, class, load)) {
3374     return;
3375   }
3376 
3377   ResourceMark rm;
3378   LogMessage(class, load) msg;
3379   stringStream info_stream;
3380 
3381   // Name and class hierarchy info
3382   info_stream.print("%s", external_name());
3383 
3384   // Source
3385   if (cfs != NULL) {
3386     if (cfs->source() != NULL) {
3387       if (module_name != NULL) {
3388         if (ClassLoader::is_modules_image(cfs->source())) {
3389           info_stream.print(" source: jrt:/%s", module_name);
3390         } else {
3391           info_stream.print(" source: %s", cfs->source());
3392         }
3393       } else {
3394         info_stream.print(" source: %s", cfs->source());
3395       }
3396     } else if (loader_data == ClassLoaderData::the_null_class_loader_data()) {
3397       Thread* THREAD = Thread::current();
3398       Klass* caller =
3399             THREAD->is_Java_thread()
3400                 ? ((JavaThread*)THREAD)->security_get_caller_class(1)
3401                 : NULL;
3402       // caller can be NULL, for example, during a JVMTI VM_Init hook
3403       if (caller != NULL) {
3404         info_stream.print(" source: instance of %s", caller->external_name());
3405       } else {
3406         // source is unknown
3407       }
3408     } else {
3409       oop class_loader = loader_data->class_loader();
3410       info_stream.print(" source: %s", class_loader->klass()->external_name());
3411     }
3412   } else {
3413     info_stream.print(" source: shared objects file");
3414   }
3415 
3416   msg.info("%s", info_stream.as_string());
3417 
3418   if (log_is_enabled(Debug, class, load)) {
3419     stringStream debug_stream;
3420 
3421     // Class hierarchy info
3422     debug_stream.print(" klass: " INTPTR_FORMAT " super: " INTPTR_FORMAT,
3423                        p2i(this),  p2i(superklass()));
3424 
3425     // Interfaces
3426     if (local_interfaces() != NULL && local_interfaces()->length() > 0) {
3427       debug_stream.print(" interfaces:");
3428       int length = local_interfaces()->length();
3429       for (int i = 0; i < length; i++) {
3430         debug_stream.print(" " INTPTR_FORMAT,
3431                            p2i(InstanceKlass::cast(local_interfaces()->at(i))));
3432       }
3433     }
3434 
3435     // Class loader
3436     debug_stream.print(" loader: [");
3437     loader_data->print_value_on(&debug_stream);
3438     debug_stream.print("]");
3439 
3440     // Classfile checksum
3441     if (cfs) {
3442       debug_stream.print(" bytes: %d checksum: %08x",
3443                          cfs->length(),
3444                          ClassLoader::crc32(0, (const char*)cfs->buffer(),
3445                          cfs->length()));
3446     }
3447 
3448     msg.debug("%s", debug_stream.as_string());
3449   }
3450 }
3451 
3452 #if INCLUDE_SERVICES
3453 // Size Statistics
3454 void InstanceKlass::collect_statistics(KlassSizeStats *sz) const {
3455   Klass::collect_statistics(sz);
3456 
3457   sz->_inst_size  = wordSize * size_helper();
3458   sz->_vtab_bytes = wordSize * vtable_length();
3459   sz->_itab_bytes = wordSize * itable_length();
3460   sz->_nonstatic_oopmap_bytes = wordSize * nonstatic_oop_map_size();
3461 
3462   int n = 0;
3463   n += (sz->_methods_array_bytes         = sz->count_array(methods()));
3464   n += (sz->_method_ordering_bytes       = sz->count_array(method_ordering()));
3465   n += (sz->_local_interfaces_bytes      = sz->count_array(local_interfaces()));
3466   n += (sz->_transitive_interfaces_bytes = sz->count_array(transitive_interfaces()));
3467   n += (sz->_fields_bytes                = sz->count_array(fields()));
3468   n += (sz->_inner_classes_bytes         = sz->count_array(inner_classes()));
3469   n += (sz->_nest_members_bytes          = sz->count_array(nest_members()));
3470   sz->_ro_bytes += n;
3471 
3472   const ConstantPool* cp = constants();
3473   if (cp) {
3474     cp->collect_statistics(sz);
3475   }
3476 
3477   const Annotations* anno = annotations();
3478   if (anno) {
3479     anno->collect_statistics(sz);
3480   }
3481 
3482   const Array<Method*>* methods_array = methods();
3483   if (methods()) {
3484     for (int i = 0; i < methods_array->length(); i++) {
3485       Method* method = methods_array->at(i);
3486       if (method) {
3487         sz->_method_count ++;
3488         method->collect_statistics(sz);
3489       }
3490     }
3491   }
3492 }
3493 #endif // INCLUDE_SERVICES
3494 
3495 // Verification
3496 
3497 class VerifyFieldClosure: public BasicOopIterateClosure {
3498  protected:
3499   template <class T> void do_oop_work(T* p) {
3500     oop obj = RawAccess<>::oop_load(p);
3501     if (!oopDesc::is_oop_or_null(obj)) {
3502       tty->print_cr("Failed: " PTR_FORMAT " -> " PTR_FORMAT, p2i(p), p2i(obj));
3503       Universe::print_on(tty);
3504       guarantee(false, "boom");
3505     }
3506   }
3507  public:
3508   virtual void do_oop(oop* p)       { VerifyFieldClosure::do_oop_work(p); }
3509   virtual void do_oop(narrowOop* p) { VerifyFieldClosure::do_oop_work(p); }
3510 };
3511 
3512 void InstanceKlass::verify_on(outputStream* st) {
3513 #ifndef PRODUCT
3514   // Avoid redundant verifies, this really should be in product.
3515   if (_verify_count == Universe::verify_count()) return;
3516   _verify_count = Universe::verify_count();
3517 #endif
3518 
3519   // Verify Klass
3520   Klass::verify_on(st);
3521 
3522   // Verify that klass is present in ClassLoaderData
3523   guarantee(class_loader_data()->contains_klass(this),
3524             "this class isn't found in class loader data");
3525 
3526   // Verify vtables
3527   if (is_linked()) {
3528     // $$$ This used to be done only for m/s collections.  Doing it
3529     // always seemed a valid generalization.  (DLD -- 6/00)
3530     vtable().verify(st);
3531   }
3532 
3533   // Verify first subklass
3534   if (subklass() != NULL) {
3535     guarantee(subklass()->is_klass(), "should be klass");
3536   }
3537 
3538   // Verify siblings
3539   Klass* super = this->super();
3540   Klass* sib = next_sibling();
3541   if (sib != NULL) {
3542     if (sib == this) {
3543       fatal("subclass points to itself " PTR_FORMAT, p2i(sib));
3544     }
3545 
3546     guarantee(sib->is_klass(), "should be klass");
3547     guarantee(sib->super() == super, "siblings should have same superklass");
3548   }
3549 
3550   // Verify implementor fields requires the Compile_lock, but this is sometimes
3551   // called inside a safepoint, so don't verify.
3552 
3553   // Verify local interfaces
3554   if (local_interfaces()) {
3555     Array<InstanceKlass*>* local_interfaces = this->local_interfaces();
3556     for (int j = 0; j < local_interfaces->length(); j++) {
3557       InstanceKlass* e = local_interfaces->at(j);
3558       guarantee(e->is_klass() && e->is_interface(), "invalid local interface");
3559     }
3560   }
3561 
3562   // Verify transitive interfaces
3563   if (transitive_interfaces() != NULL) {
3564     Array<InstanceKlass*>* transitive_interfaces = this->transitive_interfaces();
3565     for (int j = 0; j < transitive_interfaces->length(); j++) {
3566       InstanceKlass* e = transitive_interfaces->at(j);
3567       guarantee(e->is_klass() && e->is_interface(), "invalid transitive interface");
3568     }
3569   }
3570 
3571   // Verify methods
3572   if (methods() != NULL) {
3573     Array<Method*>* methods = this->methods();
3574     for (int j = 0; j < methods->length(); j++) {
3575       guarantee(methods->at(j)->is_method(), "non-method in methods array");
3576     }
3577     for (int j = 0; j < methods->length() - 1; j++) {
3578       Method* m1 = methods->at(j);
3579       Method* m2 = methods->at(j + 1);
3580       guarantee(m1->name()->fast_compare(m2->name()) <= 0, "methods not sorted correctly");
3581     }
3582   }
3583 
3584   // Verify method ordering
3585   if (method_ordering() != NULL) {
3586     Array<int>* method_ordering = this->method_ordering();
3587     int length = method_ordering->length();
3588     if (JvmtiExport::can_maintain_original_method_order() ||
3589         ((UseSharedSpaces || DumpSharedSpaces) && length != 0)) {
3590       guarantee(length == methods()->length(), "invalid method ordering length");
3591       jlong sum = 0;
3592       for (int j = 0; j < length; j++) {
3593         int original_index = method_ordering->at(j);
3594         guarantee(original_index >= 0, "invalid method ordering index");
3595         guarantee(original_index < length, "invalid method ordering index");
3596         sum += original_index;
3597       }
3598       // Verify sum of indices 0,1,...,length-1
3599       guarantee(sum == ((jlong)length*(length-1))/2, "invalid method ordering sum");
3600     } else {
3601       guarantee(length == 0, "invalid method ordering length");
3602     }
3603   }
3604 
3605   // Verify default methods
3606   if (default_methods() != NULL) {
3607     Array<Method*>* methods = this->default_methods();
3608     for (int j = 0; j < methods->length(); j++) {
3609       guarantee(methods->at(j)->is_method(), "non-method in methods array");
3610     }
3611     for (int j = 0; j < methods->length() - 1; j++) {
3612       Method* m1 = methods->at(j);
3613       Method* m2 = methods->at(j + 1);
3614       guarantee(m1->name()->fast_compare(m2->name()) <= 0, "methods not sorted correctly");
3615     }
3616   }
3617 
3618   // Verify JNI static field identifiers
3619   if (jni_ids() != NULL) {
3620     jni_ids()->verify(this);
3621   }
3622 
3623   // Verify other fields
3624   if (array_klasses() != NULL) {
3625     guarantee(array_klasses()->is_klass(), "should be klass");
3626   }
3627   if (constants() != NULL) {
3628     guarantee(constants()->is_constantPool(), "should be constant pool");
3629   }
3630   const Klass* anonymous_host = unsafe_anonymous_host();
3631   if (anonymous_host != NULL) {
3632     guarantee(anonymous_host->is_klass(), "should be klass");
3633   }
3634 }
3635 
3636 void InstanceKlass::oop_verify_on(oop obj, outputStream* st) {
3637   Klass::oop_verify_on(obj, st);
3638   VerifyFieldClosure blk;
3639   obj->oop_iterate(&blk);
3640 }
3641 
3642 
3643 // JNIid class for jfieldIDs only
3644 // Note to reviewers:
3645 // These JNI functions are just moved over to column 1 and not changed
3646 // in the compressed oops workspace.
3647 JNIid::JNIid(Klass* holder, int offset, JNIid* next) {
3648   _holder = holder;
3649   _offset = offset;
3650   _next = next;
3651   debug_only(_is_static_field_id = false;)
3652 }
3653 
3654 
3655 JNIid* JNIid::find(int offset) {
3656   JNIid* current = this;
3657   while (current != NULL) {
3658     if (current->offset() == offset) return current;
3659     current = current->next();
3660   }
3661   return NULL;
3662 }
3663 
3664 void JNIid::deallocate(JNIid* current) {
3665   while (current != NULL) {
3666     JNIid* next = current->next();
3667     delete current;
3668     current = next;
3669   }
3670 }
3671 
3672 
3673 void JNIid::verify(Klass* holder) {
3674   int first_field_offset  = InstanceMirrorKlass::offset_of_static_fields();
3675   int end_field_offset;
3676   end_field_offset = first_field_offset + (InstanceKlass::cast(holder)->static_field_size() * wordSize);
3677 
3678   JNIid* current = this;
3679   while (current != NULL) {
3680     guarantee(current->holder() == holder, "Invalid klass in JNIid");
3681 #ifdef ASSERT
3682     int o = current->offset();
3683     if (current->is_static_field_id()) {
3684       guarantee(o >= first_field_offset  && o < end_field_offset,  "Invalid static field offset in JNIid");
3685     }
3686 #endif
3687     current = current->next();
3688   }
3689 }
3690 
3691 #ifdef ASSERT
3692 void InstanceKlass::set_init_state(ClassState state) {
3693   bool good_state = is_shared() ? (_init_state <= state)
3694                                                : (_init_state < state);
3695   assert(good_state || state == allocated, "illegal state transition");
3696   _init_state = (u1)state;
3697 }
3698 #endif
3699 
3700 #if INCLUDE_JVMTI
3701 
3702 // RedefineClasses() support for previous versions
3703 
3704 // Globally, there is at least one previous version of a class to walk
3705 // during class unloading, which is saved because old methods in the class
3706 // are still running.   Otherwise the previous version list is cleaned up.
3707 bool InstanceKlass::_has_previous_versions = false;
3708 
3709 // Returns true if there are previous versions of a class for class
3710 // unloading only. Also resets the flag to false. purge_previous_version
3711 // will set the flag to true if there are any left, i.e., if there's any
3712 // work to do for next time. This is to avoid the expensive code cache
3713 // walk in CLDG::clean_deallocate_lists().
3714 bool InstanceKlass::has_previous_versions_and_reset() {
3715   bool ret = _has_previous_versions;
3716   log_trace(redefine, class, iklass, purge)("Class unloading: has_previous_versions = %s",
3717      ret ? "true" : "false");
3718   _has_previous_versions = false;
3719   return ret;
3720 }
3721 
3722 // Purge previous versions before adding new previous versions of the class and
3723 // during class unloading.
3724 void InstanceKlass::purge_previous_version_list() {
3725   assert(SafepointSynchronize::is_at_safepoint(), "only called at safepoint");
3726   assert(has_been_redefined(), "Should only be called for main class");
3727 
3728   // Quick exit.
3729   if (previous_versions() == NULL) {
3730     return;
3731   }
3732 
3733   // This klass has previous versions so see what we can cleanup
3734   // while it is safe to do so.
3735 
3736   int deleted_count = 0;    // leave debugging breadcrumbs
3737   int live_count = 0;
3738   ClassLoaderData* loader_data = class_loader_data();
3739   assert(loader_data != NULL, "should never be null");
3740 
3741   ResourceMark rm;
3742   log_trace(redefine, class, iklass, purge)("%s: previous versions", external_name());
3743 
3744   // previous versions are linked together through the InstanceKlass
3745   InstanceKlass* pv_node = previous_versions();
3746   InstanceKlass* last = this;
3747   int version = 0;
3748 
3749   // check the previous versions list
3750   for (; pv_node != NULL; ) {
3751 
3752     ConstantPool* pvcp = pv_node->constants();
3753     assert(pvcp != NULL, "cp ref was unexpectedly cleared");
3754 
3755     if (!pvcp->on_stack()) {
3756       // If the constant pool isn't on stack, none of the methods
3757       // are executing.  Unlink this previous_version.
3758       // The previous version InstanceKlass is on the ClassLoaderData deallocate list
3759       // so will be deallocated during the next phase of class unloading.
3760       log_trace(redefine, class, iklass, purge)
3761         ("previous version " INTPTR_FORMAT " is dead.", p2i(pv_node));
3762       // For debugging purposes.
3763       pv_node->set_is_scratch_class();
3764       // Unlink from previous version list.
3765       assert(pv_node->class_loader_data() == loader_data, "wrong loader_data");
3766       InstanceKlass* next = pv_node->previous_versions();
3767       pv_node->link_previous_versions(NULL);   // point next to NULL
3768       last->link_previous_versions(next);
3769       // Add to the deallocate list after unlinking
3770       loader_data->add_to_deallocate_list(pv_node);
3771       pv_node = next;
3772       deleted_count++;
3773       version++;
3774       continue;
3775     } else {
3776       log_trace(redefine, class, iklass, purge)("previous version " INTPTR_FORMAT " is alive", p2i(pv_node));
3777       assert(pvcp->pool_holder() != NULL, "Constant pool with no holder");
3778       guarantee (!loader_data->is_unloading(), "unloaded classes can't be on the stack");
3779       live_count++;
3780       // found a previous version for next time we do class unloading
3781       _has_previous_versions = true;
3782     }
3783 
3784     // At least one method is live in this previous version.
3785     // Reset dead EMCP methods not to get breakpoints.
3786     // All methods are deallocated when all of the methods for this class are no
3787     // longer running.
3788     Array<Method*>* method_refs = pv_node->methods();
3789     if (method_refs != NULL) {
3790       log_trace(redefine, class, iklass, purge)("previous methods length=%d", method_refs->length());
3791       for (int j = 0; j < method_refs->length(); j++) {
3792         Method* method = method_refs->at(j);
3793 
3794         if (!method->on_stack()) {
3795           // no breakpoints for non-running methods
3796           if (method->is_running_emcp()) {
3797             method->set_running_emcp(false);
3798           }
3799         } else {
3800           assert (method->is_obsolete() || method->is_running_emcp(),
3801                   "emcp method cannot run after emcp bit is cleared");
3802           log_trace(redefine, class, iklass, purge)
3803             ("purge: %s(%s): prev method @%d in version @%d is alive",
3804              method->name()->as_C_string(), method->signature()->as_C_string(), j, version);
3805         }
3806       }
3807     }
3808     // next previous version
3809     last = pv_node;
3810     pv_node = pv_node->previous_versions();
3811     version++;
3812   }
3813   log_trace(redefine, class, iklass, purge)
3814     ("previous version stats: live=%d, deleted=%d", live_count, deleted_count);
3815 }
3816 
3817 void InstanceKlass::mark_newly_obsolete_methods(Array<Method*>* old_methods,
3818                                                 int emcp_method_count) {
3819   int obsolete_method_count = old_methods->length() - emcp_method_count;
3820 
3821   if (emcp_method_count != 0 && obsolete_method_count != 0 &&
3822       _previous_versions != NULL) {
3823     // We have a mix of obsolete and EMCP methods so we have to
3824     // clear out any matching EMCP method entries the hard way.
3825     int local_count = 0;
3826     for (int i = 0; i < old_methods->length(); i++) {
3827       Method* old_method = old_methods->at(i);
3828       if (old_method->is_obsolete()) {
3829         // only obsolete methods are interesting
3830         Symbol* m_name = old_method->name();
3831         Symbol* m_signature = old_method->signature();
3832 
3833         // previous versions are linked together through the InstanceKlass
3834         int j = 0;
3835         for (InstanceKlass* prev_version = _previous_versions;
3836              prev_version != NULL;
3837              prev_version = prev_version->previous_versions(), j++) {
3838 
3839           Array<Method*>* method_refs = prev_version->methods();
3840           for (int k = 0; k < method_refs->length(); k++) {
3841             Method* method = method_refs->at(k);
3842 
3843             if (!method->is_obsolete() &&
3844                 method->name() == m_name &&
3845                 method->signature() == m_signature) {
3846               // The current RedefineClasses() call has made all EMCP
3847               // versions of this method obsolete so mark it as obsolete
3848               log_trace(redefine, class, iklass, add)
3849                 ("%s(%s): flush obsolete method @%d in version @%d",
3850                  m_name->as_C_string(), m_signature->as_C_string(), k, j);
3851 
3852               method->set_is_obsolete();
3853               break;
3854             }
3855           }
3856 
3857           // The previous loop may not find a matching EMCP method, but
3858           // that doesn't mean that we can optimize and not go any
3859           // further back in the PreviousVersion generations. The EMCP
3860           // method for this generation could have already been made obsolete,
3861           // but there still may be an older EMCP method that has not
3862           // been made obsolete.
3863         }
3864 
3865         if (++local_count >= obsolete_method_count) {
3866           // no more obsolete methods so bail out now
3867           break;
3868         }
3869       }
3870     }
3871   }
3872 }
3873 
3874 // Save the scratch_class as the previous version if any of the methods are running.
3875 // The previous_versions are used to set breakpoints in EMCP methods and they are
3876 // also used to clean MethodData links to redefined methods that are no longer running.
3877 void InstanceKlass::add_previous_version(InstanceKlass* scratch_class,
3878                                          int emcp_method_count) {
3879   assert(Thread::current()->is_VM_thread(),
3880          "only VMThread can add previous versions");
3881 
3882   ResourceMark rm;
3883   log_trace(redefine, class, iklass, add)
3884     ("adding previous version ref for %s, EMCP_cnt=%d", scratch_class->external_name(), emcp_method_count);
3885 
3886   // Clean out old previous versions for this class
3887   purge_previous_version_list();
3888 
3889   // Mark newly obsolete methods in remaining previous versions.  An EMCP method from
3890   // a previous redefinition may be made obsolete by this redefinition.
3891   Array<Method*>* old_methods = scratch_class->methods();
3892   mark_newly_obsolete_methods(old_methods, emcp_method_count);
3893 
3894   // If the constant pool for this previous version of the class
3895   // is not marked as being on the stack, then none of the methods
3896   // in this previous version of the class are on the stack so
3897   // we don't need to add this as a previous version.
3898   ConstantPool* cp_ref = scratch_class->constants();
3899   if (!cp_ref->on_stack()) {
3900     log_trace(redefine, class, iklass, add)("scratch class not added; no methods are running");
3901     // For debugging purposes.
3902     scratch_class->set_is_scratch_class();
3903     scratch_class->class_loader_data()->add_to_deallocate_list(scratch_class);
3904     return;
3905   }
3906 
3907   if (emcp_method_count != 0) {
3908     // At least one method is still running, check for EMCP methods
3909     for (int i = 0; i < old_methods->length(); i++) {
3910       Method* old_method = old_methods->at(i);
3911       if (!old_method->is_obsolete() && old_method->on_stack()) {
3912         // if EMCP method (not obsolete) is on the stack, mark as EMCP so that
3913         // we can add breakpoints for it.
3914 
3915         // We set the method->on_stack bit during safepoints for class redefinition
3916         // and use this bit to set the is_running_emcp bit.
3917         // After the safepoint, the on_stack bit is cleared and the running emcp
3918         // method may exit.   If so, we would set a breakpoint in a method that
3919         // is never reached, but this won't be noticeable to the programmer.
3920         old_method->set_running_emcp(true);
3921         log_trace(redefine, class, iklass, add)
3922           ("EMCP method %s is on_stack " INTPTR_FORMAT, old_method->name_and_sig_as_C_string(), p2i(old_method));
3923       } else if (!old_method->is_obsolete()) {
3924         log_trace(redefine, class, iklass, add)
3925           ("EMCP method %s is NOT on_stack " INTPTR_FORMAT, old_method->name_and_sig_as_C_string(), p2i(old_method));
3926       }
3927     }
3928   }
3929 
3930   // Add previous version if any methods are still running.
3931   // Set has_previous_version flag for processing during class unloading.
3932   _has_previous_versions = true;
3933   log_trace(redefine, class, iklass, add) ("scratch class added; one of its methods is on_stack.");
3934   assert(scratch_class->previous_versions() == NULL, "shouldn't have a previous version");
3935   scratch_class->link_previous_versions(previous_versions());
3936   link_previous_versions(scratch_class);
3937 } // end add_previous_version()
3938 
3939 #endif // INCLUDE_JVMTI
3940 
3941 Method* InstanceKlass::method_with_idnum(int idnum) {
3942   Method* m = NULL;
3943   if (idnum < methods()->length()) {
3944     m = methods()->at(idnum);
3945   }
3946   if (m == NULL || m->method_idnum() != idnum) {
3947     for (int index = 0; index < methods()->length(); ++index) {
3948       m = methods()->at(index);
3949       if (m->method_idnum() == idnum) {
3950         return m;
3951       }
3952     }
3953     // None found, return null for the caller to handle.
3954     return NULL;
3955   }
3956   return m;
3957 }
3958 
3959 
3960 Method* InstanceKlass::method_with_orig_idnum(int idnum) {
3961   if (idnum >= methods()->length()) {
3962     return NULL;
3963   }
3964   Method* m = methods()->at(idnum);
3965   if (m != NULL && m->orig_method_idnum() == idnum) {
3966     return m;
3967   }
3968   // Obsolete method idnum does not match the original idnum
3969   for (int index = 0; index < methods()->length(); ++index) {
3970     m = methods()->at(index);
3971     if (m->orig_method_idnum() == idnum) {
3972       return m;
3973     }
3974   }
3975   // None found, return null for the caller to handle.
3976   return NULL;
3977 }
3978 
3979 
3980 Method* InstanceKlass::method_with_orig_idnum(int idnum, int version) {
3981   InstanceKlass* holder = get_klass_version(version);
3982   if (holder == NULL) {
3983     return NULL; // The version of klass is gone, no method is found
3984   }
3985   Method* method = holder->method_with_orig_idnum(idnum);
3986   return method;
3987 }
3988 
3989 #if INCLUDE_JVMTI
3990 JvmtiCachedClassFileData* InstanceKlass::get_cached_class_file() {
3991   if (MetaspaceShared::is_in_shared_metaspace(_cached_class_file)) {
3992     // Ignore the archived class stream data
3993     return NULL;
3994   } else {
3995     return _cached_class_file;
3996   }
3997 }
3998 
3999 jint InstanceKlass::get_cached_class_file_len() {
4000   return VM_RedefineClasses::get_cached_class_file_len(_cached_class_file);
4001 }
4002 
4003 unsigned char * InstanceKlass::get_cached_class_file_bytes() {
4004   return VM_RedefineClasses::get_cached_class_file_bytes(_cached_class_file);
4005 }
4006 
4007 #if INCLUDE_CDS
4008 JvmtiCachedClassFileData* InstanceKlass::get_archived_class_data() {
4009   if (DumpSharedSpaces) {
4010     return _cached_class_file;
4011   } else {
4012     assert(this->is_shared(), "class should be shared");
4013     if (MetaspaceShared::is_in_shared_metaspace(_cached_class_file)) {
4014       return _cached_class_file;
4015     } else {
4016       return NULL;
4017     }
4018   }
4019 }
4020 #endif
4021 #endif