instanceKlass.hpp 50.7 KB
Newer Older
D
duke 已提交
1
/*
2
 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
D
duke 已提交
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
19 20 21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
D
duke 已提交
22 23 24
 *
 */

25 26 27
#ifndef SHARE_VM_OOPS_INSTANCEKLASS_HPP
#define SHARE_VM_OOPS_INSTANCEKLASS_HPP

28 29 30
#include "classfile/classLoaderData.hpp"
#include "oops/annotations.hpp"
#include "oops/constMethod.hpp"
31
#include "oops/fieldInfo.hpp"
32 33
#include "oops/instanceOop.hpp"
#include "oops/klassVtable.hpp"
34
#include "runtime/atomic.hpp"
35 36 37 38 39
#include "runtime/handles.hpp"
#include "runtime/os.hpp"
#include "utilities/accessFlags.hpp"
#include "utilities/bitMap.inline.hpp"

40
// An InstanceKlass is the VM level representation of a Java class.
D
duke 已提交
41 42
// It contains all information needed for at class at execution runtime.

43
//  InstanceKlass layout:
D
duke 已提交
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
//    [C++ vtbl pointer           ] Klass
//    [subtype cache              ] Klass
//    [instance size              ] Klass
//    [java mirror                ] Klass
//    [super                      ] Klass
//    [access_flags               ] Klass
//    [name                       ] Klass
//    [first subklass             ] Klass
//    [next sibling               ] Klass
//    [array klasses              ]
//    [methods                    ]
//    [local interfaces           ]
//    [transitive interfaces      ]
//    [fields                     ]
//    [constants                  ]
//    [class loader               ]
//    [protection domain          ]
//    [signers                    ]
//    [source file name           ]
//    [inner classes              ]
//    [static field size          ]
//    [nonstatic field size       ]
//    [static oop fields size     ]
//    [nonstatic oop maps size    ]
//    [has finalize method        ]
//    [deoptimization mark bit    ]
//    [initialization state       ]
//    [initializing thread        ]
//    [Java vtable length         ]
//    [oop map cache (stack maps) ]
//    [EMBEDDED Java vtable             ] size in words = vtable_len
//    [EMBEDDED nonstatic oop-map blocks] size in words = nonstatic_oop_map_size
76 77 78
//      The embedded nonstatic oop-map blocks are short pairs (offset, length)
//      indicating where oops are located in instances of this klass.
//    [EMBEDDED implementor of the interface] only exist for interface
79
//    [EMBEDDED host klass        ] only exist for an anonymous class (JSR 292 enabled)
D
duke 已提交
80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110


// forward declaration for class -- see below for definition
class SuperTypeClosure;
class JNIid;
class jniIdMapBase;
class BreakpointInfo;
class fieldDescriptor;
class DepChange;
class nmethodBucket;
class PreviousVersionNode;
class JvmtiCachedClassFieldMap;

// This is used in iterators below.
class FieldClosure: public StackObj {
public:
  virtual void do_field(fieldDescriptor* fd) = 0;
};

#ifndef PRODUCT
// Print fields.
// If "obj" argument to constructor is NULL, prints static fields, otherwise prints non-static fields.
class FieldPrinter: public FieldClosure {
   oop _obj;
   outputStream* _st;
 public:
   FieldPrinter(outputStream* st, oop obj = NULL) : _obj(obj), _st(st) {}
   void do_field(fieldDescriptor* fd);
};
#endif  // !PRODUCT

111 112 113 114 115
// ValueObjs embedded in klass. Describes where oops are located in instances of
// this klass.
class OopMapBlock VALUE_OBJ_CLASS_SPEC {
 public:
  // Byte offset of the first oop mapped by this block.
116 117
  int offset() const          { return _offset; }
  void set_offset(int offset) { _offset = offset; }
118 119

  // Number of oops in this block.
120 121
  uint count() const         { return _count; }
  void set_count(uint count) { _count = count; }
122 123 124 125 126 127 128 129

  // sizeof(OopMapBlock) in HeapWords.
  static const int size_in_words() {
    return align_size_up(int(sizeof(OopMapBlock)), HeapWordSize) >>
      LogHeapWordSize;
  }

 private:
130 131
  int  _offset;
  uint _count;
132 133
};

134
class InstanceKlass: public Klass {
D
duke 已提交
135
  friend class VMStructs;
136
  friend class ClassFileParser;
137
  friend class CompileReplay;
138 139 140 141 142 143 144 145 146 147

 protected:
  // Constructor
  InstanceKlass(int vtable_len,
                int itable_len,
                int static_field_size,
                int nonstatic_oop_map_size,
                ReferenceType rt,
                AccessFlags access_flags,
                bool is_anonymous);
D
duke 已提交
148
 public:
149 150 151 152 153 154 155 156 157 158 159 160 161 162
  static Klass* allocate_instance_klass(ClassLoaderData* loader_data,
                                          int vtable_len,
                                          int itable_len,
                                          int static_field_size,
                                          int nonstatic_oop_map_size,
                                          ReferenceType rt,
                                          AccessFlags access_flags,
                                          Symbol* name,
                                        Klass* super_klass,
                                          KlassHandle host_klass,
                                          TRAPS);

  InstanceKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); }

D
duke 已提交
163 164 165 166 167 168 169 170 171 172 173
  // See "The Java Virtual Machine Specification" section 2.16.2-5 for a detailed description
  // of the class loading & initialization procedure, and the use of the states.
  enum ClassState {
    allocated,                          // allocated (but not yet linked)
    loaded,                             // loaded and inserted in class hierarchy (but not linked yet)
    linked,                             // successfully linked/verified (but not initialized yet)
    being_initialized,                  // currently running class initializer
    fully_initialized,                  // initialized (successfull final state)
    initialization_error                // error happened during initialization
  };

174 175 176 177 178
  static int number_of_instance_classes() { return _total_instanceKlass_count; }

 private:
  static volatile int _total_instanceKlass_count;

D
duke 已提交
179 180 181 182 183
 protected:
  // Protection domain.
  oop             _protection_domain;
  // Class signers.
  objArrayOop     _signers;
184 185 186 187 188 189 190 191 192 193 194
  // Initialization lock.  Must be one per class and it has to be a VM internal
  // object so java code cannot lock it (like the mirror)
  // It has to be an object not a Mutex because it's held through java calls.
  volatile oop    _init_lock;

  // Annotations for this class
  Annotations*    _annotations;
  // Array classes holding elements of this class.
  Klass*          _array_klasses;
  // Constant pool for this class.
  ConstantPool* _constants;
195 196 197 198 199 200 201 202 203 204 205
  // The InnerClasses attribute and EnclosingMethod attribute. The
  // _inner_classes is an array of shorts. If the class has InnerClasses
  // attribute, then the _inner_classes array begins with 4-tuples of shorts
  // [inner_class_info_index, outer_class_info_index,
  // inner_name_index, inner_class_access_flags] for the InnerClasses
  // attribute. If the EnclosingMethod attribute exists, it occupies the
  // last two shorts [class_index, method_index] of the array. If only
  // the InnerClasses attribute exists, the _inner_classes array length is
  // number_of_inner_classes * 4. If the class has both InnerClasses
  // and EnclosingMethod attributes the _inner_classes array length is
  // number_of_inner_classes * 4 + enclosing_method_attribute_size.
206
  Array<jushort>* _inner_classes;
D
duke 已提交
207

208 209 210
  // Name of source file containing this klass, NULL if not specified.
  Symbol*         _source_file_name;
  // the source debug extension for this klass, NULL if not specified.
211 212 213
  // Specified as UTF-8 string without terminating zero byte in the classfile,
  // it is stored in the instanceklass as a NULL-terminated UTF-8 string
  char*           _source_debug_extension;
214 215 216 217 218 219
  // Generic signature, or null if none.
  Symbol*         _generic_signature;
  // Array name derived from this class which needs unreferencing
  // if this class is unloaded.
  Symbol*         _array_name;

220 221
  // Number of heapOopSize words used by non-static fields in this klass
  // (including inherited fields but after header_size()).
222 223
  int             _nonstatic_field_size;
  int             _static_field_size;    // number words used by static fields (oop and non-oop) in this klass
224 225
  u2              _static_oop_field_count;// number of static oop fields in this klass
  u2              _java_fields_count;    // The number of declared Java fields
226
  int             _nonstatic_oop_map_size;// size in words of nonstatic oop map blocks
227

228
  bool            _is_marked_dependent;  // used for marking during flushing and deoptimization
229 230 231 232 233 234 235
  enum {
    _misc_rewritten            = 1 << 0, // methods rewritten.
    _misc_has_nonstatic_fields = 1 << 1, // for sizing with UseCompressedOops
    _misc_should_verify_class  = 1 << 2, // allow caching of preverification
    _misc_is_anonymous         = 1 << 3  // has embedded _inner_classes field
  };
  u2              _misc_flags;
D
duke 已提交
236 237 238 239 240 241 242 243 244 245 246
  u2              _minor_version;        // minor version number of class file
  u2              _major_version;        // major version number of class file
  Thread*         _init_thread;          // Pointer to current thread doing initialization (to handle recusive initialization)
  int             _vtable_len;           // length of Java vtable (in words)
  int             _itable_len;           // length of Java itable (in words)
  OopMapCache*    volatile _oop_map_cache;   // OopMapCache for all methods in the klass (allocated lazily)
  JNIid*          _jni_ids;              // First JNI identifier for static fields in this class
  jmethodID*      _methods_jmethod_ids;  // jmethodIDs corresponding to method_idnum, or NULL if none
  int*            _methods_cached_itable_indices;  // itable_index cache for JNI invoke corresponding to methods idnum, or NULL
  nmethodBucket*  _dependencies;         // list of dependent nmethods
  nmethod*        _osr_nmethods_head;    // Head of list of on-stack replacement nmethods for this class
247
  BreakpointInfo* _breakpoints;          // bpt lists, managed by Method*
D
duke 已提交
248
  // Array of interesting part(s) of the previous version(s) of this
249
  // InstanceKlass. See PreviousVersionWalker below.
D
duke 已提交
250 251 252 253 254
  GrowableArray<PreviousVersionNode *>* _previous_versions;
  // JVMTI fields can be moved to their own structure - see 6315920
  unsigned char * _cached_class_file_bytes;       // JVMTI: cached class file, before retransformable agent modified it in CFLH
  jint            _cached_class_file_len;         // JVMTI: length of above
  JvmtiCachedClassFieldMap* _jvmti_cached_class_field_map;  // JVMTI: used during heap iteration
255 256 257 258

  // true if class, superclass, or implemented interfaces have default methods
  bool            _has_default_methods;

D
duke 已提交
259
  volatile u2     _idnum_allocated_count;         // JNI/JVMTI: increments with the addition of methods, old ids don't change
260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
  // Method array.
  Array<Method*>* _methods;
  // Interface (Klass*s) this class declares locally to implement.
  Array<Klass*>* _local_interfaces;
  // Interface (Klass*s) this class implements transitively.
  Array<Klass*>* _transitive_interfaces;
  // Int array containing the original order of method in the class file (for JVMTI).
  Array<int>*     _method_ordering;
  // Instance and static variable information, starts with 6-tuples of shorts
  // [access, name index, sig index, initval index, low_offset, high_offset]
  // for all fields, followed by the generic signature data at the end of
  // the array. Only fields with generic signature attributes have the generic
  // signature data set in the array. The fields array looks like following:
  //
  // f1: [access, name index, sig index, initial value index, low_offset, high_offset]
  // f2: [access, name index, sig index, initial value index, low_offset, high_offset]
  //      ...
  // fn: [access, name index, sig index, initial value index, low_offset, high_offset]
  //     [generic signature index]
  //     [generic signature index]
  //     ...
  Array<u2>*      _fields;
D
duke 已提交
282

283 284 285 286 287
  // Class states are defined as ClassState (see above).
  // Place the _init_state here to utilize the unused 2-byte after
  // _idnum_allocated_count.
  u1              _init_state;                    // state of class

288 289
  u1              _reference_type;                // reference type

D
duke 已提交
290 291 292 293
  // embedded Java vtable follows here
  // embedded Java itables follows here
  // embedded static fields follows here
  // embedded nonstatic oop-map blocks follows here
294 295 296 297 298
  // embedded implementor of this interface follows here
  //   The embedded implementor only exists if the current klass is an
  //   iterface. The possible values of the implementor fall into following
  //   three cases:
  //     NULL: no implementor.
299
  //     A Klass* that's not itself: one implementor.
300
  //     Itsef: more than one implementors.
301 302 303 304 305 306 307 308
  // embedded host klass follows here
  //   The embedded host klass only exists in an anonymous class for
  //   dynamic language support (JSR 292 enabled). The host class grants
  //   its access privileges to this class also. The host class is either
  //   named, or a previously loaded anonymous class. A non-anonymous class
  //   or an anonymous class loaded through normal classloading does not
  //   have this embedded field.
  //
D
duke 已提交
309 310 311 312

  friend class SystemDictionary;

 public:
313 314 315 316 317 318 319 320 321 322
  bool has_nonstatic_fields() const        {
    return (_misc_flags & _misc_has_nonstatic_fields) != 0;
  }
  void set_has_nonstatic_fields(bool b)    {
    if (b) {
      _misc_flags |= _misc_has_nonstatic_fields;
    } else {
      _misc_flags &= ~_misc_has_nonstatic_fields;
    }
  }
323

D
duke 已提交
324 325 326 327 328 329 330
  // field sizes
  int nonstatic_field_size() const         { return _nonstatic_field_size; }
  void set_nonstatic_field_size(int size)  { _nonstatic_field_size = size; }

  int static_field_size() const            { return _static_field_size; }
  void set_static_field_size(int size)     { _static_field_size = size; }

331 332
  int static_oop_field_count() const       { return (int)_static_oop_field_count; }
  void set_static_oop_field_count(u2 size) { _static_oop_field_count = size; }
D
duke 已提交
333 334 335 336 337 338 339 340 341 342

  // Java vtable
  int  vtable_length() const               { return _vtable_len; }
  void set_vtable_length(int len)          { _vtable_len = len; }

  // Java itable
  int  itable_length() const               { return _itable_len; }
  void set_itable_length(int len)          { _itable_len = len; }

  // array klasses
343 344
  Klass* array_klasses() const             { return _array_klasses; }
  void set_array_klasses(Klass* k)         { _array_klasses = k; }
D
duke 已提交
345 346

  // methods
347 348 349
  Array<Method*>* methods() const          { return _methods; }
  void set_methods(Array<Method*>* a)      { _methods = a; }
  Method* method_with_idnum(int idnum);
D
duke 已提交
350 351

  // method ordering
352 353
  Array<int>* method_ordering() const     { return _method_ordering; }
  void set_method_ordering(Array<int>* m) { _method_ordering = m; }
D
duke 已提交
354 355

  // interfaces
356 357 358 359 360 361 362 363
  Array<Klass*>* local_interfaces() const          { return _local_interfaces; }
  void set_local_interfaces(Array<Klass*>* a)      {
    guarantee(_local_interfaces == NULL || a == NULL, "Just checking");
    _local_interfaces = a; }
  Array<Klass*>* transitive_interfaces() const     { return _transitive_interfaces; }
  void set_transitive_interfaces(Array<Klass*>* a) {
    guarantee(_transitive_interfaces == NULL || a == NULL, "Just checking");
    _transitive_interfaces = a; }
D
duke 已提交
364

365 366 367 368 369 370 371 372 373 374 375
 private:
  friend class fieldDescriptor;
  FieldInfo* field(int index) const { return FieldInfo::from_field_array(_fields, index); }

 public:
  int     field_offset      (int index) const { return field(index)->offset(); }
  int     field_access_flags(int index) const { return field(index)->access_flags(); }
  Symbol* field_name        (int index) const { return field(index)->name(constants()); }
  Symbol* field_signature   (int index) const { return field(index)->signature(constants()); }

  // Number of Java declared fields
376
  int java_fields_count() const           { return (int)_java_fields_count; }
377

378
  Array<u2>* fields() const            { return _fields; }
D
duke 已提交
379

380 381 382
  void set_fields(Array<u2>* f, u2 java_fields_count) {
    guarantee(_fields == NULL || f == NULL, "Just checking");
    _fields =  f;
383 384
    _java_fields_count = java_fields_count;
  }
D
duke 已提交
385 386

  // inner classes
387 388
  Array<u2>* inner_classes() const       { return _inner_classes; }
  void set_inner_classes(Array<u2>* f)   { _inner_classes = f; }
D
duke 已提交
389 390 391 392 393 394 395 396 397 398

  enum InnerClassAttributeOffset {
    // From http://mirror.eng/products/jdk/1.1/docs/guide/innerclasses/spec/innerclasses.doc10.html#18814
    inner_class_inner_class_info_offset = 0,
    inner_class_outer_class_info_offset = 1,
    inner_class_inner_name_offset = 2,
    inner_class_access_flags_offset = 3,
    inner_class_next_offset = 4
  };

399 400 401 402 403 404
  enum EnclosingMethodAttributeOffset {
    enclosing_method_class_index_offset = 0,
    enclosing_method_method_index_offset = 1,
    enclosing_method_attribute_size = 2
  };

405
  // method override check
406
  bool is_override(methodHandle super_method, Handle targetclassloader, Symbol* targetclassname, TRAPS);
407

D
duke 已提交
408
  // package
409
  bool is_same_class_package(Klass* class2);
410 411
  bool is_same_class_package(oop classloader2, Symbol* classname2);
  static bool is_same_class_package(oop class_loader1, Symbol* class_name1, oop class_loader2, Symbol* class_name2);
D
duke 已提交
412

413
  // find an enclosing class (defined where original code was, in jvm.cpp!)
414 415
  Klass* compute_enclosing_class(bool* inner_is_member, TRAPS) {
    instanceKlassHandle self(THREAD, this);
416
    return compute_enclosing_class_impl(self, inner_is_member, THREAD);
417
  }
418
  static Klass* compute_enclosing_class_impl(instanceKlassHandle self,
419
                                               bool* inner_is_member, TRAPS);
420 421

  // tell if two classes have the same enclosing class (at package level)
422 423
  bool is_same_package_member(Klass* class2, TRAPS) {
    instanceKlassHandle self(THREAD, this);
424 425 426
    return is_same_package_member_impl(self, class2, THREAD);
  }
  static bool is_same_package_member_impl(instanceKlassHandle self,
427
                                          Klass* class2, TRAPS);
428

D
duke 已提交
429 430 431 432 433 434 435 436
  // initialization state
  bool is_loaded() const                   { return _init_state >= loaded; }
  bool is_linked() const                   { return _init_state >= linked; }
  bool is_initialized() const              { return _init_state == fully_initialized; }
  bool is_not_initialized() const          { return _init_state <  being_initialized; }
  bool is_being_initialized() const        { return _init_state == being_initialized; }
  bool is_in_error_state() const           { return _init_state == initialization_error; }
  bool is_reentrant_initialization(Thread *thread)  { return thread == _init_thread; }
437
  ClassState  init_state()                 { return (ClassState)_init_state; }
438
  bool is_rewritten() const                { return (_misc_flags & _misc_rewritten) != 0; }
439 440

  // defineClass specified verification
441 442 443 444 445 446 447 448 449 450
  bool should_verify_class() const         {
    return (_misc_flags & _misc_should_verify_class) != 0;
  }
  void set_should_verify_class(bool value) {
    if (value) {
      _misc_flags |= _misc_should_verify_class;
    } else {
      _misc_flags &= ~_misc_should_verify_class;
    }
  }
D
duke 已提交
451 452

  // marking
453 454
  bool is_marked_dependent() const         { return _is_marked_dependent; }
  void set_is_marked_dependent(bool value) { _is_marked_dependent = value; }
D
duke 已提交
455 456 457 458 459 460 461 462

  // initialization (virtuals from Klass)
  bool should_be_initialized() const;  // means that initialize should be called
  void initialize(TRAPS);
  void link_class(TRAPS);
  bool link_class_or_fail(TRAPS); // returns false on failure
  void unlink_class();
  void rewrite_class(TRAPS);
463
  void link_methods(TRAPS);
464
  Method* class_initializer();
D
duke 已提交
465 466 467 468 469

  // set the class to initialized if no static initializer is present
  void eager_initialize(Thread *thread);

  // reference type
470 471 472 473 474
  ReferenceType reference_type() const     { return (ReferenceType)_reference_type; }
  void set_reference_type(ReferenceType t) {
    assert(t == (u1)t, "overflow");
    _reference_type = (u1)t;
  }
D
duke 已提交
475

476
  static ByteSize reference_type_offset() { return in_ByteSize(offset_of(InstanceKlass, _reference_type)); }
477

D
duke 已提交
478
  // find local field, returns true if found
479
  bool find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
D
duke 已提交
480
  // find field in direct superinterfaces, returns the interface in which the field is defined
481
  Klass* find_interface_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
D
duke 已提交
482
  // find field according to JVM spec 5.4.3.2, returns the klass in which the field is defined
483
  Klass* find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
D
duke 已提交
484
  // find instance or static fields according to JVM spec 5.4.3.2, returns the klass in which the field is defined
485
  Klass* find_field(Symbol* name, Symbol* sig, bool is_static, fieldDescriptor* fd) const;
D
duke 已提交
486 487 488

  // find a non-static or static field given its offset within the class.
  bool contains_field_offset(int offset) {
489
    return instanceOopDesc::contains_field_offset(offset, nonstatic_field_size());
D
duke 已提交
490 491 492 493 494 495
  }

  bool find_local_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const;
  bool find_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const;

  // find a local method (returns NULL if not found)
496 497
  Method* find_method(Symbol* name, Symbol* signature) const;
  static Method* find_method(Array<Method*>* methods, Symbol* name, Symbol* signature);
D
duke 已提交
498 499

  // lookup operation (returns NULL if not found)
500
  Method* uncached_lookup_method(Symbol* name, Symbol* signature) const;
D
duke 已提交
501 502 503

  // lookup a method in all the interfaces that this class implements
  // (returns NULL if not found)
504
  Method* lookup_method_in_all_interfaces(Symbol* name, Symbol* signature) const;
D
duke 已提交
505

506 507 508 509 510 511 512
  // Find method indices by name.  If a method with the specified name is
  // found the index to the first method is returned, and 'end' is filled in
  // with the index of first non-name-matching method.  If no method is found
  // -1 is returned.
  int find_method_by_name(Symbol* name, int* end);
  static int find_method_by_name(Array<Method*>* methods, Symbol* name, int* end);

D
duke 已提交
513
  // constant pool
514 515
  ConstantPool* constants() const        { return _constants; }
  void set_constants(ConstantPool* c)    { _constants = c; }
D
duke 已提交
516 517 518

  // protection domain
  oop protection_domain()                  { return _protection_domain; }
519
  void set_protection_domain(oop pd)       { klass_oop_store(&_protection_domain, pd); }
D
duke 已提交
520

521
  // host class
522 523
  Klass* host_klass() const              {
    Klass** hk = (Klass**)adr_host_klass();
524 525 526 527 528 529
    if (hk == NULL) {
      return NULL;
    } else {
      return *hk;
    }
  }
530
  void set_host_klass(Klass* host)            {
531
    assert(is_anonymous(), "not anonymous");
532
    Klass** addr = (Klass**)adr_host_klass();
533
    assert(addr != NULL, "no reversed space");
534
    *addr = host;
535 536 537 538 539 540 541 542 543 544 545
  }
  bool is_anonymous() const                {
    return (_misc_flags & _misc_is_anonymous) != 0;
  }
  void set_is_anonymous(bool value)        {
    if (value) {
      _misc_flags |= _misc_is_anonymous;
    } else {
      _misc_flags &= ~_misc_is_anonymous;
    }
  }
546

547 548 549 550 551 552
  // Oop that keeps the metadata for this class from being unloaded
  // in places where the metadata is stored in other places, like nmethods
  oop klass_holder() const {
    return is_anonymous() ? java_mirror() : class_loader();
  }

D
duke 已提交
553 554
  // signers
  objArrayOop signers() const              { return _signers; }
555
  void set_signers(objArrayOop s)          { klass_oop_store((oop*)&_signers, s); }
D
duke 已提交
556 557

  // source file name
558 559
  Symbol* source_file_name() const         { return _source_file_name; }
  void set_source_file_name(Symbol* n);
D
duke 已提交
560 561 562 563 564 565 566 567

  // minor and major version numbers of class file
  u2 minor_version() const                 { return _minor_version; }
  void set_minor_version(u2 minor_version) { _minor_version = minor_version; }
  u2 major_version() const                 { return _major_version; }
  void set_major_version(u2 major_version) { _major_version = major_version; }

  // source debug extension
568 569
  char* source_debug_extension() const     { return _source_debug_extension; }
  void set_source_debug_extension(char* array, int length);
570 571 572 573

  // symbol unloading support (refcount already added)
  Symbol* array_name()                     { return _array_name; }
  void set_array_name(Symbol* name)        { assert(_array_name == NULL, "name already created"); _array_name = name; }
D
duke 已提交
574 575

  // nonstatic oop-map blocks
576
  static int nonstatic_oop_map_size(unsigned int oop_map_count) {
577 578
    return oop_map_count * OopMapBlock::size_in_words();
  }
579
  unsigned int nonstatic_oop_map_count() const {
580 581 582 583 584 585
    return _nonstatic_oop_map_size / OopMapBlock::size_in_words();
  }
  int nonstatic_oop_map_size() const { return _nonstatic_oop_map_size; }
  void set_nonstatic_oop_map_size(int words) {
    _nonstatic_oop_map_size = words;
  }
D
duke 已提交
586 587 588 589

  // RedefineClasses() support for previous versions:
  void add_previous_version(instanceKlassHandle ikh, BitMap *emcp_methods,
         int emcp_method_count);
590 591 592 593
  // If the _previous_versions array is non-NULL, then this klass
  // has been redefined at least once even if we aren't currently
  // tracking a previous version.
  bool has_been_redefined() const { return _previous_versions != NULL; }
D
duke 已提交
594 595 596 597 598 599 600 601
  bool has_previous_version() const;
  void init_previous_versions() {
    _previous_versions = NULL;
  }
  GrowableArray<PreviousVersionNode *>* previous_versions() const {
    return _previous_versions;
  }

602 603
  static void purge_previous_versions(InstanceKlass* ik);

D
duke 已提交
604 605 606 607 608 609 610 611 612 613 614 615 616 617 618
  // JVMTI: Support for caching a class file before it is modified by an agent that can do retransformation
  void set_cached_class_file(unsigned char *class_file_bytes,
                             jint class_file_len)     { _cached_class_file_len = class_file_len;
                                                        _cached_class_file_bytes = class_file_bytes; }
  jint get_cached_class_file_len()                    { return _cached_class_file_len; }
  unsigned char * get_cached_class_file_bytes()       { return _cached_class_file_bytes; }

  // JVMTI: Support for caching of field indices, types, and offsets
  void set_jvmti_cached_class_field_map(JvmtiCachedClassFieldMap* descriptor) {
    _jvmti_cached_class_field_map = descriptor;
  }
  JvmtiCachedClassFieldMap* jvmti_cached_class_field_map() const {
    return _jvmti_cached_class_field_map;
  }

619 620 621
  bool has_default_methods() const { return _has_default_methods; }
  void set_has_default_methods(bool b) { _has_default_methods = b; }

622
  // for adding methods, ConstMethod::UNSET_IDNUM means no more ids available
D
duke 已提交
623 624 625 626
  inline u2 next_method_idnum();
  void set_initial_method_idnum(u2 value)             { _idnum_allocated_count = value; }

  // generics support
627 628 629
  Symbol* generic_signature() const                   { return _generic_signature; }
  void set_generic_signature(Symbol* sig)             { _generic_signature = sig; }

630 631 632 633 634 635 636
  u2 enclosing_method_data(int offset);
  u2 enclosing_method_class_index() {
    return enclosing_method_data(enclosing_method_class_index_offset);
  }
  u2 enclosing_method_method_index() {
    return enclosing_method_data(enclosing_method_method_index_offset);
  }
D
duke 已提交
637
  void set_enclosing_method_indices(u2 class_index,
638
                                    u2 method_index);
D
duke 已提交
639 640

  // jmethodID support
641 642 643 644 645 646 647 648
  static jmethodID get_jmethod_id(instanceKlassHandle ik_h,
                     methodHandle method_h);
  static jmethodID get_jmethod_id_fetch_or_update(instanceKlassHandle ik_h,
                     size_t idnum, jmethodID new_id, jmethodID* new_jmeths,
                     jmethodID* to_dealloc_id_p,
                     jmethodID** to_dealloc_jmeths_p);
  static void get_jmethod_id_length_value(jmethodID* cache, size_t idnum,
                size_t *length_p, jmethodID* id_p);
649
  jmethodID jmethod_id_or_null(Method* method);
D
duke 已提交
650 651 652 653 654 655

  // cached itable index support
  void set_cached_itable_index(size_t idnum, int index);
  int cached_itable_index(size_t idnum);

  // annotations support
656 657 658 659 660 661 662 663 664 665
  Annotations* annotations() const          { return _annotations; }
  void set_annotations(Annotations* anno)   { _annotations = anno; }
  AnnotationArray* class_annotations() const {
    if (annotations() == NULL) return NULL;
    return annotations()->class_annotations();
  }
  Array<AnnotationArray*>* fields_annotations() const {
    if (annotations() == NULL) return NULL;
    return annotations()->fields_annotations();
  }
666 667 668 669
  Annotations* type_annotations() const {
    if (annotations() == NULL) return NULL;
    return annotations()->type_annotations();
  }
D
duke 已提交
670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708

  // allocation
  instanceOop allocate_instance(TRAPS);

  // additional member function to return a handle
  instanceHandle allocate_instance_handle(TRAPS)      { return instanceHandle(THREAD, allocate_instance(THREAD)); }

  objArrayOop allocate_objArray(int n, int length, TRAPS);
  // Helper function
  static instanceOop register_finalizer(instanceOop i, TRAPS);

  // Check whether reflection/jni/jvm code is allowed to instantiate this class;
  // if not, throw either an Error or an Exception.
  virtual void check_valid_for_instantiation(bool throwError, TRAPS);

  // initialization
  void call_class_initializer(TRAPS);
  void set_initialization_state_and_notify(ClassState state, TRAPS);

  // OopMapCache support
  OopMapCache* oop_map_cache()               { return _oop_map_cache; }
  void set_oop_map_cache(OopMapCache *cache) { _oop_map_cache = cache; }
  void mask_for(methodHandle method, int bci, InterpreterOopMap* entry);

  // JNI identifier support (for static fields - for jni performance)
  JNIid* jni_ids()                               { return _jni_ids; }
  void set_jni_ids(JNIid* ids)                   { _jni_ids = ids; }
  JNIid* jni_id_for(int offset);

  // maintenance of deoptimization dependencies
  int mark_dependent_nmethods(DepChange& changes);
  void add_dependent_nmethod(nmethod* nm);
  void remove_dependent_nmethod(nmethod* nm);

  // On-stack replacement support
  nmethod* osr_nmethods_head() const         { return _osr_nmethods_head; };
  void set_osr_nmethods_head(nmethod* h)     { _osr_nmethods_head = h; };
  void add_osr_nmethod(nmethod* n);
  void remove_osr_nmethod(nmethod* n);
709
  nmethod* lookup_osr_nmethod(Method* const m, int bci, int level, bool match_level) const;
D
duke 已提交
710

711
  // Breakpoint support (see methods on Method* for details)
D
duke 已提交
712 713 714 715
  BreakpointInfo* breakpoints() const       { return _breakpoints; };
  void set_breakpoints(BreakpointInfo* bps) { _breakpoints = bps; };

  // support for stub routines
716
  static ByteSize init_state_offset()  { return in_ByteSize(offset_of(InstanceKlass, _init_state)); }
717
  TRACE_DEFINE_OFFSET;
718
  static ByteSize init_thread_offset() { return in_ByteSize(offset_of(InstanceKlass, _init_thread)); }
D
duke 已提交
719 720

  // subclass/subinterface checks
721
  bool implements_interface(Klass* k) const;
D
duke 已提交
722

723
  // Access to the implementor of an interface.
724
  Klass* implementor() const
725
  {
726
    Klass** k = adr_implementor();
727 728 729 730 731 732 733
    if (k == NULL) {
      return NULL;
    } else {
      return *k;
    }
  }

734
  void set_implementor(Klass* k) {
735
    assert(is_interface(), "not interface");
736 737
    Klass** addr = adr_implementor();
    *addr = k;
738 739 740
  }

  int  nof_implementors() const       {
741
    Klass* k = implementor();
742 743
    if (k == NULL) {
      return 0;
744
    } else if (k != this) {
745 746 747 748
      return 1;
    } else {
      return 2;
    }
D
duke 已提交
749
  }
750

751
  void add_implementor(Klass* k);  // k is a new class that implements this interface
D
duke 已提交
752 753 754 755 756 757 758
  void init_implementor();           // initialize

  // link this class into the implementors list of every interface it implements
  void process_interfaces(Thread *thread);

  // virtual operations from Klass
  bool is_leaf_class() const               { return _subklass == NULL; }
759 760
  GrowableArray<Klass*>* compute_secondary_supers(int num_extra_slots);
  bool compute_is_subtype_of(Klass* k);
D
duke 已提交
761 762 763 764 765 766 767 768 769
  bool can_be_primary_super_slow() const;
  int oop_size(oop obj)  const             { return size_helper(); }
  bool oop_is_instance_slow() const        { return true; }

  // Iterators
  void do_local_static_fields(FieldClosure* cl);
  void do_nonstatic_fields(FieldClosure* cl); // including inherited fields
  void do_local_static_fields(void f(fieldDescriptor*, TRAPS), TRAPS);

770 771 772 773
  void methods_do(void f(Method* method));
  void array_klasses_do(void f(Klass* k));
  void array_klasses_do(void f(Klass* k, TRAPS), TRAPS);
  void with_array_klasses_do(void f(Klass* k));
D
duke 已提交
774 775
  bool super_types_do(SuperTypeClosure* blk);

776 777
  // Casting from Klass*
  static InstanceKlass* cast(Klass* k) {
778
    assert(k->is_klass(), "must be");
779 780
    assert(k->oop_is_instance(), "cast to InstanceKlass");
    return (InstanceKlass*) k;
D
duke 已提交
781 782
  }

783 784 785 786
  InstanceKlass* java_super() const {
    return (super() == NULL) ? NULL : cast(super());
  }

D
duke 已提交
787
  // Sizing (in words)
788 789 790 791 792 793 794 795 796 797 798 799
  static int header_size()            { return align_object_offset(sizeof(InstanceKlass)/HeapWordSize); }
  static int size(int vtable_length, int itable_length,
                  int nonstatic_oop_map_size,
                  bool is_interface, bool is_anonymous) {
    return align_object_size(header_size() +
           align_object_offset(vtable_length) +
           align_object_offset(itable_length) +
           ((is_interface || is_anonymous) ?
             align_object_offset(nonstatic_oop_map_size) :
             nonstatic_oop_map_size) +
           (is_interface ? (int)sizeof(Klass*)/HeapWordSize : 0) +
           (is_anonymous ? (int)sizeof(Klass*)/HeapWordSize : 0));
800
  }
801 802 803 804 805 806 807
  int size() const                    { return size(vtable_length(),
                                               itable_length(),
                                               nonstatic_oop_map_size(),
                                               is_interface(),
                                               is_anonymous());
  }

D
duke 已提交
808
  static int vtable_start_offset()    { return header_size(); }
809
  static int vtable_length_offset()   { return offset_of(InstanceKlass, _vtable_len) / HeapWordSize; }
D
duke 已提交
810

811
  intptr_t* start_of_vtable() const        { return ((intptr_t*)this) + vtable_start_offset(); }
D
duke 已提交
812
  intptr_t* start_of_itable() const        { return start_of_vtable() + align_object_offset(vtable_length()); }
813
  int  itable_offset_in_words() const { return start_of_itable() - (intptr_t*)this; }
D
duke 已提交
814 815 816

  intptr_t* end_of_itable() const          { return start_of_itable() + itable_length(); }

817
  address static_field_addr(int offset);
818 819

  OopMapBlock* start_of_nonstatic_oop_maps() const {
820
    return (OopMapBlock*)(start_of_itable() + align_object_offset(itable_length()));
821
  }
D
duke 已提交
822

823
  Klass** adr_implementor() const {
824
    if (is_interface()) {
825
      return (Klass**)(start_of_nonstatic_oop_maps() +
826
                    nonstatic_oop_map_count());
827 828 829 830 831
    } else {
      return NULL;
    }
  };

832
  Klass** adr_host_klass() const {
833
    if (is_anonymous()) {
834
      Klass** adr_impl = adr_implementor();
835 836 837
      if (adr_impl != NULL) {
        return adr_impl + 1;
      } else {
838
        return (Klass**)(start_of_nonstatic_oop_maps() +
839 840 841 842 843 844 845
                      nonstatic_oop_map_count());
      }
    } else {
      return NULL;
    }
  }

D
duke 已提交
846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866
  // Allocation profiling support
  juint alloc_size() const            { return _alloc_count * size_helper(); }
  void set_alloc_size(juint n)        {}

  // Use this to return the size of an instance in heap words:
  int size_helper() const {
    return layout_helper_to_size_helper(layout_helper());
  }

  // This bit is initialized in classFileParser.cpp.
  // It is false under any of the following conditions:
  //  - the class is abstract (including any interface)
  //  - the class has a finalizer (if !RegisterFinalizersAtInit)
  //  - the class size is larger than FastAllocateSizeLimit
  //  - the class is java/lang/Class, which cannot be allocated directly
  bool can_be_fastpath_allocated() const {
    return !layout_helper_needs_slow_path(layout_helper());
  }

  // Java vtable/itable
  klassVtable* vtable() const;        // return new klassVtable wrapper
867
  inline Method* method_at_vtable(int index);
D
duke 已提交
868
  klassItable* itable() const;        // return new klassItable wrapper
869
  Method* method_at_itable(Klass* holder, int index, TRAPS);
D
duke 已提交
870 871

  // Garbage collection
872 873
  virtual void oops_do(OopClosure* cl);

D
duke 已提交
874 875 876
  void oop_follow_contents(oop obj);
  int  oop_adjust_pointers(oop obj);

877 878 879 880 881 882 883 884 885 886 887
  void clean_implementors_list(BoolObjectClosure* is_alive);
  void clean_method_data(BoolObjectClosure* is_alive);

  // Explicit metaspace deallocation of fields
  // For RedefineClasses, we need to deallocate instanceKlasses
  void deallocate_contents(ClassLoaderData* loader_data);

  // The constant pool is on stack if any of the methods are executing or
  // referenced by handles.
  bool on_stack() const { return _constants->on_stack(); }

D
duke 已提交
888 889 890 891 892 893
  void release_C_heap_structures();

  // Parallel Scavenge and Parallel Old
  PARALLEL_GC_DECLS

  // Naming
894
  const char* signature_name() const;
D
duke 已提交
895 896

  // Iterators
897
  int oop_oop_iterate(oop obj, ExtendedOopClosure* blk) {
D
duke 已提交
898 899 900
    return oop_oop_iterate_v(obj, blk);
  }

901
  int oop_oop_iterate_m(oop obj, ExtendedOopClosure* blk, MemRegion mr) {
D
duke 已提交
902 903 904
    return oop_oop_iterate_v_m(obj, blk, mr);
  }

905 906 907
#define InstanceKlass_OOP_OOP_ITERATE_DECL(OopClosureType, nv_suffix)      \
  int  oop_oop_iterate##nv_suffix(oop obj, OopClosureType* blk);           \
  int  oop_oop_iterate##nv_suffix##_m(oop obj, OopClosureType* blk,        \
D
duke 已提交
908 909 910
                                      MemRegion mr);

  ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_DECL)
911 912 913 914 915 916 917 918 919
  ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_DECL)

#ifndef SERIALGC
#define InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix) \
  int  oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* blk);

  ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DECL)
  ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DECL)
#endif // !SERIALGC
D
duke 已提交
920

921
  u2 idnum_allocated_count() const      { return _idnum_allocated_count; }
D
duke 已提交
922 923 924 925 926
private:
  // initialization state
#ifdef ASSERT
  void set_init_state(ClassState state);
#else
927
  void set_init_state(ClassState state) { _init_state = (u1)state; }
D
duke 已提交
928
#endif
929
  void set_rewritten()                  { _misc_flags |= _misc_rewritten; }
D
duke 已提交
930 931
  void set_init_thread(Thread *thread)  { _init_thread = thread; }

932 933 934 935 936
  // The RedefineClasses() API can cause new method idnums to be needed
  // which will cause the caches to grow. Safety requires different
  // cache management logic if the caches can grow instead of just
  // going from NULL to non-NULL.
  bool idnum_can_increment() const      { return has_been_redefined(); }
D
duke 已提交
937 938 939 940 941 942 943 944 945 946
  jmethodID* methods_jmethod_ids_acquire() const
         { return (jmethodID*)OrderAccess::load_ptr_acquire(&_methods_jmethod_ids); }
  void release_set_methods_jmethod_ids(jmethodID* jmeths)
         { OrderAccess::release_store_ptr(&_methods_jmethod_ids, jmeths); }

  int* methods_cached_itable_indices_acquire() const
         { return (int*)OrderAccess::load_ptr_acquire(&_methods_cached_itable_indices); }
  void release_set_methods_cached_itable_indices(int* indices)
         { OrderAccess::release_store_ptr(&_methods_cached_itable_indices, indices); }

947 948 949 950
  // Lock during initialization
  volatile oop init_lock() const;
  void set_init_lock(oop value)      { klass_oop_store(&_init_lock, value); }
  void fence_and_clear_init_lock();  // after fully_initialized
D
duke 已提交
951 952 953 954

  // Offsets for memory management
  oop* adr_protection_domain() const { return (oop*)&this->_protection_domain;}
  oop* adr_signers() const           { return (oop*)&this->_signers;}
955
  oop* adr_init_lock() const         { return (oop*)&this->_init_lock;}
D
duke 已提交
956 957 958 959 960 961 962 963 964

  // Static methods that are used to implement member methods where an exposed this pointer
  // is needed due to possible GCs
  static bool link_class_impl                           (instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS);
  static bool verify_code                               (instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS);
  static void initialize_impl                           (instanceKlassHandle this_oop, TRAPS);
  static void eager_initialize_impl                     (instanceKlassHandle this_oop);
  static void set_initialization_state_and_notify_impl  (instanceKlassHandle this_oop, ClassState state, TRAPS);
  static void call_class_initializer_impl               (instanceKlassHandle this_oop, TRAPS);
965
  static Klass* array_klass_impl                      (instanceKlassHandle this_oop, bool or_null, int n, TRAPS);
D
duke 已提交
966 967 968 969 970
  static void do_local_static_fields_impl               (instanceKlassHandle this_oop, void f(fieldDescriptor* fd, TRAPS), TRAPS);
  /* jni_id_for_impl for jfieldID only */
  static JNIid* jni_id_for_impl                         (instanceKlassHandle this_oop, int offset);

  // Returns the array class for the n'th dimension
971
  Klass* array_klass_impl(bool or_null, int n, TRAPS);
D
duke 已提交
972 973

  // Returns the array class with this class as element type
974
  Klass* array_klass_impl(bool or_null, TRAPS);
D
duke 已提交
975 976

public:
977
  // CDS support - remove and restore oops from metadata. Oops are not shared.
D
duke 已提交
978
  virtual void remove_unshareable_info();
979
  virtual void restore_unshareable_info(TRAPS);
D
duke 已提交
980 981 982 983 984 985 986 987 988 989

  // jvm support
  jint compute_modifier_flags(TRAPS) const;

public:
  // JVMTI support
  jint jvmti_class_status() const;

 public:
  // Printing
990 991 992 993 994
#ifndef PRODUCT
  void print_on(outputStream* st) const;
#endif
  void print_value_on(outputStream* st) const;

D
duke 已提交
995
  void oop_print_value_on(oop obj, outputStream* st);
996

997 998
#ifndef PRODUCT
  void oop_print_on      (oop obj, outputStream* st);
D
duke 已提交
999 1000 1001 1002 1003 1004

  void print_dependent_nmethods(bool verbose = false);
  bool is_dependent_nmethod(nmethod* nm);
#endif

  const char* internal_name() const;
1005 1006 1007 1008

  // Verification
  void verify_on(outputStream* st);

D
duke 已提交
1009 1010 1011
  void oop_verify_on(oop obj, outputStream* st);
};

1012
inline Method* InstanceKlass::method_at_vtable(int index)  {
D
duke 已提交
1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024
#ifndef PRODUCT
  assert(index >= 0, "valid vtable index");
  if (DebugVtables) {
    verify_vtable_index(index);
  }
#endif
  vtableEntry* ve = (vtableEntry*)start_of_vtable();
  return ve[index].method();
}

// for adding methods
// UNSET_IDNUM return means no more ids available
1025 1026 1027
inline u2 InstanceKlass::next_method_idnum() {
  if (_idnum_allocated_count == ConstMethod::MAX_IDNUM) {
    return ConstMethod::UNSET_IDNUM; // no more ids available
D
duke 已提交
1028 1029 1030 1031 1032 1033 1034
  } else {
    return _idnum_allocated_count++;
  }
}


/* JNIid class for jfieldIDs only */
Z
zgu 已提交
1035
class JNIid: public CHeapObj<mtClass> {
D
duke 已提交
1036 1037
  friend class VMStructs;
 private:
1038
  Klass*             _holder;
D
duke 已提交
1039 1040 1041 1042 1043 1044 1045 1046
  JNIid*             _next;
  int                _offset;
#ifdef ASSERT
  bool               _is_static_field_id;
#endif

 public:
  // Accessors
1047
  Klass* holder() const           { return _holder; }
D
duke 已提交
1048 1049 1050
  int offset() const              { return _offset; }
  JNIid* next()                   { return _next; }
  // Constructor
1051
  JNIid(Klass* holder, int offset, JNIid* next);
D
duke 已提交
1052 1053 1054
  // Identifier lookup
  JNIid* find(int offset);

1055
  bool find_local_field(fieldDescriptor* fd) {
1056
    return InstanceKlass::cast(holder())->find_local_field_from_offset(offset(), true, fd);
1057 1058
  }

D
duke 已提交
1059 1060 1061 1062 1063 1064
  static void deallocate(JNIid* id);
  // Debugging
#ifdef ASSERT
  bool is_static_field_id() const { return _is_static_field_id; }
  void set_is_static_field_id()   { _is_static_field_id = true; }
#endif
1065
  void verify(Klass* holder);
D
duke 已提交
1066 1067 1068 1069 1070
};


// If breakpoints are more numerous than just JVMTI breakpoints,
// consider compressing this data structure.
1071
// It is currently a simple linked list defined in method.hpp.
D
duke 已提交
1072 1073 1074 1075 1076

class BreakpointInfo;


// A collection point for interesting information about the previous
1077
// version(s) of an InstanceKlass. This class uses weak references to
D
duke 已提交
1078
// the information so that the information may be collected as needed
1079 1080 1081
// by the system. If the information is shared, then a regular
// reference must be used because a weak reference would be seen as
// collectible. A GrowableArray of PreviousVersionNodes is attached
1082
// to the InstanceKlass as needed. See PreviousVersionWalker below.
Z
zgu 已提交
1083
class PreviousVersionNode : public CHeapObj<mtClass> {
D
duke 已提交
1084
 private:
1085 1086 1087 1088 1089
  // A shared ConstantPool is never collected so we'll always have
  // a reference to it so we can update items in the cache. We'll
  // have a weak reference to a non-shared ConstantPool until all
  // of the methods (EMCP or obsolete) have been collected; the
  // non-shared ConstantPool becomes collectible at that point.
1090
  ConstantPool*    _prev_constant_pool;  // regular or weak reference
1091 1092
  bool    _prev_cp_is_weak;     // true if not a shared ConstantPool

1093
  // If the previous version of the InstanceKlass doesn't have any
D
duke 已提交
1094 1095 1096
  // EMCP methods, then _prev_EMCP_methods will be NULL. If all the
  // EMCP methods have been collected, then _prev_EMCP_methods can
  // have a length of zero.
1097
  GrowableArray<Method*>* _prev_EMCP_methods;
D
duke 已提交
1098 1099

public:
1100 1101
  PreviousVersionNode(ConstantPool* prev_constant_pool, bool prev_cp_is_weak,
    GrowableArray<Method*>* prev_EMCP_methods);
D
duke 已提交
1102
  ~PreviousVersionNode();
1103
  ConstantPool* prev_constant_pool() const {
D
duke 已提交
1104 1105
    return _prev_constant_pool;
  }
1106
  GrowableArray<Method*>* prev_EMCP_methods() const {
D
duke 已提交
1107 1108 1109 1110 1111 1112 1113 1114 1115
    return _prev_EMCP_methods;
  }
};


// A Handle-ized version of PreviousVersionNode.
class PreviousVersionInfo : public ResourceObj {
 private:
  constantPoolHandle   _prev_constant_pool_handle;
1116
  // If the previous version of the InstanceKlass doesn't have any
D
duke 已提交
1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158
  // EMCP methods, then _prev_EMCP_methods will be NULL. Since the
  // methods cannot be collected while we hold a handle,
  // _prev_EMCP_methods should never have a length of zero.
  GrowableArray<methodHandle>* _prev_EMCP_method_handles;

public:
  PreviousVersionInfo(PreviousVersionNode *pv_node);
  ~PreviousVersionInfo();
  constantPoolHandle prev_constant_pool_handle() const {
    return _prev_constant_pool_handle;
  }
  GrowableArray<methodHandle>* prev_EMCP_method_handles() const {
    return _prev_EMCP_method_handles;
  }
};


// Helper object for walking previous versions. This helper cleans up
// the Handles that it allocates when the helper object is destroyed.
// The PreviousVersionInfo object returned by next_previous_version()
// is only valid until a subsequent call to next_previous_version() or
// the helper object is destroyed.
class PreviousVersionWalker : public StackObj {
 private:
  GrowableArray<PreviousVersionNode *>* _previous_versions;
  int                                   _current_index;
  // Fields for cleaning up when we are done walking the previous versions:
  // A HandleMark for the PreviousVersionInfo handles:
  HandleMark                            _hm;

  // It would be nice to have a ResourceMark field in this helper also,
  // but the ResourceMark code says to be careful to delete handles held
  // in GrowableArrays _before_ deleting the GrowableArray. Since we
  // can't guarantee the order in which the fields are destroyed, we
  // have to let the creator of the PreviousVersionWalker object do
  // the right thing. Also, adding a ResourceMark here causes an
  // include loop.

  // A pointer to the current info object so we can handle the deletes.
  PreviousVersionInfo *                 _current_p;

 public:
1159
  PreviousVersionWalker(InstanceKlass *ik);
D
duke 已提交
1160 1161 1162 1163 1164 1165
  ~PreviousVersionWalker();

  // Return the interesting information for the next previous version
  // of the klass. Returns NULL if there are no more previous versions.
  PreviousVersionInfo* next_previous_version();
};
1166

N
never 已提交
1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177

//
// nmethodBucket is used to record dependent nmethods for
// deoptimization.  nmethod dependencies are actually <klass, method>
// pairs but we really only care about the klass part for purposes of
// finding nmethods which might need to be deoptimized.  Instead of
// recording the method, a count of how many times a particular nmethod
// was recorded is kept.  This ensures that any recording errors are
// noticed since an nmethod should be removed as many times are it's
// added.
//
Z
zgu 已提交
1178
class nmethodBucket: public CHeapObj<mtClass> {
N
never 已提交
1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198
  friend class VMStructs;
 private:
  nmethod*       _nmethod;
  int            _count;
  nmethodBucket* _next;

 public:
  nmethodBucket(nmethod* nmethod, nmethodBucket* next) {
    _nmethod = nmethod;
    _next = next;
    _count = 1;
  }
  int count()                             { return _count; }
  int increment()                         { _count += 1; return _count; }
  int decrement()                         { _count -= 1; assert(_count >= 0, "don't underflow"); return _count; }
  nmethodBucket* next()                   { return _next; }
  void set_next(nmethodBucket* b)         { _next = b; }
  nmethod* get_nmethod()                  { return _nmethod; }
};

1199
// An iterator that's used to access the inner classes indices in the
1200
// InstanceKlass::_inner_classes array.
1201 1202
class InnerClassesIterator : public StackObj {
 private:
1203
  Array<jushort>* _inner_classes;
1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216
  int _length;
  int _idx;
 public:

  InnerClassesIterator(instanceKlassHandle k) {
    _inner_classes = k->inner_classes();
    if (k->inner_classes() != NULL) {
      _length = _inner_classes->length();
      // The inner class array's length should be the multiple of
      // inner_class_next_offset if it only contains the InnerClasses
      // attribute data, or it should be
      // n*inner_class_next_offset+enclosing_method_attribute_size
      // if it also contains the EnclosingMethod data.
1217 1218
      assert((_length % InstanceKlass::inner_class_next_offset == 0 ||
              _length % InstanceKlass::inner_class_next_offset == InstanceKlass::enclosing_method_attribute_size),
1219 1220
             "just checking");
      // Remove the enclosing_method portion if exists.
1221 1222
      if (_length % InstanceKlass::inner_class_next_offset == InstanceKlass::enclosing_method_attribute_size) {
        _length -= InstanceKlass::enclosing_method_attribute_size;
1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234
      }
    } else {
      _length = 0;
    }
    _idx = 0;
  }

  int length() const {
    return _length;
  }

  void next() {
1235
    _idx += InstanceKlass::inner_class_next_offset;
1236 1237 1238 1239 1240 1241 1242
  }

  bool done() const {
    return (_idx >= _length);
  }

  u2 inner_class_info_index() const {
1243 1244
    return _inner_classes->at(
               _idx + InstanceKlass::inner_class_inner_class_info_offset);
1245 1246 1247
  }

  void set_inner_class_info_index(u2 index) {
1248 1249
    _inner_classes->at_put(
               _idx + InstanceKlass::inner_class_inner_class_info_offset, index);
1250 1251 1252
  }

  u2 outer_class_info_index() const {
1253 1254
    return _inner_classes->at(
               _idx + InstanceKlass::inner_class_outer_class_info_offset);
1255 1256 1257
  }

  void set_outer_class_info_index(u2 index) {
1258 1259
    _inner_classes->at_put(
               _idx + InstanceKlass::inner_class_outer_class_info_offset, index);
1260 1261 1262
  }

  u2 inner_name_index() const {
1263 1264
    return _inner_classes->at(
               _idx + InstanceKlass::inner_class_inner_name_offset);
1265 1266 1267
  }

  void set_inner_name_index(u2 index) {
1268 1269
    _inner_classes->at_put(
               _idx + InstanceKlass::inner_class_inner_name_offset, index);
1270 1271 1272
  }

  u2 inner_access_flags() const {
1273 1274
    return _inner_classes->at(
               _idx + InstanceKlass::inner_class_access_flags_offset);
1275 1276 1277
  }
};

1278
#endif // SHARE_VM_OOPS_INSTANCEKLASS_HPP