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