truffle: src/share/vm/oops/instanceKlass.hpp annotate

annotate src/share/vm/oops/instanceKlass.hpp @ 14649:f6301b007a16

6498581: ThreadInterruptTest3 produces wrong output on Windows Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set. Reviewed-by: acorn, kvn Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com

author	minqi
date	Wed, 26 Feb 2014 15:20:41 -0800
parents	48314d596a04
children	fdad2932c73f

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
14340 cd6b3f1a94ff 8033792: AltHashing used jint for imprecise bit shifting minqi parents: 14221 diff changeset	2 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1155 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1155 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1155 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	25 #ifndef SHARE_VM_OOPS_INSTANCEKLASS_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	26 #define SHARE_VM_OOPS_INSTANCEKLASS_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	27
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	28 #include "classfile/classLoaderData.hpp"
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10345 diff changeset	29 #include "memory/referenceType.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	30 #include "oops/annotations.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	31 #include "oops/constMethod.hpp"
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	32 #include "oops/fieldInfo.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	33 #include "oops/instanceOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	34 #include "oops/klassVtable.hpp"
7464 ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 6972 diff changeset	35 #include "runtime/atomic.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	36 #include "runtime/handles.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	37 #include "runtime/os.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	38 #include "utilities/accessFlags.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	39 #include "utilities/bitMap.inline.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7596 diff changeset	40 #include "utilities/macros.hpp"
10405 f2110083203d 8005849: JEP 167: Event-Based JVM Tracing sla parents: 10345 diff changeset	41 #include "trace/traceMacros.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	42
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	43 // An InstanceKlass is the VM level representation of a Java class.
0 a61af66fc99e Initial load duke parents: diff changeset	44 // It contains all information needed for at class at execution runtime.
a61af66fc99e Initial load duke parents: diff changeset	45
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	46 // InstanceKlass layout:
0 a61af66fc99e Initial load duke parents: diff changeset	47 // [C++ vtbl pointer ] Klass
a61af66fc99e Initial load duke parents: diff changeset	48 // [subtype cache ] Klass
a61af66fc99e Initial load duke parents: diff changeset	49 // [instance size ] Klass
a61af66fc99e Initial load duke parents: diff changeset	50 // [java mirror ] Klass
a61af66fc99e Initial load duke parents: diff changeset	51 // [super ] Klass
a61af66fc99e Initial load duke parents: diff changeset	52 // [access_flags ] Klass
a61af66fc99e Initial load duke parents: diff changeset	53 // [name ] Klass
a61af66fc99e Initial load duke parents: diff changeset	54 // [first subklass ] Klass
a61af66fc99e Initial load duke parents: diff changeset	55 // [next sibling ] Klass
a61af66fc99e Initial load duke parents: diff changeset	56 // [array klasses ]
a61af66fc99e Initial load duke parents: diff changeset	57 // [methods ]
a61af66fc99e Initial load duke parents: diff changeset	58 // [local interfaces ]
a61af66fc99e Initial load duke parents: diff changeset	59 // [transitive interfaces ]
a61af66fc99e Initial load duke parents: diff changeset	60 // [fields ]
a61af66fc99e Initial load duke parents: diff changeset	61 // [constants ]
a61af66fc99e Initial load duke parents: diff changeset	62 // [class loader ]
a61af66fc99e Initial load duke parents: diff changeset	63 // [source file name ]
a61af66fc99e Initial load duke parents: diff changeset	64 // [inner classes ]
a61af66fc99e Initial load duke parents: diff changeset	65 // [static field size ]
a61af66fc99e Initial load duke parents: diff changeset	66 // [nonstatic field size ]
a61af66fc99e Initial load duke parents: diff changeset	67 // [static oop fields size ]
a61af66fc99e Initial load duke parents: diff changeset	68 // [nonstatic oop maps size ]
a61af66fc99e Initial load duke parents: diff changeset	69 // [has finalize method ]
a61af66fc99e Initial load duke parents: diff changeset	70 // [deoptimization mark bit ]
a61af66fc99e Initial load duke parents: diff changeset	71 // [initialization state ]
a61af66fc99e Initial load duke parents: diff changeset	72 // [initializing thread ]
a61af66fc99e Initial load duke parents: diff changeset	73 // [Java vtable length ]
a61af66fc99e Initial load duke parents: diff changeset	74 // [oop map cache (stack maps) ]
a61af66fc99e Initial load duke parents: diff changeset	75 // [EMBEDDED Java vtable ] size in words = vtable_len
a61af66fc99e Initial load duke parents: diff changeset	76 // [EMBEDDED nonstatic oop-map blocks] size in words = nonstatic_oop_map_size
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	77 // The embedded nonstatic oop-map blocks are short pairs (offset, length)
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	78 // indicating where oops are located in instances of this klass.
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	79 // [EMBEDDED implementor of the interface] only exist for interface
6038 8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	80 // [EMBEDDED host klass ] only exist for an anonymous class (JSR 292 enabled)
0 a61af66fc99e Initial load duke parents: diff changeset	81
a61af66fc99e Initial load duke parents: diff changeset	82
a61af66fc99e Initial load duke parents: diff changeset	83 // forward declaration for class -- see below for definition
a61af66fc99e Initial load duke parents: diff changeset	84 class SuperTypeClosure;
a61af66fc99e Initial load duke parents: diff changeset	85 class JNIid;
a61af66fc99e Initial load duke parents: diff changeset	86 class jniIdMapBase;
a61af66fc99e Initial load duke parents: diff changeset	87 class BreakpointInfo;
a61af66fc99e Initial load duke parents: diff changeset	88 class fieldDescriptor;
a61af66fc99e Initial load duke parents: diff changeset	89 class DepChange;
a61af66fc99e Initial load duke parents: diff changeset	90 class nmethodBucket;
a61af66fc99e Initial load duke parents: diff changeset	91 class PreviousVersionNode;
a61af66fc99e Initial load duke parents: diff changeset	92 class JvmtiCachedClassFieldMap;
10133 6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 8719 diff changeset	93 class MemberNameTable;
0 a61af66fc99e Initial load duke parents: diff changeset	94
a61af66fc99e Initial load duke parents: diff changeset	95 // This is used in iterators below.
a61af66fc99e Initial load duke parents: diff changeset	96 class FieldClosure: public StackObj {
a61af66fc99e Initial load duke parents: diff changeset	97 public:
a61af66fc99e Initial load duke parents: diff changeset	98 virtual void do_field(fieldDescriptor* fd) = 0;
a61af66fc99e Initial load duke parents: diff changeset	99 };
a61af66fc99e Initial load duke parents: diff changeset	100
a61af66fc99e Initial load duke parents: diff changeset	101 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	102 // Print fields.
a61af66fc99e Initial load duke parents: diff changeset	103 // If "obj" argument to constructor is NULL, prints static fields, otherwise prints non-static fields.
a61af66fc99e Initial load duke parents: diff changeset	104 class FieldPrinter: public FieldClosure {
a61af66fc99e Initial load duke parents: diff changeset	105 oop _obj;
a61af66fc99e Initial load duke parents: diff changeset	106 outputStream* _st;
a61af66fc99e Initial load duke parents: diff changeset	107 public:
a61af66fc99e Initial load duke parents: diff changeset	108 FieldPrinter(outputStream* st, oop obj = NULL) : _obj(obj), _st(st) {}
a61af66fc99e Initial load duke parents: diff changeset	109 void do_field(fieldDescriptor* fd);
a61af66fc99e Initial load duke parents: diff changeset	110 };
a61af66fc99e Initial load duke parents: diff changeset	111 #endif // !PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	112
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	113 // ValueObjs embedded in klass. Describes where oops are located in instances of
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	114 // this klass.
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	115 class OopMapBlock VALUE_OBJ_CLASS_SPEC {
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	116 public:
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	117 // Byte offset of the first oop mapped by this block.
939 9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	118 int offset() const { return _offset; }
9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	119 void set_offset(int offset) { _offset = offset; }
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	120
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	121 // Number of oops in this block.
939 9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	122 uint count() const { return _count; }
9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	123 void set_count(uint count) { _count = count; }
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	124
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	125 // sizeof(OopMapBlock) in HeapWords.
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	126 static const int size_in_words() {
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	127 return align_size_up(int(sizeof(OopMapBlock)), HeapWordSize) >>
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	128 LogHeapWordSize;
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	129 }
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	130
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	131 private:
939 9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	132 int _offset;
9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	133 uint _count;
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	134 };
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	135
11148 825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	136 struct JvmtiCachedClassFileData;
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	137
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	138 class InstanceKlass: public Klass {
0 a61af66fc99e Initial load duke parents: diff changeset	139 friend class VMStructs;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	140 friend class ClassFileParser;
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6934 diff changeset	141 friend class CompileReplay;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	142
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	143 protected:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	144 // Constructor
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	145 InstanceKlass(int vtable_len,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	146 int itable_len,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	147 int static_field_size,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	148 int nonstatic_oop_map_size,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	149 ReferenceType rt,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	150 AccessFlags access_flags,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	151 bool is_anonymous);
0 a61af66fc99e Initial load duke parents: diff changeset	152 public:
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	153 static InstanceKlass* allocate_instance_klass(
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	154 ClassLoaderData* loader_data,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	155 int vtable_len,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	156 int itable_len,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	157 int static_field_size,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	158 int nonstatic_oop_map_size,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	159 ReferenceType rt,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	160 AccessFlags access_flags,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	161 Symbol* name,
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	162 Klass* super_klass,
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	163 bool is_anonymous,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	164 TRAPS);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	165
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	166 InstanceKlass() { assert(DumpSharedSpaces \|\| UseSharedSpaces, "only for CDS"); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	167
0 a61af66fc99e Initial load duke parents: diff changeset	168 // See "The Java Virtual Machine Specification" section 2.16.2-5 for a detailed description
a61af66fc99e Initial load duke parents: diff changeset	169 // of the class loading & initialization procedure, and the use of the states.
a61af66fc99e Initial load duke parents: diff changeset	170 enum ClassState {
a61af66fc99e Initial load duke parents: diff changeset	171 allocated, // allocated (but not yet linked)
a61af66fc99e Initial load duke parents: diff changeset	172 loaded, // loaded and inserted in class hierarchy (but not linked yet)
a61af66fc99e Initial load duke parents: diff changeset	173 linked, // successfully linked/verified (but not initialized yet)
a61af66fc99e Initial load duke parents: diff changeset	174 being_initialized, // currently running class initializer
a61af66fc99e Initial load duke parents: diff changeset	175 fully_initialized, // initialized (successfull final state)
a61af66fc99e Initial load duke parents: diff changeset	176 initialization_error // error happened during initialization
a61af66fc99e Initial load duke parents: diff changeset	177 };
a61af66fc99e Initial load duke parents: diff changeset	178
7464 ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 6972 diff changeset	179 static int number_of_instance_classes() { return _total_instanceKlass_count; }
ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 6972 diff changeset	180
ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 6972 diff changeset	181 private:
ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 6972 diff changeset	182 static volatile int _total_instanceKlass_count;
ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 6972 diff changeset	183
0 a61af66fc99e Initial load duke parents: diff changeset	184 protected:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	185 // Annotations for this class
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	186 Annotations* _annotations;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	187 // Array classes holding elements of this class.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	188 Klass* _array_klasses;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	189 // Constant pool for this class.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	190 ConstantPool* _constants;
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	191 // The InnerClasses attribute and EnclosingMethod attribute. The
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	192 // _inner_classes is an array of shorts. If the class has InnerClasses
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	193 // attribute, then the _inner_classes array begins with 4-tuples of shorts
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	194 // [inner_class_info_index, outer_class_info_index,
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	195 // inner_name_index, inner_class_access_flags] for the InnerClasses
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	196 // attribute. If the EnclosingMethod attribute exists, it occupies the
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	197 // last two shorts [class_index, method_index] of the array. If only
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	198 // the InnerClasses attribute exists, the _inner_classes array length is
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	199 // number_of_inner_classes * 4. If the class has both InnerClasses
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	200 // and EnclosingMethod attributes the _inner_classes array length is
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	201 // number_of_inner_classes * 4 + enclosing_method_attribute_size.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	202 Array<jushort>* _inner_classes;
0 a61af66fc99e Initial load duke parents: diff changeset	203
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	204 // the source debug extension for this klass, NULL if not specified.
6203 04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	205 // Specified as UTF-8 string without terminating zero byte in the classfile,
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	206 // it is stored in the instanceklass as a NULL-terminated UTF-8 string
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	207 char* _source_debug_extension;
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	208 // Array name derived from this class which needs unreferencing
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	209 // if this class is unloaded.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	210 Symbol* _array_name;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	211
165 437d03ea40b1 6703888: Compressed Oops: use the 32-bits gap after klass in a object kvn parents: 113 diff changeset	212 // Number of heapOopSize words used by non-static fields in this klass
437d03ea40b1 6703888: Compressed Oops: use the 32-bits gap after klass in a object kvn parents: 113 diff changeset	213 // (including inherited fields but after header_size()).
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 49 diff changeset	214 int _nonstatic_field_size;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 49 diff changeset	215 int _static_field_size; // number words used by static fields (oop and non-oop) in this klass
12067 e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	216 // Constant pool index to the utf8 entry of the Generic signature,
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	217 // or 0 if none.
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	218 u2 _generic_signature_index;
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	219 // Constant pool index to the utf8 entry for the name of source file
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	220 // containing this klass, 0 if not specified.
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	221 u2 _source_file_name_index;
4744 cd5d8cafcc84 7123315: instanceKlass::_static_oop_field_count and instanceKlass::_java_fields_count should be u2 type. jiangli parents: 4739 diff changeset	222 u2 _static_oop_field_count;// number of static oop fields in this klass
cd5d8cafcc84 7123315: instanceKlass::_static_oop_field_count and instanceKlass::_java_fields_count should be u2 type. jiangli parents: 4739 diff changeset	223 u2 _java_fields_count; // The number of declared Java fields
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	224 int _nonstatic_oop_map_size;// size in words of nonstatic oop map blocks
4737 75c0a73eee98 7102776: Pack instanceKlass boolean fields into single u1 field coleenp parents: 3939 diff changeset	225
7593 337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	226 // _is_marked_dependent can be set concurrently, thus cannot be part of the
337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	227 // _misc_flags.
4772 8f8b94305aff 7129240: backout fix for 7102776 until 7128770 is resolved dcubed parents: 4771 diff changeset	228 bool _is_marked_dependent; // used for marking during flushing and deoptimization
7593 337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	229
6038 8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	230 enum {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	231 _misc_rewritten = 1 << 0, // methods rewritten.
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	232 _misc_has_nonstatic_fields = 1 << 1, // for sizing with UseCompressedOops
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	233 _misc_should_verify_class = 1 << 2, // allow caching of preverification
10149 d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	234 _misc_is_anonymous = 1 << 3, // has embedded _host_klass field
7596 212c5b9c38e7 Merge dlong parents: 7593 7587 diff changeset	235 _misc_is_contended = 1 << 4, // marked with contended annotation
212c5b9c38e7 Merge dlong parents: 7593 7587 diff changeset	236 _misc_has_default_methods = 1 << 5 // class/superclass/implemented interfaces has default methods
6038 8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	237 };
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	238 u2 _misc_flags;
0 a61af66fc99e Initial load duke parents: diff changeset	239 u2 _minor_version; // minor version number of class file
a61af66fc99e Initial load duke parents: diff changeset	240 u2 _major_version; // major version number of class file
a61af66fc99e Initial load duke parents: diff changeset	241 Thread* _init_thread; // Pointer to current thread doing initialization (to handle recusive initialization)
a61af66fc99e Initial load duke parents: diff changeset	242 int _vtable_len; // length of Java vtable (in words)
a61af66fc99e Initial load duke parents: diff changeset	243 int _itable_len; // length of Java itable (in words)
a61af66fc99e Initial load duke parents: diff changeset	244 OopMapCache* volatile _oop_map_cache; // OopMapCache for all methods in the klass (allocated lazily)
10133 6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 8719 diff changeset	245 MemberNameTable* _member_names; // Member names
0 a61af66fc99e Initial load duke parents: diff changeset	246 JNIid* _jni_ids; // First JNI identifier for static fields in this class
a61af66fc99e Initial load duke parents: diff changeset	247 jmethodID* _methods_jmethod_ids; // jmethodIDs corresponding to method_idnum, or NULL if none
a61af66fc99e Initial load duke parents: diff changeset	248 nmethodBucket* _dependencies; // list of dependent nmethods
a61af66fc99e Initial load duke parents: diff changeset	249 nmethod* _osr_nmethods_head; // Head of list of on-stack replacement nmethods for this class
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	250 BreakpointInfo* _breakpoints; // bpt lists, managed by Method*
0 a61af66fc99e Initial load duke parents: diff changeset	251 // Array of interesting part(s) of the previous version(s) of this
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	252 // InstanceKlass. See PreviousVersionWalker below.
0 a61af66fc99e Initial load duke parents: diff changeset	253 GrowableArray<PreviousVersionNode > _previous_versions;
a61af66fc99e Initial load duke parents: diff changeset	254 // JVMTI fields can be moved to their own structure - see 6315920
11148 825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	255 // JVMTI: cached class file, before retransformable agent modified it in CFLH
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	256 JvmtiCachedClassFileData* _cached_class_file;
7968 44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7596 diff changeset	257
44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7596 diff changeset	258 volatile u2 _idnum_allocated_count; // JNI/JVMTI: increments with the addition of methods, old ids don't change
44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7596 diff changeset	259
44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7596 diff changeset	260 // Class states are defined as ClassState (see above).
44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7596 diff changeset	261 // Place the _init_state here to utilize the unused 2-byte after
44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7596 diff changeset	262 // _idnum_allocated_count.
44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7596 diff changeset	263 u1 _init_state; // state of class
44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7596 diff changeset	264 u1 _reference_type; // reference type
44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7596 diff changeset	265
0 a61af66fc99e Initial load duke parents: diff changeset	266 JvmtiCachedClassFieldMap* _jvmti_cached_class_field_map; // JVMTI: used during heap iteration
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	267
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	268 NOT_PRODUCT(int _verify_count;) // to avoid redundant verifies
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	269
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	270 // Method array.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	271 Array<Method> _methods;
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	272 // Default Method Array, concrete methods inherited from interfaces
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	273 Array<Method> _default_methods;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	274 // Interface (Klass*s) this class declares locally to implement.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	275 Array<Klass> _local_interfaces;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	276 // Interface (Klass*s) this class implements transitively.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	277 Array<Klass> _transitive_interfaces;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	278 // Int array containing the original order of method in the class file (for JVMTI).
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	279 Array<int>* _method_ordering;
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	280 // Int array containing the vtable_indices for default_methods
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	281 // offset matches _default_methods offset
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	282 Array<int>* _default_vtable_indices;
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	283
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	284 // Instance and static variable information, starts with 6-tuples of shorts
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	285 // [access, name index, sig index, initval index, low_offset, high_offset]
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	286 // for all fields, followed by the generic signature data at the end of
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	287 // the array. Only fields with generic signature attributes have the generic
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	288 // signature data set in the array. The fields array looks like following:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	289 //
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	290 // f1: [access, name index, sig index, initial value index, low_offset, high_offset]
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	291 // f2: [access, name index, sig index, initial value index, low_offset, high_offset]
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	292 // ...
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	293 // fn: [access, name index, sig index, initial value index, low_offset, high_offset]
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	294 // [generic signature index]
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	295 // [generic signature index]
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	296 // ...
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	297 Array<u2>* _fields;
0 a61af66fc99e Initial load duke parents: diff changeset	298
a61af66fc99e Initial load duke parents: diff changeset	299 // embedded Java vtable follows here
a61af66fc99e Initial load duke parents: diff changeset	300 // embedded Java itables follows here
a61af66fc99e Initial load duke parents: diff changeset	301 // embedded static fields follows here
a61af66fc99e Initial load duke parents: diff changeset	302 // embedded nonstatic oop-map blocks follows here
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	303 // embedded implementor of this interface follows here
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	304 // The embedded implementor only exists if the current klass is an
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	305 // iterface. The possible values of the implementor fall into following
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	306 // three cases:
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	307 // NULL: no implementor.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	308 // A Klass* that's not itself: one implementor.
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	309 // Itsef: more than one implementors.
6038 8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	310 // embedded host klass follows here
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	311 // The embedded host klass only exists in an anonymous class for
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	312 // dynamic language support (JSR 292 enabled). The host class grants
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	313 // its access privileges to this class also. The host class is either
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	314 // named, or a previously loaded anonymous class. A non-anonymous class
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	315 // or an anonymous class loaded through normal classloading does not
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	316 // have this embedded field.
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	317 //
0 a61af66fc99e Initial load duke parents: diff changeset	318
a61af66fc99e Initial load duke parents: diff changeset	319 friend class SystemDictionary;
a61af66fc99e Initial load duke parents: diff changeset	320
a61af66fc99e Initial load duke parents: diff changeset	321 public:
6038 8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	322 bool has_nonstatic_fields() const {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	323 return (_misc_flags & _misc_has_nonstatic_fields) != 0;
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	324 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	325 void set_has_nonstatic_fields(bool b) {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	326 if (b) {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	327 _misc_flags \|= _misc_has_nonstatic_fields;
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	328 } else {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	329 _misc_flags &= ~_misc_has_nonstatic_fields;
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	330 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	331 }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 49 diff changeset	332
0 a61af66fc99e Initial load duke parents: diff changeset	333 // field sizes
a61af66fc99e Initial load duke parents: diff changeset	334 int nonstatic_field_size() const { return _nonstatic_field_size; }
a61af66fc99e Initial load duke parents: diff changeset	335 void set_nonstatic_field_size(int size) { _nonstatic_field_size = size; }
a61af66fc99e Initial load duke parents: diff changeset	336
a61af66fc99e Initial load duke parents: diff changeset	337 int static_field_size() const { return _static_field_size; }
a61af66fc99e Initial load duke parents: diff changeset	338 void set_static_field_size(int size) { _static_field_size = size; }
a61af66fc99e Initial load duke parents: diff changeset	339
4744 cd5d8cafcc84 7123315: instanceKlass::_static_oop_field_count and instanceKlass::_java_fields_count should be u2 type. jiangli parents: 4739 diff changeset	340 int static_oop_field_count() const { return (int)_static_oop_field_count; }
cd5d8cafcc84 7123315: instanceKlass::_static_oop_field_count and instanceKlass::_java_fields_count should be u2 type. jiangli parents: 4739 diff changeset	341 void set_static_oop_field_count(u2 size) { _static_oop_field_count = size; }
0 a61af66fc99e Initial load duke parents: diff changeset	342
a61af66fc99e Initial load duke parents: diff changeset	343 // Java vtable
a61af66fc99e Initial load duke parents: diff changeset	344 int vtable_length() const { return _vtable_len; }
a61af66fc99e Initial load duke parents: diff changeset	345 void set_vtable_length(int len) { _vtable_len = len; }
a61af66fc99e Initial load duke parents: diff changeset	346
a61af66fc99e Initial load duke parents: diff changeset	347 // Java itable
a61af66fc99e Initial load duke parents: diff changeset	348 int itable_length() const { return _itable_len; }
a61af66fc99e Initial load duke parents: diff changeset	349 void set_itable_length(int len) { _itable_len = len; }
a61af66fc99e Initial load duke parents: diff changeset	350
a61af66fc99e Initial load duke parents: diff changeset	351 // array klasses
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	352 Klass* array_klasses() const { return _array_klasses; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	353 void set_array_klasses(Klass* k) { _array_klasses = k; }
0 a61af66fc99e Initial load duke parents: diff changeset	354
a61af66fc99e Initial load duke parents: diff changeset	355 // methods
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	356 Array<Method> methods() const { return _methods; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	357 void set_methods(Array<Method> a) { _methods = a; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	358 Method* method_with_idnum(int idnum);
0 a61af66fc99e Initial load duke parents: diff changeset	359
a61af66fc99e Initial load duke parents: diff changeset	360 // method ordering
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	361 Array<int>* method_ordering() const { return _method_ordering; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	362 void set_method_ordering(Array<int>* m) { _method_ordering = m; }
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	363 void copy_method_ordering(intArray* m, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	364
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	365 // default_methods
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	366 Array<Method> default_methods() const { return _default_methods; }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	367 void set_default_methods(Array<Method> a) { _default_methods = a; }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	368
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	369 // default method vtable_indices
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	370 Array<int>* default_vtable_indices() const { return _default_vtable_indices; }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	371 void set_default_vtable_indices(Array<int>* v) { _default_vtable_indices = v; }
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	372 Array<int>* create_new_default_vtable_indices(int len, TRAPS);
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	373
0 a61af66fc99e Initial load duke parents: diff changeset	374 // interfaces
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	375 Array<Klass> local_interfaces() const { return _local_interfaces; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	376 void set_local_interfaces(Array<Klass> a) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	377 guarantee(_local_interfaces == NULL \|\| a == NULL, "Just checking");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	378 _local_interfaces = a; }
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	379
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	380 Array<Klass> transitive_interfaces() const { return _transitive_interfaces; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	381 void set_transitive_interfaces(Array<Klass> a) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	382 guarantee(_transitive_interfaces == NULL \|\| a == NULL, "Just checking");
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	383 _transitive_interfaces = a;
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	384 }
0 a61af66fc99e Initial load duke parents: diff changeset	385
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	386 private:
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	387 friend class fieldDescriptor;
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	388 FieldInfo* field(int index) const { return FieldInfo::from_field_array(_fields, index); }
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	389
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	390 public:
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	391 int field_offset (int index) const { return field(index)->offset(); }
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	392 int field_access_flags(int index) const { return field(index)->access_flags(); }
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	393 Symbol* field_name (int index) const { return field(index)->name(constants()); }
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	394 Symbol* field_signature (int index) const { return field(index)->signature(constants()); }
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	395
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	396 // Number of Java declared fields
4744 cd5d8cafcc84 7123315: instanceKlass::_static_oop_field_count and instanceKlass::_java_fields_count should be u2 type. jiangli parents: 4739 diff changeset	397 int java_fields_count() const { return (int)_java_fields_count; }
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	398
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	399 Array<u2>* fields() const { return _fields; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	400 void set_fields(Array<u2>* f, u2 java_fields_count) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	401 guarantee(_fields == NULL \|\| f == NULL, "Just checking");
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	402 _fields = f;
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	403 _java_fields_count = java_fields_count;
0 a61af66fc99e Initial load duke parents: diff changeset	404 }
a61af66fc99e Initial load duke parents: diff changeset	405
a61af66fc99e Initial load duke parents: diff changeset	406 // inner classes
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	407 Array<u2>* inner_classes() const { return _inner_classes; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	408 void set_inner_classes(Array<u2>* f) { _inner_classes = f; }
0 a61af66fc99e Initial load duke parents: diff changeset	409
a61af66fc99e Initial load duke parents: diff changeset	410 enum InnerClassAttributeOffset {
a61af66fc99e Initial load duke parents: diff changeset	411 // From http://mirror.eng/products/jdk/1.1/docs/guide/innerclasses/spec/innerclasses.doc10.html#18814
a61af66fc99e Initial load duke parents: diff changeset	412 inner_class_inner_class_info_offset = 0,
a61af66fc99e Initial load duke parents: diff changeset	413 inner_class_outer_class_info_offset = 1,
a61af66fc99e Initial load duke parents: diff changeset	414 inner_class_inner_name_offset = 2,
a61af66fc99e Initial load duke parents: diff changeset	415 inner_class_access_flags_offset = 3,
a61af66fc99e Initial load duke parents: diff changeset	416 inner_class_next_offset = 4
a61af66fc99e Initial load duke parents: diff changeset	417 };
a61af66fc99e Initial load duke parents: diff changeset	418
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	419 enum EnclosingMethodAttributeOffset {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	420 enclosing_method_class_index_offset = 0,
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	421 enclosing_method_method_index_offset = 1,
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	422 enclosing_method_attribute_size = 2
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	423 };
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	424
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 431 diff changeset	425 // method override check
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	426 bool is_override(methodHandle super_method, Handle targetclassloader, Symbol* targetclassname, TRAPS);
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 431 diff changeset	427
0 a61af66fc99e Initial load duke parents: diff changeset	428 // package
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	429 bool is_same_class_package(Klass* class2);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	430 bool is_same_class_package(oop classloader2, Symbol* classname2);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	431 static bool is_same_class_package(oop class_loader1, Symbol* class_name1, oop class_loader2, Symbol* class_name2);
0 a61af66fc99e Initial load duke parents: diff changeset	432
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 431 diff changeset	433 // find an enclosing class (defined where original code was, in jvm.cpp!)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	434 Klass* compute_enclosing_class(bool* inner_is_member, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	435 instanceKlassHandle self(THREAD, this);
1126 933a3e806ce6 6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build xlu parents: 1039 diff changeset	436 return compute_enclosing_class_impl(self, inner_is_member, THREAD);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 431 diff changeset	437 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	438 static Klass* compute_enclosing_class_impl(instanceKlassHandle self,
1126 933a3e806ce6 6895168: JCK api/signaturetest/sigtest.basic.html#basic test fails for jdk 5.0 with HS 16 in nightly build xlu parents: 1039 diff changeset	439 bool* inner_is_member, TRAPS);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 431 diff changeset	440
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 431 diff changeset	441 // tell if two classes have the same enclosing class (at package level)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	442 bool is_same_package_member(Klass* class2, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	443 instanceKlassHandle self(THREAD, this);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 431 diff changeset	444 return is_same_package_member_impl(self, class2, THREAD);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 431 diff changeset	445 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 431 diff changeset	446 static bool is_same_package_member_impl(instanceKlassHandle self,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	447 Klass* class2, TRAPS);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 431 diff changeset	448
0 a61af66fc99e Initial load duke parents: diff changeset	449 // initialization state
a61af66fc99e Initial load duke parents: diff changeset	450 bool is_loaded() const { return _init_state >= loaded; }
a61af66fc99e Initial load duke parents: diff changeset	451 bool is_linked() const { return _init_state >= linked; }
a61af66fc99e Initial load duke parents: diff changeset	452 bool is_initialized() const { return _init_state == fully_initialized; }
a61af66fc99e Initial load duke parents: diff changeset	453 bool is_not_initialized() const { return _init_state < being_initialized; }
a61af66fc99e Initial load duke parents: diff changeset	454 bool is_being_initialized() const { return _init_state == being_initialized; }
a61af66fc99e Initial load duke parents: diff changeset	455 bool is_in_error_state() const { return _init_state == initialization_error; }
a61af66fc99e Initial load duke parents: diff changeset	456 bool is_reentrant_initialization(Thread *thread) { return thread == _init_thread; }
4739 52b5d32fbfaf 7117052: instanceKlass::_init_state can be u1 type coleenp parents: 4737 diff changeset	457 ClassState init_state() { return (ClassState)_init_state; }
6038 8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	458 bool is_rewritten() const { return (_misc_flags & _misc_rewritten) != 0; }
973 ad6585fd4087 6830542: Performance: JVM_DefineClass already verified. acorn parents: 726 diff changeset	459
ad6585fd4087 6830542: Performance: JVM_DefineClass already verified. acorn parents: 726 diff changeset	460 // defineClass specified verification
6038 8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	461 bool should_verify_class() const {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	462 return (_misc_flags & _misc_should_verify_class) != 0;
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	463 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	464 void set_should_verify_class(bool value) {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	465 if (value) {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	466 _misc_flags \|= _misc_should_verify_class;
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	467 } else {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	468 _misc_flags &= ~_misc_should_verify_class;
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	469 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	470 }
0 a61af66fc99e Initial load duke parents: diff changeset	471
a61af66fc99e Initial load duke parents: diff changeset	472 // marking
4772 8f8b94305aff 7129240: backout fix for 7102776 until 7128770 is resolved dcubed parents: 4771 diff changeset	473 bool is_marked_dependent() const { return _is_marked_dependent; }
8f8b94305aff 7129240: backout fix for 7102776 until 7128770 is resolved dcubed parents: 4771 diff changeset	474 void set_is_marked_dependent(bool value) { _is_marked_dependent = value; }
0 a61af66fc99e Initial load duke parents: diff changeset	475
a61af66fc99e Initial load duke parents: diff changeset	476 // initialization (virtuals from Klass)
a61af66fc99e Initial load duke parents: diff changeset	477 bool should_be_initialized() const; // means that initialize should be called
a61af66fc99e Initial load duke parents: diff changeset	478 void initialize(TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	479 void link_class(TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	480 bool link_class_or_fail(TRAPS); // returns false on failure
a61af66fc99e Initial load duke parents: diff changeset	481 void unlink_class();
a61af66fc99e Initial load duke parents: diff changeset	482 void rewrite_class(TRAPS);
7459 cc6a617fffd2 8005494: SIGSEGV in Rewriter::relocate_and_link() when testing Weblogic with CompressedOops and KlassPtrs coleenp parents: 7457 diff changeset	483 void link_methods(TRAPS);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	484 Method* class_initializer();
0 a61af66fc99e Initial load duke parents: diff changeset	485
a61af66fc99e Initial load duke parents: diff changeset	486 // set the class to initialized if no static initializer is present
a61af66fc99e Initial load duke parents: diff changeset	487 void eager_initialize(Thread *thread);
a61af66fc99e Initial load duke parents: diff changeset	488
a61af66fc99e Initial load duke parents: diff changeset	489 // reference type
4899 a79cb7c55012 7132690: InstanceKlass:_reference_type should be u1 type jiangli parents: 4772 diff changeset	490 ReferenceType reference_type() const { return (ReferenceType)_reference_type; }
a79cb7c55012 7132690: InstanceKlass:_reference_type should be u1 type jiangli parents: 4772 diff changeset	491 void set_reference_type(ReferenceType t) {
a79cb7c55012 7132690: InstanceKlass:_reference_type should be u1 type jiangli parents: 4772 diff changeset	492 assert(t == (u1)t, "overflow");
a79cb7c55012 7132690: InstanceKlass:_reference_type should be u1 type jiangli parents: 4772 diff changeset	493 _reference_type = (u1)t;
a79cb7c55012 7132690: InstanceKlass:_reference_type should be u1 type jiangli parents: 4772 diff changeset	494 }
0 a61af66fc99e Initial load duke parents: diff changeset	495
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	496 static ByteSize reference_type_offset() { return in_ByteSize(offset_of(InstanceKlass, _reference_type)); }
3249 e1162778c1c8 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error johnc parents: 2376 diff changeset	497
0 a61af66fc99e Initial load duke parents: diff changeset	498 // find local field, returns true if found
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	499 bool find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
0 a61af66fc99e Initial load duke parents: diff changeset	500 // find field in direct superinterfaces, returns the interface in which the field is defined
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	501 Klass* find_interface_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
0 a61af66fc99e Initial load duke parents: diff changeset	502 // find field according to JVM spec 5.4.3.2, returns the klass in which the field is defined
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	503 Klass* find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
0 a61af66fc99e Initial load duke parents: diff changeset	504 // find instance or static fields according to JVM spec 5.4.3.2, returns the klass in which the field is defined
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	505 Klass* find_field(Symbol* name, Symbol* sig, bool is_static, fieldDescriptor* fd) const;
0 a61af66fc99e Initial load duke parents: diff changeset	506
a61af66fc99e Initial load duke parents: diff changeset	507 // find a non-static or static field given its offset within the class.
a61af66fc99e Initial load duke parents: diff changeset	508 bool contains_field_offset(int offset) {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 49 diff changeset	509 return instanceOopDesc::contains_field_offset(offset, nonstatic_field_size());
0 a61af66fc99e Initial load duke parents: diff changeset	510 }
a61af66fc99e Initial load duke parents: diff changeset	511
a61af66fc99e Initial load duke parents: diff changeset	512 bool find_local_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const;
a61af66fc99e Initial load duke parents: diff changeset	513 bool find_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const;
a61af66fc99e Initial load duke parents: diff changeset	514
a61af66fc99e Initial load duke parents: diff changeset	515 // find a local method (returns NULL if not found)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	516 Method* find_method(Symbol* name, Symbol* signature) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	517 static Method* find_method(Array<Method> methods, Symbol* name, Symbol* signature);
13414 379f11bc04fc 8028438: static superclass method masks default methods acorn parents: 13401 diff changeset	518 static Method* find_instance_method(Array<Method> methods, Symbol* name, Symbol* signature);
0 a61af66fc99e Initial load duke parents: diff changeset	519
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	520 // find a local method index in default_methods (returns -1 if not found)
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	521 static int find_method_index(Array<Method> methods, Symbol* name, Symbol* signature);
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	522
0 a61af66fc99e Initial load duke parents: diff changeset	523 // lookup operation (returns NULL if not found)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	524 Method* uncached_lookup_method(Symbol* name, Symbol* signature) const;
0 a61af66fc99e Initial load duke parents: diff changeset	525
a61af66fc99e Initial load duke parents: diff changeset	526 // lookup a method in all the interfaces that this class implements
a61af66fc99e Initial load duke parents: diff changeset	527 // (returns NULL if not found)
14221 2353011244bd 8027804: JCK resolveMethod test fails expecting AbstractMethodError hseigel parents: 13414 diff changeset	528 Method* lookup_method_in_all_interfaces(Symbol* name, Symbol* signature, bool skip_default_methods) const;
2353011244bd 8027804: JCK resolveMethod test fails expecting AbstractMethodError hseigel parents: 13414 diff changeset	529
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	530 // lookup a method in local defaults then in all interfaces
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	531 // (returns NULL if not found)
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	532 Method* lookup_method_in_ordered_interfaces(Symbol* name, Symbol* signature) const;
0 a61af66fc99e Initial load duke parents: diff changeset	533
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	534 // Find method indices by name. If a method with the specified name is
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	535 // found the index to the first method is returned, and 'end' is filled in
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	536 // with the index of first non-name-matching method. If no method is found
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	537 // -1 is returned.
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	538 int find_method_by_name(Symbol* name, int* end);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	539 static int find_method_by_name(Array<Method> methods, Symbol* name, int* end);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	540
0 a61af66fc99e Initial load duke parents: diff changeset	541 // constant pool
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	542 ConstantPool* constants() const { return _constants; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	543 void set_constants(ConstantPool* c) { _constants = c; }
0 a61af66fc99e Initial load duke parents: diff changeset	544
a61af66fc99e Initial load duke parents: diff changeset	545 // protection domain
10343 6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	546 oop protection_domain() const;
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	547
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	548 // signers
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	549 objArrayOop signers() const;
0 a61af66fc99e Initial load duke parents: diff changeset	550
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 356 diff changeset	551 // host class
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	552 Klass* host_klass() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	553 Klass hk = (Klass)adr_host_klass();
6038 8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	554 if (hk == NULL) {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	555 return NULL;
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	556 } else {
14340 cd6b3f1a94ff 8033792: AltHashing used jint for imprecise bit shifting minqi parents: 14221 diff changeset	557 assert(*hk != NULL, "host klass should always be set if the address is not null");
6038 8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	558 return *hk;
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	559 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	560 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	561 void set_host_klass(Klass* host) {
6038 8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	562 assert(is_anonymous(), "not anonymous");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	563 Klass addr = (Klass)adr_host_klass();
6038 8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	564 assert(addr != NULL, "no reversed space");
8693 872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	565 if (addr != NULL) {
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	566 *addr = host;
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	567 }
6038 8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	568 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	569 bool is_anonymous() const {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	570 return (_misc_flags & _misc_is_anonymous) != 0;
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	571 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	572 void set_is_anonymous(bool value) {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	573 if (value) {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	574 _misc_flags \|= _misc_is_anonymous;
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	575 } else {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	576 _misc_flags &= ~_misc_is_anonymous;
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	577 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	578 }
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 356 diff changeset	579
7409 30866cd626b0 8004883: NPG: clean up anonymous class fix coleenp parents: 6972 diff changeset	580 // Oop that keeps the metadata for this class from being unloaded
30866cd626b0 8004883: NPG: clean up anonymous class fix coleenp parents: 6972 diff changeset	581 // in places where the metadata is stored in other places, like nmethods
30866cd626b0 8004883: NPG: clean up anonymous class fix coleenp parents: 6972 diff changeset	582 oop klass_holder() const {
30866cd626b0 8004883: NPG: clean up anonymous class fix coleenp parents: 6972 diff changeset	583 return is_anonymous() ? java_mirror() : class_loader();
30866cd626b0 8004883: NPG: clean up anonymous class fix coleenp parents: 6972 diff changeset	584 }
30866cd626b0 8004883: NPG: clean up anonymous class fix coleenp parents: 6972 diff changeset	585
7587 4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	586 bool is_contended() const {
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	587 return (_misc_flags & _misc_is_contended) != 0;
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	588 }
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	589 void set_is_contended(bool value) {
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	590 if (value) {
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	591 _misc_flags \|= _misc_is_contended;
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	592 } else {
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	593 _misc_flags &= ~_misc_is_contended;
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	594 }
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	595 }
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	596
0 a61af66fc99e Initial load duke parents: diff changeset	597 // source file name
12067 e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	598 Symbol* source_file_name() const {
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	599 return (_source_file_name_index == 0) ?
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	600 (Symbol*)NULL : _constants->symbol_at(_source_file_name_index);
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	601 }
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	602 u2 source_file_name_index() const {
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	603 return _source_file_name_index;
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	604 }
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	605 void set_source_file_name_index(u2 sourcefile_index) {
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	606 _source_file_name_index = sourcefile_index;
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	607 }
0 a61af66fc99e Initial load duke parents: diff changeset	608
a61af66fc99e Initial load duke parents: diff changeset	609 // minor and major version numbers of class file
a61af66fc99e Initial load duke parents: diff changeset	610 u2 minor_version() const { return _minor_version; }
a61af66fc99e Initial load duke parents: diff changeset	611 void set_minor_version(u2 minor_version) { _minor_version = minor_version; }
a61af66fc99e Initial load duke parents: diff changeset	612 u2 major_version() const { return _major_version; }
a61af66fc99e Initial load duke parents: diff changeset	613 void set_major_version(u2 major_version) { _major_version = major_version; }
a61af66fc99e Initial load duke parents: diff changeset	614
a61af66fc99e Initial load duke parents: diff changeset	615 // source debug extension
6203 04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	616 char* source_debug_extension() const { return _source_debug_extension; }
04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	617 void set_source_debug_extension(char* array, int length);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	618
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	619 // symbol unloading support (refcount already added)
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	620 Symbol* array_name() { return _array_name; }
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	621 void set_array_name(Symbol* name) { assert(_array_name == NULL \|\| name == NULL, "name already created"); _array_name = name; }
0 a61af66fc99e Initial load duke parents: diff changeset	622
a61af66fc99e Initial load duke parents: diff changeset	623 // nonstatic oop-map blocks
939 9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	624 static int nonstatic_oop_map_size(unsigned int oop_map_count) {
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	625 return oop_map_count * OopMapBlock::size_in_words();
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	626 }
939 9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	627 unsigned int nonstatic_oop_map_count() const {
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	628 return _nonstatic_oop_map_size / OopMapBlock::size_in_words();
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	629 }
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	630 int nonstatic_oop_map_size() const { return _nonstatic_oop_map_size; }
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	631 void set_nonstatic_oop_map_size(int words) {
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	632 _nonstatic_oop_map_size = words;
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	633 }
0 a61af66fc99e Initial load duke parents: diff changeset	634
a61af66fc99e Initial load duke parents: diff changeset	635 // RedefineClasses() support for previous versions:
a61af66fc99e Initial load duke parents: diff changeset	636 void add_previous_version(instanceKlassHandle ikh, BitMap *emcp_methods,
a61af66fc99e Initial load duke parents: diff changeset	637 int emcp_method_count);
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	638 // If the _previous_versions array is non-NULL, then this klass
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	639 // has been redefined at least once even if we aren't currently
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	640 // tracking a previous version.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	641 bool has_been_redefined() const { return _previous_versions != NULL; }
0 a61af66fc99e Initial load duke parents: diff changeset	642 bool has_previous_version() const;
a61af66fc99e Initial load duke parents: diff changeset	643 void init_previous_versions() {
a61af66fc99e Initial load duke parents: diff changeset	644 _previous_versions = NULL;
a61af66fc99e Initial load duke parents: diff changeset	645 }
a61af66fc99e Initial load duke parents: diff changeset	646 GrowableArray<PreviousVersionNode > previous_versions() const {
a61af66fc99e Initial load duke parents: diff changeset	647 return _previous_versions;
a61af66fc99e Initial load duke parents: diff changeset	648 }
a61af66fc99e Initial load duke parents: diff changeset	649
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	650 static void purge_previous_versions(InstanceKlass* ik);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	651
0 a61af66fc99e Initial load duke parents: diff changeset	652 // JVMTI: Support for caching a class file before it is modified by an agent that can do retransformation
11148 825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	653 void set_cached_class_file(JvmtiCachedClassFileData *data) {
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	654 _cached_class_file = data;
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	655 }
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	656 JvmtiCachedClassFileData * get_cached_class_file() { return _cached_class_file; }
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	657 jint get_cached_class_file_len();
825e6cb66923 8020309: Eliminate InstanceKlass::_cached_class_file_len. jiangli parents: 11096 diff changeset	658 unsigned char * get_cached_class_file_bytes();
0 a61af66fc99e Initial load duke parents: diff changeset	659
a61af66fc99e Initial load duke parents: diff changeset	660 // JVMTI: Support for caching of field indices, types, and offsets
a61af66fc99e Initial load duke parents: diff changeset	661 void set_jvmti_cached_class_field_map(JvmtiCachedClassFieldMap* descriptor) {
a61af66fc99e Initial load duke parents: diff changeset	662 _jvmti_cached_class_field_map = descriptor;
a61af66fc99e Initial load duke parents: diff changeset	663 }
a61af66fc99e Initial load duke parents: diff changeset	664 JvmtiCachedClassFieldMap* jvmti_cached_class_field_map() const {
a61af66fc99e Initial load duke parents: diff changeset	665 return _jvmti_cached_class_field_map;
a61af66fc99e Initial load duke parents: diff changeset	666 }
a61af66fc99e Initial load duke parents: diff changeset	667
7593 337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	668 bool has_default_methods() const {
337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	669 return (_misc_flags & _misc_has_default_methods) != 0;
337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	670 }
337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	671 void set_has_default_methods(bool b) {
337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	672 if (b) {
337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	673 _misc_flags \|= _misc_has_default_methods;
337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	674 } else {
337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	675 _misc_flags &= ~_misc_has_default_methods;
337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	676 }
337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	677 }
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	678
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	679 // for adding methods, ConstMethod::UNSET_IDNUM means no more ids available
0 a61af66fc99e Initial load duke parents: diff changeset	680 inline u2 next_method_idnum();
a61af66fc99e Initial load duke parents: diff changeset	681 void set_initial_method_idnum(u2 value) { _idnum_allocated_count = value; }
a61af66fc99e Initial load duke parents: diff changeset	682
a61af66fc99e Initial load duke parents: diff changeset	683 // generics support
12067 e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	684 Symbol* generic_signature() const {
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	685 return (_generic_signature_index == 0) ?
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	686 (Symbol*)NULL : _constants->symbol_at(_generic_signature_index);
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	687 }
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	688 u2 generic_signature_index() const {
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	689 return _generic_signature_index;
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	690 }
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	691 void set_generic_signature_index(u2 sig_index) {
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	692 _generic_signature_index = sig_index;
e22ee8e7ae62 8021948: Change InstanceKlass::_source_file_name and _generic_signature from Symbol* to constant pool indexes. jiangli parents: 11148 diff changeset	693 }
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	694
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	695 u2 enclosing_method_data(int offset);
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	696 u2 enclosing_method_class_index() {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	697 return enclosing_method_data(enclosing_method_class_index_offset);
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	698 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	699 u2 enclosing_method_method_index() {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	700 return enclosing_method_data(enclosing_method_method_index_offset);
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	701 }
0 a61af66fc99e Initial load duke parents: diff changeset	702 void set_enclosing_method_indices(u2 class_index,
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	703 u2 method_index);
0 a61af66fc99e Initial load duke parents: diff changeset	704
a61af66fc99e Initial load duke parents: diff changeset	705 // jmethodID support
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	706 static jmethodID get_jmethod_id(instanceKlassHandle ik_h,
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	707 methodHandle method_h);
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	708 static jmethodID get_jmethod_id_fetch_or_update(instanceKlassHandle ik_h,
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	709 size_t idnum, jmethodID new_id, jmethodID* new_jmeths,
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	710 jmethodID* to_dealloc_id_p,
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	711 jmethodID** to_dealloc_jmeths_p);
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	712 static void get_jmethod_id_length_value(jmethodID* cache, size_t idnum,
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	713 size_t length_p, jmethodID id_p);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	714 jmethodID jmethod_id_or_null(Method* method);
0 a61af66fc99e Initial load duke parents: diff changeset	715
a61af66fc99e Initial load duke parents: diff changeset	716 // annotations support
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	717 Annotations* annotations() const { return _annotations; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	718 void set_annotations(Annotations* anno) { _annotations = anno; }
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	719
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	720 AnnotationArray* class_annotations() const {
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	721 return (_annotations != NULL) ? _annotations->class_annotations() : NULL;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	722 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	723 Array<AnnotationArray> fields_annotations() const {
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	724 return (_annotations != NULL) ? _annotations->fields_annotations() : NULL;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	725 }
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	726 AnnotationArray* class_type_annotations() const {
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	727 return (_annotations != NULL) ? _annotations->class_type_annotations() : NULL;
7457 35431a769282 8004823: Add VM support for type annotation reflection stefank parents: 7409 diff changeset	728 }
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	729 Array<AnnotationArray> fields_type_annotations() const {
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	730 return (_annotations != NULL) ? _annotations->fields_type_annotations() : NULL;
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	731 }
0 a61af66fc99e Initial load duke parents: diff changeset	732 // allocation
a61af66fc99e Initial load duke parents: diff changeset	733 instanceOop allocate_instance(TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	734
a61af66fc99e Initial load duke parents: diff changeset	735 // additional member function to return a handle
a61af66fc99e Initial load duke parents: diff changeset	736 instanceHandle allocate_instance_handle(TRAPS) { return instanceHandle(THREAD, allocate_instance(THREAD)); }
a61af66fc99e Initial load duke parents: diff changeset	737
a61af66fc99e Initial load duke parents: diff changeset	738 objArrayOop allocate_objArray(int n, int length, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	739 // Helper function
a61af66fc99e Initial load duke parents: diff changeset	740 static instanceOop register_finalizer(instanceOop i, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	741
a61af66fc99e Initial load duke parents: diff changeset	742 // Check whether reflection/jni/jvm code is allowed to instantiate this class;
a61af66fc99e Initial load duke parents: diff changeset	743 // if not, throw either an Error or an Exception.
a61af66fc99e Initial load duke parents: diff changeset	744 virtual void check_valid_for_instantiation(bool throwError, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	745
a61af66fc99e Initial load duke parents: diff changeset	746 // initialization
a61af66fc99e Initial load duke parents: diff changeset	747 void call_class_initializer(TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	748 void set_initialization_state_and_notify(ClassState state, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	749
a61af66fc99e Initial load duke parents: diff changeset	750 // OopMapCache support
a61af66fc99e Initial load duke parents: diff changeset	751 OopMapCache* oop_map_cache() { return _oop_map_cache; }
a61af66fc99e Initial load duke parents: diff changeset	752 void set_oop_map_cache(OopMapCache *cache) { _oop_map_cache = cache; }
a61af66fc99e Initial load duke parents: diff changeset	753 void mask_for(methodHandle method, int bci, InterpreterOopMap* entry);
a61af66fc99e Initial load duke parents: diff changeset	754
a61af66fc99e Initial load duke parents: diff changeset	755 // JNI identifier support (for static fields - for jni performance)
a61af66fc99e Initial load duke parents: diff changeset	756 JNIid* jni_ids() { return _jni_ids; }
a61af66fc99e Initial load duke parents: diff changeset	757 void set_jni_ids(JNIid* ids) { _jni_ids = ids; }
a61af66fc99e Initial load duke parents: diff changeset	758 JNIid* jni_id_for(int offset);
a61af66fc99e Initial load duke parents: diff changeset	759
a61af66fc99e Initial load duke parents: diff changeset	760 // maintenance of deoptimization dependencies
a61af66fc99e Initial load duke parents: diff changeset	761 int mark_dependent_nmethods(DepChange& changes);
a61af66fc99e Initial load duke parents: diff changeset	762 void add_dependent_nmethod(nmethod* nm);
a61af66fc99e Initial load duke parents: diff changeset	763 void remove_dependent_nmethod(nmethod* nm);
a61af66fc99e Initial load duke parents: diff changeset	764
a61af66fc99e Initial load duke parents: diff changeset	765 // On-stack replacement support
a61af66fc99e Initial load duke parents: diff changeset	766 nmethod* osr_nmethods_head() const { return _osr_nmethods_head; };
a61af66fc99e Initial load duke parents: diff changeset	767 void set_osr_nmethods_head(nmethod* h) { _osr_nmethods_head = h; };
a61af66fc99e Initial load duke parents: diff changeset	768 void add_osr_nmethod(nmethod* n);
a61af66fc99e Initial load duke parents: diff changeset	769 void remove_osr_nmethod(nmethod* n);
10265 92ef81e2f571 8003557: NPG: Klass* const k should be const Klass* k. minqi parents: 10152 diff changeset	770 nmethod* lookup_osr_nmethod(const Method* m, int bci, int level, bool match_level) const;
0 a61af66fc99e Initial load duke parents: diff changeset	771
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	772 // Breakpoint support (see methods on Method* for details)
0 a61af66fc99e Initial load duke parents: diff changeset	773 BreakpointInfo* breakpoints() const { return _breakpoints; };
a61af66fc99e Initial load duke parents: diff changeset	774 void set_breakpoints(BreakpointInfo* bps) { _breakpoints = bps; };
a61af66fc99e Initial load duke parents: diff changeset	775
a61af66fc99e Initial load duke parents: diff changeset	776 // support for stub routines
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	777 static ByteSize init_state_offset() { return in_ByteSize(offset_of(InstanceKlass, _init_state)); }
6006 0105f367a14c 7160570: Intrinsification support for tracing framework rbackman parents: 5998 diff changeset	778 TRACE_DEFINE_OFFSET;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	779 static ByteSize init_thread_offset() { return in_ByteSize(offset_of(InstanceKlass, _init_thread)); }
0 a61af66fc99e Initial load duke parents: diff changeset	780
a61af66fc99e Initial load duke parents: diff changeset	781 // subclass/subinterface checks
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	782 bool implements_interface(Klass* k) const;
13401 22eaa15b7960 8026065: InterfaceMethodref for invokespecial must name a direct superinterface hseigel parents: 12946 diff changeset	783 bool is_same_or_direct_interface(Klass* k) const;
0 a61af66fc99e Initial load duke parents: diff changeset	784
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	785 // Access to the implementor of an interface.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	786 Klass* implementor() const
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	787 {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	788 Klass** k = adr_implementor();
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	789 if (k == NULL) {
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	790 return NULL;
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	791 } else {
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	792 return *k;
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	793 }
0 a61af66fc99e Initial load duke parents: diff changeset	794 }
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	795
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	796 void set_implementor(Klass* k) {
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	797 assert(is_interface(), "not interface");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	798 Klass** addr = adr_implementor();
8693 872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	799 assert(addr != NULL, "null addr");
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	800 if (addr != NULL) {
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	801 *addr = k;
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	802 }
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	803 }
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	804
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	805 int nof_implementors() const {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	806 Klass* k = implementor();
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	807 if (k == NULL) {
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	808 return 0;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	809 } else if (k != this) {
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	810 return 1;
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	811 } else {
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	812 return 2;
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	813 }
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	814 }
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	815
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	816 void add_implementor(Klass* k); // k is a new class that implements this interface
0 a61af66fc99e Initial load duke parents: diff changeset	817 void init_implementor(); // initialize
a61af66fc99e Initial load duke parents: diff changeset	818
a61af66fc99e Initial load duke parents: diff changeset	819 // link this class into the implementors list of every interface it implements
a61af66fc99e Initial load duke parents: diff changeset	820 void process_interfaces(Thread *thread);
a61af66fc99e Initial load duke parents: diff changeset	821
a61af66fc99e Initial load duke parents: diff changeset	822 // virtual operations from Klass
a61af66fc99e Initial load duke parents: diff changeset	823 bool is_leaf_class() const { return _subklass == NULL; }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	824 GrowableArray<Klass> compute_secondary_supers(int num_extra_slots);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	825 bool compute_is_subtype_of(Klass* k);
0 a61af66fc99e Initial load duke parents: diff changeset	826 bool can_be_primary_super_slow() const;
a61af66fc99e Initial load duke parents: diff changeset	827 int oop_size(oop obj) const { return size_helper(); }
a61af66fc99e Initial load duke parents: diff changeset	828 bool oop_is_instance_slow() const { return true; }
a61af66fc99e Initial load duke parents: diff changeset	829
a61af66fc99e Initial load duke parents: diff changeset	830 // Iterators
a61af66fc99e Initial load duke parents: diff changeset	831 void do_local_static_fields(FieldClosure* cl);
a61af66fc99e Initial load duke parents: diff changeset	832 void do_nonstatic_fields(FieldClosure* cl); // including inherited fields
a61af66fc99e Initial load duke parents: diff changeset	833 void do_local_static_fields(void f(fieldDescriptor*, TRAPS), TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	834
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	835 void methods_do(void f(Method* method));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	836 void array_klasses_do(void f(Klass* k));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	837 void array_klasses_do(void f(Klass* k, TRAPS), TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	838 bool super_types_do(SuperTypeClosure* blk);
a61af66fc99e Initial load duke parents: diff changeset	839
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	840 // Casting from Klass*
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	841 static InstanceKlass* cast(Klass* k) {
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	842 assert(k->is_klass(), "must be");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	843 assert(k->oop_is_instance(), "cast to InstanceKlass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	844 return (InstanceKlass*) k;
0 a61af66fc99e Initial load duke parents: diff changeset	845 }
a61af66fc99e Initial load duke parents: diff changeset	846
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	847 InstanceKlass* java_super() const {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	848 return (super() == NULL) ? NULL : cast(super());
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	849 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	850
0 a61af66fc99e Initial load duke parents: diff changeset	851 // Sizing (in words)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	852 static int header_size() { return align_object_offset(sizeof(InstanceKlass)/HeapWordSize); }
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	853
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	854 static int size(int vtable_length, int itable_length,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	855 int nonstatic_oop_map_size,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	856 bool is_interface, bool is_anonymous) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	857 return align_object_size(header_size() +
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	858 align_object_offset(vtable_length) +
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	859 align_object_offset(itable_length) +
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	860 ((is_interface \|\| is_anonymous) ?
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	861 align_object_offset(nonstatic_oop_map_size) :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	862 nonstatic_oop_map_size) +
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	863 (is_interface ? (int)sizeof(Klass*)/HeapWordSize : 0) +
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	864 (is_anonymous ? (int)sizeof(Klass*)/HeapWordSize : 0));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	865 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	866 int size() const { return size(vtable_length(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	867 itable_length(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	868 nonstatic_oop_map_size(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	869 is_interface(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	870 is_anonymous());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	871 }
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7596 diff changeset	872 #if INCLUDE_SERVICES
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7596 diff changeset	873 virtual void collect_statistics(KlassSizeStats *sz) const;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7596 diff changeset	874 #endif
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	875
0 a61af66fc99e Initial load duke parents: diff changeset	876 static int vtable_start_offset() { return header_size(); }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	877 static int vtable_length_offset() { return offset_of(InstanceKlass, _vtable_len) / HeapWordSize; }
0 a61af66fc99e Initial load duke parents: diff changeset	878
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	879 intptr_t* start_of_vtable() const { return ((intptr_t*)this) + vtable_start_offset(); }
0 a61af66fc99e Initial load duke parents: diff changeset	880 intptr_t* start_of_itable() const { return start_of_vtable() + align_object_offset(vtable_length()); }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	881 int itable_offset_in_words() const { return start_of_itable() - (intptr_t*)this; }
0 a61af66fc99e Initial load duke parents: diff changeset	882
a61af66fc99e Initial load duke parents: diff changeset	883 intptr_t* end_of_itable() const { return start_of_itable() + itable_length(); }
a61af66fc99e Initial load duke parents: diff changeset	884
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	885 address static_field_addr(int offset);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 49 diff changeset	886
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 49 diff changeset	887 OopMapBlock* start_of_nonstatic_oop_maps() const {
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	888 return (OopMapBlock*)(start_of_itable() + align_object_offset(itable_length()));
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 49 diff changeset	889 }
0 a61af66fc99e Initial load duke parents: diff changeset	890
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	891 Klass** end_of_nonstatic_oop_maps() const {
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	892 return (Klass**)(start_of_nonstatic_oop_maps() +
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	893 nonstatic_oop_map_count());
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	894 }
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	895
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	896 Klass** adr_implementor() const {
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	897 if (is_interface()) {
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	898 return (Klass**)end_of_nonstatic_oop_maps();
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	899 } else {
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	900 return NULL;
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	901 }
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	902 };
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	903
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	904 Klass** adr_host_klass() const {
6038 8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	905 if (is_anonymous()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	906 Klass** adr_impl = adr_implementor();
6038 8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	907 if (adr_impl != NULL) {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	908 return adr_impl + 1;
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	909 } else {
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	910 return end_of_nonstatic_oop_maps();
6038 8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	911 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	912 } else {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	913 return NULL;
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	914 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	915 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	916
0 a61af66fc99e Initial load duke parents: diff changeset	917 // Use this to return the size of an instance in heap words:
a61af66fc99e Initial load duke parents: diff changeset	918 int size_helper() const {
a61af66fc99e Initial load duke parents: diff changeset	919 return layout_helper_to_size_helper(layout_helper());
a61af66fc99e Initial load duke parents: diff changeset	920 }
a61af66fc99e Initial load duke parents: diff changeset	921
a61af66fc99e Initial load duke parents: diff changeset	922 // This bit is initialized in classFileParser.cpp.
a61af66fc99e Initial load duke parents: diff changeset	923 // It is false under any of the following conditions:
a61af66fc99e Initial load duke parents: diff changeset	924 // - the class is abstract (including any interface)
a61af66fc99e Initial load duke parents: diff changeset	925 // - the class has a finalizer (if !RegisterFinalizersAtInit)
a61af66fc99e Initial load duke parents: diff changeset	926 // - the class size is larger than FastAllocateSizeLimit
a61af66fc99e Initial load duke parents: diff changeset	927 // - the class is java/lang/Class, which cannot be allocated directly
a61af66fc99e Initial load duke parents: diff changeset	928 bool can_be_fastpath_allocated() const {
a61af66fc99e Initial load duke parents: diff changeset	929 return !layout_helper_needs_slow_path(layout_helper());
a61af66fc99e Initial load duke parents: diff changeset	930 }
a61af66fc99e Initial load duke parents: diff changeset	931
a61af66fc99e Initial load duke parents: diff changeset	932 // Java vtable/itable
a61af66fc99e Initial load duke parents: diff changeset	933 klassVtable* vtable() const; // return new klassVtable wrapper
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	934 inline Method* method_at_vtable(int index);
0 a61af66fc99e Initial load duke parents: diff changeset	935 klassItable* itable() const; // return new klassItable wrapper
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	936 Method* method_at_itable(Klass* holder, int index, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	937
12823 ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	938 #if INCLUDE_JVMTI
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	939 void adjust_default_methods(Method old_methods, Method new_methods,
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	940 int methods_length, bool* trace_name_printed);
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	941 #endif // INCLUDE_JVMTI
ac9cb1d5a202 8009130: Lambda: Fix access controls, loader constraints. acorn parents: 12811 diff changeset	942
0 a61af66fc99e Initial load duke parents: diff changeset	943 // Garbage collection
a61af66fc99e Initial load duke parents: diff changeset	944 void oop_follow_contents(oop obj);
a61af66fc99e Initial load duke parents: diff changeset	945 int oop_adjust_pointers(oop obj);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	946
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	947 void clean_implementors_list(BoolObjectClosure* is_alive);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	948 void clean_method_data(BoolObjectClosure* is_alive);
0 a61af66fc99e Initial load duke parents: diff changeset	949
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	950 // Explicit metaspace deallocation of fields
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	951 // For RedefineClasses and class file parsing errors, we need to deallocate
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	952 // instanceKlasses and the metadata they point to.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	953 void deallocate_contents(ClassLoaderData* loader_data);
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	954 static void deallocate_methods(ClassLoaderData* loader_data,
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	955 Array<Method> methods);
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	956 void static deallocate_interfaces(ClassLoaderData* loader_data,
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	957 Klass* super_klass,
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	958 Array<Klass> local_interfaces,
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	959 Array<Klass> transitive_interfaces);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	960
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	961 // The constant pool is on stack if any of the methods are executing or
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	962 // referenced by handles.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	963 bool on_stack() const { return _constants->on_stack(); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	964
10149 d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	965 // callbacks for actions during class unloading
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	966 static void notify_unload_class(InstanceKlass* ik);
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	967 static void release_C_heap_structures(InstanceKlass* ik);
0 a61af66fc99e Initial load duke parents: diff changeset	968
a61af66fc99e Initial load duke parents: diff changeset	969 // Parallel Scavenge and Parallel Old
a61af66fc99e Initial load duke parents: diff changeset	970 PARALLEL_GC_DECLS
a61af66fc99e Initial load duke parents: diff changeset	971
a61af66fc99e Initial load duke parents: diff changeset	972 // Naming
1039 987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638) jrose parents: 977 diff changeset	973 const char* signature_name() const;
0 a61af66fc99e Initial load duke parents: diff changeset	974
a61af66fc99e Initial load duke parents: diff changeset	975 // Iterators
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	976 int oop_oop_iterate(oop obj, ExtendedOopClosure* blk) {
0 a61af66fc99e Initial load duke parents: diff changeset	977 return oop_oop_iterate_v(obj, blk);
a61af66fc99e Initial load duke parents: diff changeset	978 }
a61af66fc99e Initial load duke parents: diff changeset	979
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	980 int oop_oop_iterate_m(oop obj, ExtendedOopClosure* blk, MemRegion mr) {
0 a61af66fc99e Initial load duke parents: diff changeset	981 return oop_oop_iterate_v_m(obj, blk, mr);
a61af66fc99e Initial load duke parents: diff changeset	982 }
a61af66fc99e Initial load duke parents: diff changeset	983
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	984 #define InstanceKlass_OOP_OOP_ITERATE_DECL(OopClosureType, nv_suffix) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	985 int oop_oop_iterate##nv_suffix(oop obj, OopClosureType* blk); \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	986 int oop_oop_iterate##nv_suffix##_m(oop obj, OopClosureType* blk, \
0 a61af66fc99e Initial load duke parents: diff changeset	987 MemRegion mr);
a61af66fc99e Initial load duke parents: diff changeset	988
a61af66fc99e Initial load duke parents: diff changeset	989 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_DECL)
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	990 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_DECL)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	991
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7596 diff changeset	992 #if INCLUDE_ALL_GCS
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	993 #define InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	994 int oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* blk);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	995
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	996 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DECL)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	997 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DECL)
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7596 diff changeset	998 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	999
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1000 u2 idnum_allocated_count() const { return _idnum_allocated_count; }
10152 c115fac239eb 8008962: NPG: Memory regression: One extra Monitor per ConstantPool iklam parents: 10149 diff changeset	1001
0 a61af66fc99e Initial load duke parents: diff changeset	1002 private:
a61af66fc99e Initial load duke parents: diff changeset	1003 // initialization state
a61af66fc99e Initial load duke parents: diff changeset	1004 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	1005 void set_init_state(ClassState state);
a61af66fc99e Initial load duke parents: diff changeset	1006 #else
4739 52b5d32fbfaf 7117052: instanceKlass::_init_state can be u1 type coleenp parents: 4737 diff changeset	1007 void set_init_state(ClassState state) { _init_state = (u1)state; }
0 a61af66fc99e Initial load duke parents: diff changeset	1008 #endif
6038 8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	1009 void set_rewritten() { _misc_flags \|= _misc_rewritten; }
0 a61af66fc99e Initial load duke parents: diff changeset	1010 void set_init_thread(Thread *thread) { _init_thread = thread; }
a61af66fc99e Initial load duke parents: diff changeset	1011
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	1012 // The RedefineClasses() API can cause new method idnums to be needed
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	1013 // which will cause the caches to grow. Safety requires different
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	1014 // cache management logic if the caches can grow instead of just
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	1015 // going from NULL to non-NULL.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	1016 bool idnum_can_increment() const { return has_been_redefined(); }
0 a61af66fc99e Initial load duke parents: diff changeset	1017 jmethodID* methods_jmethod_ids_acquire() const
a61af66fc99e Initial load duke parents: diff changeset	1018 { return (jmethodID*)OrderAccess::load_ptr_acquire(&_methods_jmethod_ids); }
a61af66fc99e Initial load duke parents: diff changeset	1019 void release_set_methods_jmethod_ids(jmethodID* jmeths)
a61af66fc99e Initial load duke parents: diff changeset	1020 { OrderAccess::release_store_ptr(&_methods_jmethod_ids, jmeths); }
a61af66fc99e Initial load duke parents: diff changeset	1021
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1022 // Lock during initialization
10152 c115fac239eb 8008962: NPG: Memory regression: One extra Monitor per ConstantPool iklam parents: 10149 diff changeset	1023 public:
10343 6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	1024 // Lock for (1) initialization; (2) access to the ConstantPool of this class.
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	1025 // Must be one per class and it has to be a VM internal object so java code
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	1026 // cannot lock it (like the mirror).
6bd680e9ea35 8003421: NPG: Move oops out of InstanceKlass into mirror coleenp parents: 10265 diff changeset	1027 // It has to be an object not a Mutex because it's held through java calls.
12811 3374b92de2d9 8025004: -XX:+CheckUnhandledOops asserts for JDK 8 Solaris fastdebug binaries coleenp parents: 12287 diff changeset	1028 oop init_lock() const;
10152 c115fac239eb 8008962: NPG: Memory regression: One extra Monitor per ConstantPool iklam parents: 10149 diff changeset	1029 private:
12946 b8860472c377 8014910: deadlock between JVM/TI ClassPrepare event handler and CompilerThread iklam parents: 12823 diff changeset	1030 void fence_and_clear_init_lock();
0 a61af66fc99e Initial load duke parents: diff changeset	1031
a61af66fc99e Initial load duke parents: diff changeset	1032 // Static methods that are used to implement member methods where an exposed this pointer
a61af66fc99e Initial load duke parents: diff changeset	1033 // is needed due to possible GCs
a61af66fc99e Initial load duke parents: diff changeset	1034 static bool link_class_impl (instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	1035 static bool verify_code (instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	1036 static void initialize_impl (instanceKlassHandle this_oop, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	1037 static void eager_initialize_impl (instanceKlassHandle this_oop);
a61af66fc99e Initial load duke parents: diff changeset	1038 static void set_initialization_state_and_notify_impl (instanceKlassHandle this_oop, ClassState state, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	1039 static void call_class_initializer_impl (instanceKlassHandle this_oop, TRAPS);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1040 static Klass* array_klass_impl (instanceKlassHandle this_oop, bool or_null, int n, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	1041 static void do_local_static_fields_impl (instanceKlassHandle this_oop, void f(fieldDescriptor* fd, TRAPS), TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	1042 /* jni_id_for_impl for jfieldID only */
a61af66fc99e Initial load duke parents: diff changeset	1043 static JNIid* jni_id_for_impl (instanceKlassHandle this_oop, int offset);
a61af66fc99e Initial load duke parents: diff changeset	1044
a61af66fc99e Initial load duke parents: diff changeset	1045 // Returns the array class for the n'th dimension
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1046 Klass* array_klass_impl(bool or_null, int n, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	1047
a61af66fc99e Initial load duke parents: diff changeset	1048 // Returns the array class with this class as element type
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1049 Klass* array_klass_impl(bool or_null, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	1050
10149 d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	1051 // Free CHeap allocated fields.
d587a5c30bd8 8011803: release_C_heap_structures is never called for anonymous classes. coleenp parents: 10133 diff changeset	1052 void release_C_heap_structures();
0 a61af66fc99e Initial load duke parents: diff changeset	1053 public:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1054 // CDS support - remove and restore oops from metadata. Oops are not shared.
0 a61af66fc99e Initial load duke parents: diff changeset	1055 virtual void remove_unshareable_info();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1056 virtual void restore_unshareable_info(TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	1057
a61af66fc99e Initial load duke parents: diff changeset	1058 // jvm support
a61af66fc99e Initial load duke parents: diff changeset	1059 jint compute_modifier_flags(TRAPS) const;
a61af66fc99e Initial load duke parents: diff changeset	1060
10133 6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 8719 diff changeset	1061 // JSR-292 support
6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 8719 diff changeset	1062 MemberNameTable* member_names() { return _member_names; }
6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 8719 diff changeset	1063 void set_member_names(MemberNameTable* member_names) { _member_names = member_names; }
10345 b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	1064 void add_member_name(int index, Handle member_name);
b7fa10a3a69a 8014288: perf regression in nashorn JDK-8008448.js test after 8008511 changes sspitsyn parents: 10343 diff changeset	1065 oop get_member_name(int index);
10133 6337ca4dcad8 8008511: JSR 292: MemberName vmtarget refs to methods must be updated at class redefinition sspitsyn parents: 8719 diff changeset	1066
0 a61af66fc99e Initial load duke parents: diff changeset	1067 public:
a61af66fc99e Initial load duke parents: diff changeset	1068 // JVMTI support
a61af66fc99e Initial load duke parents: diff changeset	1069 jint jvmti_class_status() const;
a61af66fc99e Initial load duke parents: diff changeset	1070
a61af66fc99e Initial load duke parents: diff changeset	1071 public:
a61af66fc99e Initial load duke parents: diff changeset	1072 // Printing
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1073 #ifndef PRODUCT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1074 void print_on(outputStream* st) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1075 #endif
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1076 void print_value_on(outputStream* st) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1077
1155 4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1126 diff changeset	1078 void oop_print_value_on(oop obj, outputStream* st);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1079
1155 4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1126 diff changeset	1080 #ifndef PRODUCT
0 a61af66fc99e Initial load duke parents: diff changeset	1081 void oop_print_on (oop obj, outputStream* st);
a61af66fc99e Initial load duke parents: diff changeset	1082
a61af66fc99e Initial load duke parents: diff changeset	1083 void print_dependent_nmethods(bool verbose = false);
a61af66fc99e Initial load duke parents: diff changeset	1084 bool is_dependent_nmethod(nmethod* nm);
a61af66fc99e Initial load duke parents: diff changeset	1085 #endif
a61af66fc99e Initial load duke parents: diff changeset	1086
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1087 const char* internal_name() const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1088
0 a61af66fc99e Initial load duke parents: diff changeset	1089 // Verification
14378 48314d596a04 8027146: Class loading verification failure if GC occurs in Universe::flush_dependents_on coleenp parents: 14340 diff changeset	1090 void verify_on(outputStream* st);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1091
0 a61af66fc99e Initial load duke parents: diff changeset	1092 void oop_verify_on(oop obj, outputStream* st);
a61af66fc99e Initial load duke parents: diff changeset	1093 };
a61af66fc99e Initial load duke parents: diff changeset	1094
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1095 inline Method* InstanceKlass::method_at_vtable(int index) {
0 a61af66fc99e Initial load duke parents: diff changeset	1096 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1097 assert(index >= 0, "valid vtable index");
a61af66fc99e Initial load duke parents: diff changeset	1098 if (DebugVtables) {
a61af66fc99e Initial load duke parents: diff changeset	1099 verify_vtable_index(index);
a61af66fc99e Initial load duke parents: diff changeset	1100 }
a61af66fc99e Initial load duke parents: diff changeset	1101 #endif
a61af66fc99e Initial load duke parents: diff changeset	1102 vtableEntry* ve = (vtableEntry*)start_of_vtable();
a61af66fc99e Initial load duke parents: diff changeset	1103 return ve[index].method();
a61af66fc99e Initial load duke parents: diff changeset	1104 }
a61af66fc99e Initial load duke parents: diff changeset	1105
a61af66fc99e Initial load duke parents: diff changeset	1106 // for adding methods
a61af66fc99e Initial load duke parents: diff changeset	1107 // UNSET_IDNUM return means no more ids available
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1108 inline u2 InstanceKlass::next_method_idnum() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1109 if (_idnum_allocated_count == ConstMethod::MAX_IDNUM) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1110 return ConstMethod::UNSET_IDNUM; // no more ids available
0 a61af66fc99e Initial load duke parents: diff changeset	1111 } else {
a61af66fc99e Initial load duke parents: diff changeset	1112 return _idnum_allocated_count++;
a61af66fc99e Initial load duke parents: diff changeset	1113 }
a61af66fc99e Initial load duke parents: diff changeset	1114 }
a61af66fc99e Initial load duke parents: diff changeset	1115
a61af66fc99e Initial load duke parents: diff changeset	1116
a61af66fc99e Initial load duke parents: diff changeset	1117 /* JNIid class for jfieldIDs only */
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6100 diff changeset	1118 class JNIid: public CHeapObj<mtClass> {
0 a61af66fc99e Initial load duke parents: diff changeset	1119 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	1120 private:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1121 Klass* _holder;
0 a61af66fc99e Initial load duke parents: diff changeset	1122 JNIid* _next;
a61af66fc99e Initial load duke parents: diff changeset	1123 int _offset;
a61af66fc99e Initial load duke parents: diff changeset	1124 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	1125 bool _is_static_field_id;
a61af66fc99e Initial load duke parents: diff changeset	1126 #endif
a61af66fc99e Initial load duke parents: diff changeset	1127
a61af66fc99e Initial load duke parents: diff changeset	1128 public:
a61af66fc99e Initial load duke parents: diff changeset	1129 // Accessors
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1130 Klass* holder() const { return _holder; }
0 a61af66fc99e Initial load duke parents: diff changeset	1131 int offset() const { return _offset; }
a61af66fc99e Initial load duke parents: diff changeset	1132 JNIid* next() { return _next; }
a61af66fc99e Initial load duke parents: diff changeset	1133 // Constructor
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1134 JNIid(Klass* holder, int offset, JNIid* next);
0 a61af66fc99e Initial load duke parents: diff changeset	1135 // Identifier lookup
a61af66fc99e Initial load duke parents: diff changeset	1136 JNIid* find(int offset);
a61af66fc99e Initial load duke parents: diff changeset	1137
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	1138 bool find_local_field(fieldDescriptor* fd) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1139 return InstanceKlass::cast(holder())->find_local_field_from_offset(offset(), true, fd);
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	1140 }
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	1141
0 a61af66fc99e Initial load duke parents: diff changeset	1142 static void deallocate(JNIid* id);
a61af66fc99e Initial load duke parents: diff changeset	1143 // Debugging
a61af66fc99e Initial load duke parents: diff changeset	1144 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	1145 bool is_static_field_id() const { return _is_static_field_id; }
a61af66fc99e Initial load duke parents: diff changeset	1146 void set_is_static_field_id() { _is_static_field_id = true; }
a61af66fc99e Initial load duke parents: diff changeset	1147 #endif
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1148 void verify(Klass* holder);
0 a61af66fc99e Initial load duke parents: diff changeset	1149 };
a61af66fc99e Initial load duke parents: diff changeset	1150
a61af66fc99e Initial load duke parents: diff changeset	1151
a61af66fc99e Initial load duke parents: diff changeset	1152 // If breakpoints are more numerous than just JVMTI breakpoints,
a61af66fc99e Initial load duke parents: diff changeset	1153 // consider compressing this data structure.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1154 // It is currently a simple linked list defined in method.hpp.
0 a61af66fc99e Initial load duke parents: diff changeset	1155
a61af66fc99e Initial load duke parents: diff changeset	1156 class BreakpointInfo;
a61af66fc99e Initial load duke parents: diff changeset	1157
a61af66fc99e Initial load duke parents: diff changeset	1158
a61af66fc99e Initial load duke parents: diff changeset	1159 // A collection point for interesting information about the previous
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	1160 // version(s) of an InstanceKlass. A GrowableArray of PreviousVersionNodes
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	1161 // is attached to the InstanceKlass as needed. See PreviousVersionWalker below.
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6100 diff changeset	1162 class PreviousVersionNode : public CHeapObj<mtClass> {
0 a61af66fc99e Initial load duke parents: diff changeset	1163 private:
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	1164 ConstantPool* _prev_constant_pool;
47 2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash dcubed parents: 0 diff changeset	1165
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1166 // If the previous version of the InstanceKlass doesn't have any
0 a61af66fc99e Initial load duke parents: diff changeset	1167 // EMCP methods, then _prev_EMCP_methods will be NULL. If all the
a61af66fc99e Initial load duke parents: diff changeset	1168 // EMCP methods have been collected, then _prev_EMCP_methods can
a61af66fc99e Initial load duke parents: diff changeset	1169 // have a length of zero.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1170 GrowableArray<Method> _prev_EMCP_methods;
0 a61af66fc99e Initial load duke parents: diff changeset	1171
a61af66fc99e Initial load duke parents: diff changeset	1172 public:
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	1173 PreviousVersionNode(ConstantPool* prev_constant_pool,
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	1174 GrowableArray<Method> prev_EMCP_methods);
0 a61af66fc99e Initial load duke parents: diff changeset	1175 ~PreviousVersionNode();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1176 ConstantPool* prev_constant_pool() const {
0 a61af66fc99e Initial load duke parents: diff changeset	1177 return _prev_constant_pool;
a61af66fc99e Initial load duke parents: diff changeset	1178 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1179 GrowableArray<Method> prev_EMCP_methods() const {
0 a61af66fc99e Initial load duke parents: diff changeset	1180 return _prev_EMCP_methods;
a61af66fc99e Initial load duke parents: diff changeset	1181 }
a61af66fc99e Initial load duke parents: diff changeset	1182 };
a61af66fc99e Initial load duke parents: diff changeset	1183
a61af66fc99e Initial load duke parents: diff changeset	1184
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	1185 // Helper object for walking previous versions.
0 a61af66fc99e Initial load duke parents: diff changeset	1186 class PreviousVersionWalker : public StackObj {
a61af66fc99e Initial load duke parents: diff changeset	1187 private:
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	1188 Thread* _thread;
0 a61af66fc99e Initial load duke parents: diff changeset	1189 GrowableArray<PreviousVersionNode > _previous_versions;
a61af66fc99e Initial load duke parents: diff changeset	1190 int _current_index;
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	1191
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	1192 // A pointer to the current node object so we can handle the deletes.
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	1193 PreviousVersionNode* _current_p;
0 a61af66fc99e Initial load duke parents: diff changeset	1194
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	1195 // The constant pool handle keeps all the methods in this class from being
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	1196 // deallocated from the metaspace during class unloading.
4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	1197 constantPoolHandle _current_constant_pool_handle;
0 a61af66fc99e Initial load duke parents: diff changeset	1198
a61af66fc99e Initial load duke parents: diff changeset	1199 public:
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	1200 PreviousVersionWalker(Thread* thread, InstanceKlass *ik);
0 a61af66fc99e Initial load duke parents: diff changeset	1201
a61af66fc99e Initial load duke parents: diff changeset	1202 // Return the interesting information for the next previous version
a61af66fc99e Initial load duke parents: diff changeset	1203 // of the klass. Returns NULL if there are no more previous versions.
12281 4f9a42c33738 8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously coleenp parents: 12067 diff changeset	1204 PreviousVersionNode* next_previous_version();
0 a61af66fc99e Initial load duke parents: diff changeset	1205 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	1206
3939 f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1207
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1208 //
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1209 // nmethodBucket is used to record dependent nmethods for
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1210 // deoptimization. nmethod dependencies are actually <klass, method>
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1211 // pairs but we really only care about the klass part for purposes of
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1212 // finding nmethods which might need to be deoptimized. Instead of
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1213 // recording the method, a count of how many times a particular nmethod
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1214 // was recorded is kept. This ensures that any recording errors are
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1215 // noticed since an nmethod should be removed as many times are it's
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1216 // added.
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1217 //
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6100 diff changeset	1218 class nmethodBucket: public CHeapObj<mtClass> {
3939 f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1219 friend class VMStructs;
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1220 private:
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1221 nmethod* _nmethod;
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1222 int _count;
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1223 nmethodBucket* _next;
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1224
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1225 public:
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1226 nmethodBucket(nmethod* nmethod, nmethodBucket* next) {
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1227 _nmethod = nmethod;
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1228 _next = next;
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1229 _count = 1;
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1230 }
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1231 int count() { return _count; }
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1232 int increment() { _count += 1; return _count; }
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1233 int decrement() { _count -= 1; assert(_count >= 0, "don't underflow"); return _count; }
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1234 nmethodBucket* next() { return _next; }
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1235 void set_next(nmethodBucket* b) { _next = b; }
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1236 nmethod* get_nmethod() { return _nmethod; }
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1237 };
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1238
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1239 // An iterator that's used to access the inner classes indices in the
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1240 // InstanceKlass::_inner_classes array.
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1241 class InnerClassesIterator : public StackObj {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1242 private:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1243 Array<jushort>* _inner_classes;
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1244 int _length;
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1245 int _idx;
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1246 public:
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1247
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1248 InnerClassesIterator(instanceKlassHandle k) {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1249 _inner_classes = k->inner_classes();
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1250 if (k->inner_classes() != NULL) {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1251 _length = _inner_classes->length();
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1252 // The inner class array's length should be the multiple of
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1253 // inner_class_next_offset if it only contains the InnerClasses
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1254 // attribute data, or it should be
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1255 // n*inner_class_next_offset+enclosing_method_attribute_size
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1256 // if it also contains the EnclosingMethod data.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1257 assert((_length % InstanceKlass::inner_class_next_offset == 0 \|\|
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1258 _length % InstanceKlass::inner_class_next_offset == InstanceKlass::enclosing_method_attribute_size),
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1259 "just checking");
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1260 // Remove the enclosing_method portion if exists.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1261 if (_length % InstanceKlass::inner_class_next_offset == InstanceKlass::enclosing_method_attribute_size) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1262 _length -= InstanceKlass::enclosing_method_attribute_size;
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1263 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1264 } else {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1265 _length = 0;
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1266 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1267 _idx = 0;
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1268 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1269
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1270 int length() const {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1271 return _length;
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1272 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1273
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1274 void next() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1275 _idx += InstanceKlass::inner_class_next_offset;
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1276 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1277
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1278 bool done() const {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1279 return (_idx >= _length);
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1280 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1281
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1282 u2 inner_class_info_index() const {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1283 return _inner_classes->at(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1284 _idx + InstanceKlass::inner_class_inner_class_info_offset);
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1285 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1286
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1287 void set_inner_class_info_index(u2 index) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1288 _inner_classes->at_put(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1289 _idx + InstanceKlass::inner_class_inner_class_info_offset, index);
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1290 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1291
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1292 u2 outer_class_info_index() const {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1293 return _inner_classes->at(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1294 _idx + InstanceKlass::inner_class_outer_class_info_offset);
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1295 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1296
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1297 void set_outer_class_info_index(u2 index) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1298 _inner_classes->at_put(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1299 _idx + InstanceKlass::inner_class_outer_class_info_offset, index);
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1300 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1301
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1302 u2 inner_name_index() const {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1303 return _inner_classes->at(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1304 _idx + InstanceKlass::inner_class_inner_name_offset);
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1305 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1306
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1307 void set_inner_name_index(u2 index) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1308 _inner_classes->at_put(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1309 _idx + InstanceKlass::inner_class_inner_name_offset, index);
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1310 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1311
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1312 u2 inner_access_flags() const {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1313 return _inner_classes->at(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1314 _idx + InstanceKlass::inner_class_access_flags_offset);
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1315 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1316 };
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1317
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	1318 #endif // SHARE_VM_OOPS_INSTANCEKLASS_HPP

Mercurial > hg > truffle

annotate src/share/vm/oops/instanceKlass.hpp @ 14649:f6301b007a16