instanceKlass.hpp 51.0 KB
Newer Older
D
duke 已提交
1
/*
2
 * Copyright (c) 1997, 2013, 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
#include "classfile/classLoaderData.hpp"
S
sla 已提交
29
#include "memory/referenceType.hpp"
30 31
#include "oops/annotations.hpp"
#include "oops/constMethod.hpp"
32
#include "oops/fieldInfo.hpp"
33 34
#include "oops/instanceOop.hpp"
#include "oops/klassVtable.hpp"
35
#include "runtime/atomic.hpp"
36 37 38 39
#include "runtime/handles.hpp"
#include "runtime/os.hpp"
#include "utilities/accessFlags.hpp"
#include "utilities/bitMap.inline.hpp"
40
#include "utilities/macros.hpp"
S
sla 已提交
41
#include "trace/traceMacros.hpp"
42

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

46
//  InstanceKlass layout:
D
duke 已提交
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 76
//    [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               ]
//    [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
77 78 79
//      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
80
//    [EMBEDDED host klass        ] only exist for an anonymous class (JSR 292 enabled)
D
duke 已提交
81 82 83 84 85 86 87 88 89 90 91 92


// 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;
93
class MemberNameTable;
D
duke 已提交
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112

// 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

113 114 115 116 117
// 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.
118 119
  int offset() const          { return _offset; }
  void set_offset(int offset) { _offset = offset; }
120 121

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

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

 private:
132 133
  int  _offset;
  uint _count;
134 135
};

136 137
struct JvmtiCachedClassFileData;

138
class InstanceKlass: public Klass {
D
duke 已提交
139
  friend class VMStructs;
140
  friend class ClassFileParser;
141
  friend class CompileReplay;
142 143 144 145 146 147 148 149 150 151

 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 已提交
152
 public:
153 154
  static InstanceKlass* allocate_instance_klass(
                                          ClassLoaderData* loader_data,
155 156 157 158 159 160 161
                                          int vtable_len,
                                          int itable_len,
                                          int static_field_size,
                                          int nonstatic_oop_map_size,
                                          ReferenceType rt,
                                          AccessFlags access_flags,
                                          Symbol* name,
C
coleenp 已提交
162 163
                                          Klass* super_klass,
                                          bool is_anonymous,
164 165 166 167
                                          TRAPS);

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

D
duke 已提交
168 169 170 171 172 173 174 175 176 177 178
  // 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
  };

179 180 181 182 183
  static int number_of_instance_classes() { return _total_instanceKlass_count; }

 private:
  static volatile int _total_instanceKlass_count;

D
duke 已提交
184
 protected:
185 186 187 188 189 190
  // Annotations for this class
  Annotations*    _annotations;
  // Array classes holding elements of this class.
  Klass*          _array_klasses;
  // Constant pool for this class.
  ConstantPool* _constants;
191 192 193 194 195 196 197 198 199 200 201
  // 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.
202
  Array<jushort>* _inner_classes;
D
duke 已提交
203

204
  // the source debug extension for this klass, NULL if not specified.
205 206 207
  // 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;
208 209 210 211
  // Array name derived from this class which needs unreferencing
  // if this class is unloaded.
  Symbol*         _array_name;

212 213
  // Number of heapOopSize words used by non-static fields in this klass
  // (including inherited fields but after header_size()).
214 215
  int             _nonstatic_field_size;
  int             _static_field_size;    // number words used by static fields (oop and non-oop) in this klass
216 217 218 219 220 221
  // Constant pool index to the utf8 entry of the Generic signature,
  // or 0 if none.
  u2              _generic_signature_index;
  // Constant pool index to the utf8 entry for the name of source file
  // containing this klass, 0 if not specified.
  u2              _source_file_name_index;
222 223
  u2              _static_oop_field_count;// number of static oop fields in this klass
  u2              _java_fields_count;    // The number of declared Java fields
224
  int             _nonstatic_oop_map_size;// size in words of nonstatic oop map blocks
225

226 227
  // _is_marked_dependent can be set concurrently, thus cannot be part of the
  // _misc_flags.
228
  bool            _is_marked_dependent;  // used for marking during flushing and deoptimization
229

230 231 232 233
  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
234
    _misc_is_anonymous         = 1 << 3, // has embedded _host_klass field
D
Merge  
dlong 已提交
235 236
    _misc_is_contended         = 1 << 4, // marked with contended annotation
    _misc_has_default_methods  = 1 << 5  // class/superclass/implemented interfaces has default methods
237 238
  };
  u2              _misc_flags;
D
duke 已提交
239 240 241 242 243 244
  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)
245
  MemberNameTable* _member_names;        // Member names
D
duke 已提交
246 247 248 249
  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
  nmethodBucket*  _dependencies;         // list of dependent nmethods
  nmethod*        _osr_nmethods_head;    // Head of list of on-stack replacement nmethods for this class
250
  BreakpointInfo* _breakpoints;          // bpt lists, managed by Method*
D
duke 已提交
251
  // Array of interesting part(s) of the previous version(s) of this
252
  // InstanceKlass. See PreviousVersionWalker below.
D
duke 已提交
253 254
  GrowableArray<PreviousVersionNode *>* _previous_versions;
  // JVMTI fields can be moved to their own structure - see 6315920
255 256
  // JVMTI: cached class file, before retransformable agent modified it in CFLH
  JvmtiCachedClassFileData* _cached_class_file;
257 258 259 260 261 262 263 264 265

  volatile u2     _idnum_allocated_count;         // JNI/JVMTI: increments with the addition of methods, old ids don't change

  // 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
  u1              _reference_type;                // reference type

D
duke 已提交
266
  JvmtiCachedClassFieldMap* _jvmti_cached_class_field_map;  // JVMTI: used during heap iteration
267

268 269
  NOT_PRODUCT(int _verify_count;)  // to avoid redundant verifies

270 271
  // Method array.
  Array<Method*>* _methods;
272 273
  // Default Method Array, concrete methods inherited from interfaces
  Array<Method*>* _default_methods;
274 275 276 277 278 279
  // 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;
280 281 282 283
  // Int array containing the vtable_indices for default_methods
  // offset matches _default_methods offset
  Array<int>*     _default_vtable_indices;

284 285 286 287 288 289 290 291 292 293 294 295 296 297
  // 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 已提交
298 299 300 301 302

  // embedded Java vtable follows here
  // embedded Java itables follows here
  // embedded static fields follows here
  // embedded nonstatic oop-map blocks follows here
303 304 305 306 307
  // 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.
308
  //     A Klass* that's not itself: one implementor.
309
  //     Itsef: more than one implementors.
310 311 312 313 314 315 316 317
  // 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 已提交
318 319 320 321

  friend class SystemDictionary;

 public:
322 323 324 325 326 327 328 329 330 331
  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;
    }
  }
332

D
duke 已提交
333 334 335 336 337 338 339
  // 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; }

340 341
  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 已提交
342 343 344 345 346 347 348 349 350 351

  // 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
352 353
  Klass* array_klasses() const             { return _array_klasses; }
  void set_array_klasses(Klass* k)         { _array_klasses = k; }
D
duke 已提交
354 355

  // methods
356 357 358
  Array<Method*>* methods() const          { return _methods; }
  void set_methods(Array<Method*>* a)      { _methods = a; }
  Method* method_with_idnum(int idnum);
D
duke 已提交
359 360

  // method ordering
361 362
  Array<int>* method_ordering() const     { return _method_ordering; }
  void set_method_ordering(Array<int>* m) { _method_ordering = m; }
363
  void copy_method_ordering(intArray* m, TRAPS);
D
duke 已提交
364

365 366 367 368 369 370 371 372 373
  // default_methods
  Array<Method*>* default_methods() const  { return _default_methods; }
  void set_default_methods(Array<Method*>* a) { _default_methods = a; }

  // default method vtable_indices
  Array<int>* default_vtable_indices() const { return _default_vtable_indices; }
  void set_default_vtable_indices(Array<int>* v) { _default_vtable_indices = v; }
  Array<int>* create_new_default_vtable_indices(int len, TRAPS);

D
duke 已提交
374
  // interfaces
375 376 377 378
  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; }
379

380 381 382
  Array<Klass*>* transitive_interfaces() const     { return _transitive_interfaces; }
  void set_transitive_interfaces(Array<Klass*>* a) {
    guarantee(_transitive_interfaces == NULL || a == NULL, "Just checking");
383 384
    _transitive_interfaces = a;
  }
D
duke 已提交
385

386 387 388 389 390 391 392 393 394 395 396
 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
397
  int java_fields_count() const           { return (int)_java_fields_count; }
398

399 400 401
  Array<u2>* fields() const            { return _fields; }
  void set_fields(Array<u2>* f, u2 java_fields_count) {
    guarantee(_fields == NULL || f == NULL, "Just checking");
402
    _fields = f;
403 404
    _java_fields_count = java_fields_count;
  }
D
duke 已提交
405 406

  // inner classes
407 408
  Array<u2>* inner_classes() const       { return _inner_classes; }
  void set_inner_classes(Array<u2>* f)   { _inner_classes = f; }
D
duke 已提交
409 410 411 412 413 414 415 416 417 418

  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
  };

419 420 421 422 423 424
  enum EnclosingMethodAttributeOffset {
    enclosing_method_class_index_offset = 0,
    enclosing_method_method_index_offset = 1,
    enclosing_method_attribute_size = 2
  };

425
  // method override check
426
  bool is_override(methodHandle super_method, Handle targetclassloader, Symbol* targetclassname, TRAPS);
427

D
duke 已提交
428
  // package
429
  bool is_same_class_package(Klass* class2);
430 431
  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 已提交
432

433
  // find an enclosing class (defined where original code was, in jvm.cpp!)
434 435
  Klass* compute_enclosing_class(bool* inner_is_member, TRAPS) {
    instanceKlassHandle self(THREAD, this);
436
    return compute_enclosing_class_impl(self, inner_is_member, THREAD);
437
  }
438
  static Klass* compute_enclosing_class_impl(instanceKlassHandle self,
439
                                               bool* inner_is_member, TRAPS);
440 441

  // tell if two classes have the same enclosing class (at package level)
442 443
  bool is_same_package_member(Klass* class2, TRAPS) {
    instanceKlassHandle self(THREAD, this);
444 445 446
    return is_same_package_member_impl(self, class2, THREAD);
  }
  static bool is_same_package_member_impl(instanceKlassHandle self,
447
                                          Klass* class2, TRAPS);
448

D
duke 已提交
449 450 451 452 453 454 455 456
  // 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; }
457
  ClassState  init_state()                 { return (ClassState)_init_state; }
458
  bool is_rewritten() const                { return (_misc_flags & _misc_rewritten) != 0; }
459 460

  // defineClass specified verification
461 462 463 464 465 466 467 468 469 470
  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 已提交
471 472

  // marking
473 474
  bool is_marked_dependent() const         { return _is_marked_dependent; }
  void set_is_marked_dependent(bool value) { _is_marked_dependent = value; }
D
duke 已提交
475 476 477 478 479 480 481 482

  // 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);
483
  void link_methods(TRAPS);
484
  Method* class_initializer();
D
duke 已提交
485 486 487 488 489

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

  // reference type
490 491 492 493 494
  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 已提交
495

496
  static ByteSize reference_type_offset() { return in_ByteSize(offset_of(InstanceKlass, _reference_type)); }
497

D
duke 已提交
498
  // find local field, returns true if found
499
  bool find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
D
duke 已提交
500
  // find field in direct superinterfaces, returns the interface in which the field is defined
501
  Klass* find_interface_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
D
duke 已提交
502
  // find field according to JVM spec 5.4.3.2, returns the klass in which the field is defined
503
  Klass* find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
D
duke 已提交
504
  // find instance or static fields according to JVM spec 5.4.3.2, returns the klass in which the field is defined
505
  Klass* find_field(Symbol* name, Symbol* sig, bool is_static, fieldDescriptor* fd) const;
D
duke 已提交
506 507 508

  // find a non-static or static field given its offset within the class.
  bool contains_field_offset(int offset) {
509
    return instanceOopDesc::contains_field_offset(offset, nonstatic_field_size());
D
duke 已提交
510 511 512 513 514 515
  }

  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)
516 517
  Method* find_method(Symbol* name, Symbol* signature) const;
  static Method* find_method(Array<Method*>* methods, Symbol* name, Symbol* signature);
518
  static Method* find_instance_method(Array<Method*>* methods, Symbol* name, Symbol* signature);
D
duke 已提交
519

520 521 522
  // find a local method index in default_methods (returns -1 if not found)
  static int find_method_index(Array<Method*>* methods, Symbol* name, Symbol* signature);

D
duke 已提交
523
  // lookup operation (returns NULL if not found)
524
  Method* uncached_lookup_method(Symbol* name, Symbol* signature) const;
D
duke 已提交
525 526 527

  // lookup a method in all the interfaces that this class implements
  // (returns NULL if not found)
528
  Method* lookup_method_in_all_interfaces(Symbol* name, Symbol* signature) const;
529 530 531
  // lookup a method in local defaults then in all interfaces
  // (returns NULL if not found)
  Method* lookup_method_in_ordered_interfaces(Symbol* name, Symbol* signature) const;
D
duke 已提交
532

533 534 535 536 537 538 539
  // 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 已提交
540
  // constant pool
541 542
  ConstantPool* constants() const        { return _constants; }
  void set_constants(ConstantPool* c)    { _constants = c; }
D
duke 已提交
543 544

  // protection domain
545 546 547 548
  oop protection_domain() const;

  // signers
  objArrayOop signers() const;
D
duke 已提交
549

550
  // host class
551 552
  Klass* host_klass() const              {
    Klass** hk = (Klass**)adr_host_klass();
553 554 555 556 557 558
    if (hk == NULL) {
      return NULL;
    } else {
      return *hk;
    }
  }
559
  void set_host_klass(Klass* host)            {
560
    assert(is_anonymous(), "not anonymous");
561
    Klass** addr = (Klass**)adr_host_klass();
562
    assert(addr != NULL, "no reversed space");
563 564 565
    if (addr != NULL) {
      *addr = host;
    }
566 567 568 569 570 571 572 573 574 575 576
  }
  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;
    }
  }
577

578 579 580 581 582 583
  // 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();
  }

584 585 586 587 588 589 590 591 592 593 594
  bool is_contended() const                {
    return (_misc_flags & _misc_is_contended) != 0;
  }
  void set_is_contended(bool value)        {
    if (value) {
      _misc_flags |= _misc_is_contended;
    } else {
      _misc_flags &= ~_misc_is_contended;
    }
  }

D
duke 已提交
595
  // source file name
596 597 598 599 600 601 602 603 604 605
  Symbol* source_file_name() const               {
    return (_source_file_name_index == 0) ?
      (Symbol*)NULL : _constants->symbol_at(_source_file_name_index);
  }
  u2 source_file_name_index() const              {
    return _source_file_name_index;
  }
  void set_source_file_name_index(u2 sourcefile_index) {
    _source_file_name_index = sourcefile_index;
  }
D
duke 已提交
606 607 608 609 610 611 612 613

  // 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
614 615
  char* source_debug_extension() const     { return _source_debug_extension; }
  void set_source_debug_extension(char* array, int length);
616 617 618

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

  // nonstatic oop-map blocks
622
  static int nonstatic_oop_map_size(unsigned int oop_map_count) {
623 624
    return oop_map_count * OopMapBlock::size_in_words();
  }
625
  unsigned int nonstatic_oop_map_count() const {
626 627 628 629 630 631
    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 已提交
632 633 634 635

  // RedefineClasses() support for previous versions:
  void add_previous_version(instanceKlassHandle ikh, BitMap *emcp_methods,
         int emcp_method_count);
636 637 638 639
  // 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 已提交
640 641 642 643 644 645 646 647
  bool has_previous_version() const;
  void init_previous_versions() {
    _previous_versions = NULL;
  }
  GrowableArray<PreviousVersionNode *>* previous_versions() const {
    return _previous_versions;
  }

648 649
  static void purge_previous_versions(InstanceKlass* ik);

D
duke 已提交
650
  // JVMTI: Support for caching a class file before it is modified by an agent that can do retransformation
651 652 653 654 655 656
  void set_cached_class_file(JvmtiCachedClassFileData *data) {
    _cached_class_file = data;
  }
  JvmtiCachedClassFileData * get_cached_class_file() { return _cached_class_file; }
  jint get_cached_class_file_len();
  unsigned char * get_cached_class_file_bytes();
D
duke 已提交
657 658 659 660 661 662 663 664 665

  // 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;
  }

666 667 668 669 670 671 672 673 674 675
  bool has_default_methods() const {
    return (_misc_flags & _misc_has_default_methods) != 0;
  }
  void set_has_default_methods(bool b) {
    if (b) {
      _misc_flags |= _misc_has_default_methods;
    } else {
      _misc_flags &= ~_misc_has_default_methods;
    }
  }
676

677
  // for adding methods, ConstMethod::UNSET_IDNUM means no more ids available
D
duke 已提交
678 679 680 681
  inline u2 next_method_idnum();
  void set_initial_method_idnum(u2 value)             { _idnum_allocated_count = value; }

  // generics support
682 683 684 685 686 687 688 689 690 691
  Symbol* generic_signature() const                   {
    return (_generic_signature_index == 0) ?
      (Symbol*)NULL : _constants->symbol_at(_generic_signature_index);
  }
  u2 generic_signature_index() const                  {
    return _generic_signature_index;
  }
  void set_generic_signature_index(u2 sig_index)      {
    _generic_signature_index = sig_index;
  }
692

693 694 695 696 697 698 699
  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 已提交
700
  void set_enclosing_method_indices(u2 class_index,
701
                                    u2 method_index);
D
duke 已提交
702 703

  // jmethodID support
704 705 706 707 708 709 710 711
  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);
712
  jmethodID jmethod_id_or_null(Method* method);
D
duke 已提交
713 714

  // annotations support
715 716
  Annotations* annotations() const          { return _annotations; }
  void set_annotations(Annotations* anno)   { _annotations = anno; }
C
coleenp 已提交
717

718
  AnnotationArray* class_annotations() const {
C
coleenp 已提交
719
    return (_annotations != NULL) ? _annotations->class_annotations() : NULL;
720 721
  }
  Array<AnnotationArray*>* fields_annotations() const {
C
coleenp 已提交
722
    return (_annotations != NULL) ? _annotations->fields_annotations() : NULL;
723
  }
C
coleenp 已提交
724 725 726 727 728
  AnnotationArray* class_type_annotations() const {
    return (_annotations != NULL) ? _annotations->class_type_annotations() : NULL;
  }
  Array<AnnotationArray*>* fields_type_annotations() const {
    return (_annotations != NULL) ? _annotations->fields_type_annotations() : NULL;
729
  }
D
duke 已提交
730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767
  // 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);
768
  nmethod* lookup_osr_nmethod(const Method* m, int bci, int level, bool match_level) const;
D
duke 已提交
769

770
  // Breakpoint support (see methods on Method* for details)
D
duke 已提交
771 772 773 774
  BreakpointInfo* breakpoints() const       { return _breakpoints; };
  void set_breakpoints(BreakpointInfo* bps) { _breakpoints = bps; };

  // support for stub routines
775
  static ByteSize init_state_offset()  { return in_ByteSize(offset_of(InstanceKlass, _init_state)); }
776
  TRACE_DEFINE_OFFSET;
777
  static ByteSize init_thread_offset() { return in_ByteSize(offset_of(InstanceKlass, _init_thread)); }
D
duke 已提交
778 779

  // subclass/subinterface checks
780
  bool implements_interface(Klass* k) const;
781
  bool is_same_or_direct_interface(Klass* k) const;
D
duke 已提交
782

783
  // Access to the implementor of an interface.
784
  Klass* implementor() const
785
  {
786
    Klass** k = adr_implementor();
787 788 789 790 791 792 793
    if (k == NULL) {
      return NULL;
    } else {
      return *k;
    }
  }

794
  void set_implementor(Klass* k) {
795
    assert(is_interface(), "not interface");
796
    Klass** addr = adr_implementor();
797 798 799 800
    assert(addr != NULL, "null addr");
    if (addr != NULL) {
      *addr = k;
    }
801 802 803
  }

  int  nof_implementors() const       {
804
    Klass* k = implementor();
805 806
    if (k == NULL) {
      return 0;
807
    } else if (k != this) {
808 809 810 811
      return 1;
    } else {
      return 2;
    }
D
duke 已提交
812
  }
813

814
  void add_implementor(Klass* k);  // k is a new class that implements this interface
D
duke 已提交
815 816 817 818 819 820 821
  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; }
822 823
  GrowableArray<Klass*>* compute_secondary_supers(int num_extra_slots);
  bool compute_is_subtype_of(Klass* k);
D
duke 已提交
824 825 826 827 828 829 830 831 832
  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);

833 834 835
  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);
D
duke 已提交
836 837
  bool super_types_do(SuperTypeClosure* blk);

838 839
  // Casting from Klass*
  static InstanceKlass* cast(Klass* k) {
840
    assert(k->is_klass(), "must be");
841 842
    assert(k->oop_is_instance(), "cast to InstanceKlass");
    return (InstanceKlass*) k;
D
duke 已提交
843 844
  }

845 846 847 848
  InstanceKlass* java_super() const {
    return (super() == NULL) ? NULL : cast(super());
  }

D
duke 已提交
849
  // Sizing (in words)
850
  static int header_size()            { return align_object_offset(sizeof(InstanceKlass)/HeapWordSize); }
C
coleenp 已提交
851

852 853 854 855 856 857 858 859 860 861 862
  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));
863
  }
864 865 866 867 868 869
  int size() const                    { return size(vtable_length(),
                                               itable_length(),
                                               nonstatic_oop_map_size(),
                                               is_interface(),
                                               is_anonymous());
  }
870 871 872
#if INCLUDE_SERVICES
  virtual void collect_statistics(KlassSizeStats *sz) const;
#endif
873

D
duke 已提交
874
  static int vtable_start_offset()    { return header_size(); }
875
  static int vtable_length_offset()   { return offset_of(InstanceKlass, _vtable_len) / HeapWordSize; }
D
duke 已提交
876

877
  intptr_t* start_of_vtable() const        { return ((intptr_t*)this) + vtable_start_offset(); }
D
duke 已提交
878
  intptr_t* start_of_itable() const        { return start_of_vtable() + align_object_offset(vtable_length()); }
879
  int  itable_offset_in_words() const { return start_of_itable() - (intptr_t*)this; }
D
duke 已提交
880 881 882

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

883
  address static_field_addr(int offset);
884 885

  OopMapBlock* start_of_nonstatic_oop_maps() const {
886
    return (OopMapBlock*)(start_of_itable() + align_object_offset(itable_length()));
887
  }
D
duke 已提交
888

C
coleenp 已提交
889 890 891 892 893
  Klass** end_of_nonstatic_oop_maps() const {
    return (Klass**)(start_of_nonstatic_oop_maps() +
                     nonstatic_oop_map_count());
  }

894
  Klass** adr_implementor() const {
895
    if (is_interface()) {
C
coleenp 已提交
896
      return (Klass**)end_of_nonstatic_oop_maps();
897 898 899 900 901
    } else {
      return NULL;
    }
  };

902
  Klass** adr_host_klass() const {
903
    if (is_anonymous()) {
904
      Klass** adr_impl = adr_implementor();
905 906 907
      if (adr_impl != NULL) {
        return adr_impl + 1;
      } else {
C
coleenp 已提交
908
        return end_of_nonstatic_oop_maps();
909 910 911 912 913 914
      }
    } else {
      return NULL;
    }
  }

D
duke 已提交
915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931
  // 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
932
  inline Method* method_at_vtable(int index);
D
duke 已提交
933
  klassItable* itable() const;        // return new klassItable wrapper
934
  Method* method_at_itable(Klass* holder, int index, TRAPS);
D
duke 已提交
935

936 937 938 939 940
#if INCLUDE_JVMTI
  void adjust_default_methods(Method** old_methods, Method** new_methods,
                              int methods_length, bool* trace_name_printed);
#endif // INCLUDE_JVMTI

D
duke 已提交
941 942 943 944
  // Garbage collection
  void oop_follow_contents(oop obj);
  int  oop_adjust_pointers(oop obj);

945 946 947 948
  void clean_implementors_list(BoolObjectClosure* is_alive);
  void clean_method_data(BoolObjectClosure* is_alive);

  // Explicit metaspace deallocation of fields
949 950
  // For RedefineClasses and class file parsing errors, we need to deallocate
  // instanceKlasses and the metadata they point to.
951
  void deallocate_contents(ClassLoaderData* loader_data);
952 953 954 955 956 957
  static void deallocate_methods(ClassLoaderData* loader_data,
                                 Array<Method*>* methods);
  void static deallocate_interfaces(ClassLoaderData* loader_data,
                                    Klass* super_klass,
                                    Array<Klass*>* local_interfaces,
                                    Array<Klass*>* transitive_interfaces);
958 959 960 961 962

  // 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(); }

963 964 965
  // callbacks for actions during class unloading
  static void notify_unload_class(InstanceKlass* ik);
  static void release_C_heap_structures(InstanceKlass* ik);
D
duke 已提交
966 967 968 969 970

  // Parallel Scavenge and Parallel Old
  PARALLEL_GC_DECLS

  // Naming
971
  const char* signature_name() const;
D
duke 已提交
972 973

  // Iterators
974
  int oop_oop_iterate(oop obj, ExtendedOopClosure* blk) {
D
duke 已提交
975 976 977
    return oop_oop_iterate_v(obj, blk);
  }

978
  int oop_oop_iterate_m(oop obj, ExtendedOopClosure* blk, MemRegion mr) {
D
duke 已提交
979 980 981
    return oop_oop_iterate_v_m(obj, blk, mr);
  }

982 983 984
#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 已提交
985 986 987
                                      MemRegion mr);

  ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_DECL)
988 989
  ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_DECL)

990
#if INCLUDE_ALL_GCS
991 992 993 994 995
#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)
996
#endif // INCLUDE_ALL_GCS
D
duke 已提交
997

998
  u2 idnum_allocated_count() const      { return _idnum_allocated_count; }
999

D
duke 已提交
1000 1001 1002 1003 1004
private:
  // initialization state
#ifdef ASSERT
  void set_init_state(ClassState state);
#else
1005
  void set_init_state(ClassState state) { _init_state = (u1)state; }
D
duke 已提交
1006
#endif
1007
  void set_rewritten()                  { _misc_flags |= _misc_rewritten; }
D
duke 已提交
1008 1009
  void set_init_thread(Thread *thread)  { _init_thread = thread; }

1010 1011 1012 1013 1014
  // 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 已提交
1015 1016 1017 1018 1019
  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); }

1020
  // Lock during initialization
1021
public:
1022 1023 1024 1025
  // Lock for (1) initialization; (2) access to the ConstantPool of this class.
  // 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.
1026
  oop init_lock() const;
1027
private:
1028
  void fence_and_clear_init_lock();
D
duke 已提交
1029 1030 1031 1032 1033 1034 1035 1036 1037

  // 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);
1038
  static Klass* array_klass_impl                      (instanceKlassHandle this_oop, bool or_null, int n, TRAPS);
D
duke 已提交
1039 1040 1041 1042 1043
  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
1044
  Klass* array_klass_impl(bool or_null, int n, TRAPS);
D
duke 已提交
1045 1046

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

1049 1050
  // Free CHeap allocated fields.
  void release_C_heap_structures();
D
duke 已提交
1051
public:
1052
  // CDS support - remove and restore oops from metadata. Oops are not shared.
D
duke 已提交
1053
  virtual void remove_unshareable_info();
1054
  virtual void restore_unshareable_info(TRAPS);
D
duke 已提交
1055 1056 1057 1058

  // jvm support
  jint compute_modifier_flags(TRAPS) const;

1059 1060 1061
  // JSR-292 support
  MemberNameTable* member_names() { return _member_names; }
  void set_member_names(MemberNameTable* member_names) { _member_names = member_names; }
1062 1063
  void add_member_name(int index, Handle member_name);
  oop  get_member_name(int index);
1064

D
duke 已提交
1065 1066 1067 1068 1069 1070
public:
  // JVMTI support
  jint jvmti_class_status() const;

 public:
  // Printing
1071 1072 1073 1074 1075
#ifndef PRODUCT
  void print_on(outputStream* st) const;
#endif
  void print_value_on(outputStream* st) const;

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

1078 1079
#ifndef PRODUCT
  void oop_print_on      (oop obj, outputStream* st);
D
duke 已提交
1080 1081 1082 1083 1084 1085

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

  const char* internal_name() const;
1086 1087

  // Verification
1088
  void verify_on(outputStream* st, bool check_dictionary);
1089

D
duke 已提交
1090 1091 1092
  void oop_verify_on(oop obj, outputStream* st);
};

1093
inline Method* InstanceKlass::method_at_vtable(int index)  {
D
duke 已提交
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105
#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
1106 1107 1108
inline u2 InstanceKlass::next_method_idnum() {
  if (_idnum_allocated_count == ConstMethod::MAX_IDNUM) {
    return ConstMethod::UNSET_IDNUM; // no more ids available
D
duke 已提交
1109 1110 1111 1112 1113 1114 1115
  } else {
    return _idnum_allocated_count++;
  }
}


/* JNIid class for jfieldIDs only */
Z
zgu 已提交
1116
class JNIid: public CHeapObj<mtClass> {
D
duke 已提交
1117 1118
  friend class VMStructs;
 private:
1119
  Klass*             _holder;
D
duke 已提交
1120 1121 1122 1123 1124 1125 1126 1127
  JNIid*             _next;
  int                _offset;
#ifdef ASSERT
  bool               _is_static_field_id;
#endif

 public:
  // Accessors
1128
  Klass* holder() const           { return _holder; }
D
duke 已提交
1129 1130 1131
  int offset() const              { return _offset; }
  JNIid* next()                   { return _next; }
  // Constructor
1132
  JNIid(Klass* holder, int offset, JNIid* next);
D
duke 已提交
1133 1134 1135
  // Identifier lookup
  JNIid* find(int offset);

1136
  bool find_local_field(fieldDescriptor* fd) {
1137
    return InstanceKlass::cast(holder())->find_local_field_from_offset(offset(), true, fd);
1138 1139
  }

D
duke 已提交
1140 1141 1142 1143 1144 1145
  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
1146
  void verify(Klass* holder);
D
duke 已提交
1147 1148 1149 1150 1151
};


// If breakpoints are more numerous than just JVMTI breakpoints,
// consider compressing this data structure.
1152
// It is currently a simple linked list defined in method.hpp.
D
duke 已提交
1153 1154 1155 1156 1157

class BreakpointInfo;


// A collection point for interesting information about the previous
1158 1159
// version(s) of an InstanceKlass.  A GrowableArray of PreviousVersionNodes
// is attached to the InstanceKlass as needed. See PreviousVersionWalker below.
Z
zgu 已提交
1160
class PreviousVersionNode : public CHeapObj<mtClass> {
D
duke 已提交
1161
 private:
1162
  ConstantPool*    _prev_constant_pool;
1163

1164
  // If the previous version of the InstanceKlass doesn't have any
D
duke 已提交
1165 1166 1167
  // 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.
1168
  GrowableArray<Method*>* _prev_EMCP_methods;
D
duke 已提交
1169 1170

public:
1171 1172
  PreviousVersionNode(ConstantPool* prev_constant_pool,
                      GrowableArray<Method*>* prev_EMCP_methods);
D
duke 已提交
1173
  ~PreviousVersionNode();
1174
  ConstantPool* prev_constant_pool() const {
D
duke 已提交
1175 1176
    return _prev_constant_pool;
  }
1177
  GrowableArray<Method*>* prev_EMCP_methods() const {
D
duke 已提交
1178 1179 1180 1181 1182
    return _prev_EMCP_methods;
  }
};


1183
// Helper object for walking previous versions.
D
duke 已提交
1184 1185
class PreviousVersionWalker : public StackObj {
 private:
1186
  Thread*                               _thread;
D
duke 已提交
1187 1188 1189
  GrowableArray<PreviousVersionNode *>* _previous_versions;
  int                                   _current_index;

1190 1191
  // A pointer to the current node object so we can handle the deletes.
  PreviousVersionNode*                  _current_p;
D
duke 已提交
1192

1193 1194 1195
  // The constant pool handle keeps all the methods in this class from being
  // deallocated from the metaspace during class unloading.
  constantPoolHandle                    _current_constant_pool_handle;
D
duke 已提交
1196 1197

 public:
1198
  PreviousVersionWalker(Thread* thread, InstanceKlass *ik);
D
duke 已提交
1199 1200 1201

  // Return the interesting information for the next previous version
  // of the klass. Returns NULL if there are no more previous versions.
1202
  PreviousVersionNode* next_previous_version();
D
duke 已提交
1203
};
1204

N
never 已提交
1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215

//
// 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 已提交
1216
class nmethodBucket: public CHeapObj<mtClass> {
N
never 已提交
1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236
  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; }
};

1237
// An iterator that's used to access the inner classes indices in the
1238
// InstanceKlass::_inner_classes array.
1239 1240
class InnerClassesIterator : public StackObj {
 private:
1241
  Array<jushort>* _inner_classes;
1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
  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.
1255 1256
      assert((_length % InstanceKlass::inner_class_next_offset == 0 ||
              _length % InstanceKlass::inner_class_next_offset == InstanceKlass::enclosing_method_attribute_size),
1257 1258
             "just checking");
      // Remove the enclosing_method portion if exists.
1259 1260
      if (_length % InstanceKlass::inner_class_next_offset == InstanceKlass::enclosing_method_attribute_size) {
        _length -= InstanceKlass::enclosing_method_attribute_size;
1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272
      }
    } else {
      _length = 0;
    }
    _idx = 0;
  }

  int length() const {
    return _length;
  }

  void next() {
1273
    _idx += InstanceKlass::inner_class_next_offset;
1274 1275 1276 1277 1278 1279 1280
  }

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

  u2 inner_class_info_index() const {
1281 1282
    return _inner_classes->at(
               _idx + InstanceKlass::inner_class_inner_class_info_offset);
1283 1284 1285
  }

  void set_inner_class_info_index(u2 index) {
1286 1287
    _inner_classes->at_put(
               _idx + InstanceKlass::inner_class_inner_class_info_offset, index);
1288 1289 1290
  }

  u2 outer_class_info_index() const {
1291 1292
    return _inner_classes->at(
               _idx + InstanceKlass::inner_class_outer_class_info_offset);
1293 1294 1295
  }

  void set_outer_class_info_index(u2 index) {
1296 1297
    _inner_classes->at_put(
               _idx + InstanceKlass::inner_class_outer_class_info_offset, index);
1298 1299 1300
  }

  u2 inner_name_index() const {
1301 1302
    return _inner_classes->at(
               _idx + InstanceKlass::inner_class_inner_name_offset);
1303 1304 1305
  }

  void set_inner_name_index(u2 index) {
1306 1307
    _inner_classes->at_put(
               _idx + InstanceKlass::inner_class_inner_name_offset, index);
1308 1309 1310
  }

  u2 inner_access_flags() const {
1311 1312
    return _inner_classes->at(
               _idx + InstanceKlass::inner_class_access_flags_offset);
1313 1314 1315
  }
};

1316
#endif // SHARE_VM_OOPS_INSTANCEKLASS_HPP