graal-compiler: src/share/vm/oops/instanceKlass.hpp annotate

annotate src/share/vm/oops/instanceKlass.hpp @ 10185:d50cc62e94ff

8012715: G1: GraphKit accesses PtrQueue::_index as int but is size_t Summary: In graphKit INT operations were generated to access PtrQueue::_index which has type size_t. This is 64 bit on 64-bit machines. No problems occur on little endian machines as long as the index fits into 32 bit, but on big endian machines the upper part is read, which is zero. This leads to unnecessary branches to the slow path in the runtime. Reviewed-by: twisti, johnc Contributed-by: Martin Doerr <martin.doerr@sap.com>

author	johnc
date	Wed, 24 Apr 2013 14:48:43 -0700
parents	c8b31b461e1a
children	b9a918201d47 6337ca4dcad8

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7596 diff changeset	2 * Copyright (c) 1997, 2013, 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"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	29 #include "oops/annotations.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	30 #include "oops/constMethod.hpp"
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	31 #include "oops/fieldInfo.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	32 #include "oops/instanceOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	33 #include "oops/klassVtable.hpp"
7464 ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 6972 diff changeset	34 #include "runtime/atomic.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	35 #include "runtime/handles.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	36 #include "runtime/os.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	37 #include "utilities/accessFlags.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	38 #include "utilities/bitMap.inline.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7596 diff changeset	39 #include "utilities/macros.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	40
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	41 // An InstanceKlass is the VM level representation of a Java class.
0 a61af66fc99e Initial load duke parents: diff changeset	42 // It contains all information needed for at class at execution runtime.
a61af66fc99e Initial load duke parents: diff changeset	43
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	44 // InstanceKlass layout:
0 a61af66fc99e Initial load duke parents: diff changeset	45 // [C++ vtbl pointer ] Klass
a61af66fc99e Initial load duke parents: diff changeset	46 // [subtype cache ] Klass
a61af66fc99e Initial load duke parents: diff changeset	47 // [instance size ] Klass
a61af66fc99e Initial load duke parents: diff changeset	48 // [java mirror ] Klass
a61af66fc99e Initial load duke parents: diff changeset	49 // [super ] Klass
a61af66fc99e Initial load duke parents: diff changeset	50 // [access_flags ] Klass
a61af66fc99e Initial load duke parents: diff changeset	51 // [name ] Klass
a61af66fc99e Initial load duke parents: diff changeset	52 // [first subklass ] Klass
a61af66fc99e Initial load duke parents: diff changeset	53 // [next sibling ] Klass
a61af66fc99e Initial load duke parents: diff changeset	54 // [array klasses ]
a61af66fc99e Initial load duke parents: diff changeset	55 // [methods ]
a61af66fc99e Initial load duke parents: diff changeset	56 // [local interfaces ]
a61af66fc99e Initial load duke parents: diff changeset	57 // [transitive interfaces ]
a61af66fc99e Initial load duke parents: diff changeset	58 // [fields ]
a61af66fc99e Initial load duke parents: diff changeset	59 // [constants ]
a61af66fc99e Initial load duke parents: diff changeset	60 // [class loader ]
a61af66fc99e Initial load duke parents: diff changeset	61 // [protection domain ]
a61af66fc99e Initial load duke parents: diff changeset	62 // [signers ]
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;
a61af66fc99e Initial load duke parents: diff changeset	93
a61af66fc99e Initial load duke parents: diff changeset	94 // This is used in iterators below.
a61af66fc99e Initial load duke parents: diff changeset	95 class FieldClosure: public StackObj {
a61af66fc99e Initial load duke parents: diff changeset	96 public:
a61af66fc99e Initial load duke parents: diff changeset	97 virtual void do_field(fieldDescriptor* fd) = 0;
a61af66fc99e Initial load duke parents: diff changeset	98 };
a61af66fc99e Initial load duke parents: diff changeset	99
a61af66fc99e Initial load duke parents: diff changeset	100 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	101 // Print fields.
a61af66fc99e Initial load duke parents: diff changeset	102 // If "obj" argument to constructor is NULL, prints static fields, otherwise prints non-static fields.
a61af66fc99e Initial load duke parents: diff changeset	103 class FieldPrinter: public FieldClosure {
a61af66fc99e Initial load duke parents: diff changeset	104 oop _obj;
a61af66fc99e Initial load duke parents: diff changeset	105 outputStream* _st;
a61af66fc99e Initial load duke parents: diff changeset	106 public:
a61af66fc99e Initial load duke parents: diff changeset	107 FieldPrinter(outputStream* st, oop obj = NULL) : _obj(obj), _st(st) {}
a61af66fc99e Initial load duke parents: diff changeset	108 void do_field(fieldDescriptor* fd);
a61af66fc99e Initial load duke parents: diff changeset	109 };
a61af66fc99e Initial load duke parents: diff changeset	110 #endif // !PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	111
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	112 // ValueObjs embedded in klass. Describes where oops are located in instances of
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	113 // this klass.
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	114 class OopMapBlock VALUE_OBJ_CLASS_SPEC {
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	115 public:
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	116 // 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	117 int offset() const { return _offset; }
9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	118 void set_offset(int offset) { _offset = offset; }
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	119
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	120 // Number of oops in this block.
939 9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	121 uint count() const { return _count; }
9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	122 void set_count(uint count) { _count = count; }
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	123
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	124 // sizeof(OopMapBlock) in HeapWords.
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	125 static const int size_in_words() {
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	126 return align_size_up(int(sizeof(OopMapBlock)), HeapWordSize) >>
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	127 LogHeapWordSize;
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	128 }
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	129
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	130 private:
939 9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	131 int _offset;
9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	132 uint _count;
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	133 };
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	134
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	135 class InstanceKlass: public Klass {
0 a61af66fc99e Initial load duke parents: diff changeset	136 friend class VMStructs;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	137 friend class ClassFileParser;
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6934 diff changeset	138 friend class CompileReplay;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	139
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	140 protected:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	141 // Constructor
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	142 InstanceKlass(int vtable_len,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	143 int itable_len,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	144 int static_field_size,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	145 int nonstatic_oop_map_size,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	146 ReferenceType rt,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	147 AccessFlags access_flags,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	148 bool is_anonymous);
0 a61af66fc99e Initial load duke parents: diff changeset	149 public:
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	150 static InstanceKlass* allocate_instance_klass(
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	151 ClassLoaderData* loader_data,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	152 int vtable_len,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	153 int itable_len,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	154 int static_field_size,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	155 int nonstatic_oop_map_size,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	156 ReferenceType rt,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	157 AccessFlags access_flags,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	158 Symbol* name,
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	159 Klass* super_klass,
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	160 bool is_anonymous,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	161 TRAPS);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	162
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	163 InstanceKlass() { assert(DumpSharedSpaces \|\| UseSharedSpaces, "only for CDS"); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	164
0 a61af66fc99e Initial load duke parents: diff changeset	165 // See "The Java Virtual Machine Specification" section 2.16.2-5 for a detailed description
a61af66fc99e Initial load duke parents: diff changeset	166 // of the class loading & initialization procedure, and the use of the states.
a61af66fc99e Initial load duke parents: diff changeset	167 enum ClassState {
a61af66fc99e Initial load duke parents: diff changeset	168 allocated, // allocated (but not yet linked)
a61af66fc99e Initial load duke parents: diff changeset	169 loaded, // loaded and inserted in class hierarchy (but not linked yet)
a61af66fc99e Initial load duke parents: diff changeset	170 linked, // successfully linked/verified (but not initialized yet)
a61af66fc99e Initial load duke parents: diff changeset	171 being_initialized, // currently running class initializer
a61af66fc99e Initial load duke parents: diff changeset	172 fully_initialized, // initialized (successfull final state)
a61af66fc99e Initial load duke parents: diff changeset	173 initialization_error // error happened during initialization
a61af66fc99e Initial load duke parents: diff changeset	174 };
a61af66fc99e Initial load duke parents: diff changeset	175
7464 ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 6972 diff changeset	176 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	177
ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 6972 diff changeset	178 private:
ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 6972 diff changeset	179 static volatile int _total_instanceKlass_count;
ecd24264898b 8005048: NMT: #loaded classes needs to just show the # defined classes zgu parents: 6972 diff changeset	180
0 a61af66fc99e Initial load duke parents: diff changeset	181 protected:
a61af66fc99e Initial load duke parents: diff changeset	182 // Protection domain.
a61af66fc99e Initial load duke parents: diff changeset	183 oop _protection_domain;
a61af66fc99e Initial load duke parents: diff changeset	184 // Class signers.
a61af66fc99e Initial load duke parents: diff changeset	185 objArrayOop _signers;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	186 // Initialization lock. Must be one per class and it has to be a VM internal
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	187 // object so java code cannot lock it (like the mirror)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	188 // It has to be an object not a Mutex because it's held through java calls.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	189 volatile oop _init_lock;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	190
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	191 // Annotations for this class
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	192 Annotations* _annotations;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	193 // Array classes holding elements of this class.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	194 Klass* _array_klasses;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	195 // Constant pool for this class.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	196 ConstantPool* _constants;
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	197 // 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	198 // _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	199 // 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	200 // [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	201 // 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	202 // 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	203 // 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	204 // 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	205 // 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	206 // 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	207 // 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	208 Array<jushort>* _inner_classes;
0 a61af66fc99e Initial load duke parents: diff changeset	209
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	210 // Name of source file containing this klass, NULL if not specified.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	211 Symbol* _source_file_name;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	212 // 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	213 // 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	214 // 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	215 char* _source_debug_extension;
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	216 // Generic signature, or null if none.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	217 Symbol* _generic_signature;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	218 // 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	219 // if this class is unloaded.
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	220 Symbol* _array_name;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	221
165 437d03ea40b1 6703888: Compressed Oops: use the 32-bits gap after klass in a object kvn parents: 113 diff changeset	222 // 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	223 // (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	224 int _nonstatic_field_size;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 49 diff changeset	225 int _static_field_size; // number words used by static fields (oop and non-oop) in this klass
4744 cd5d8cafcc84 7123315: instanceKlass::_static_oop_field_count and instanceKlass::_java_fields_count should be u2 type. jiangli parents: 4739 diff changeset	226 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	227 u2 _java_fields_count; // The number of declared Java fields
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	228 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	229
7593 337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	230 // _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	231 // _misc_flags.
4772 8f8b94305aff 7129240: backout fix for 7102776 until 7128770 is resolved dcubed parents: 4771 diff changeset	232 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	233
6038 8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	234 enum {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	235 _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	236 _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	237 _misc_should_verify_class = 1 << 2, // allow caching of preverification
7587 4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	238 _misc_is_anonymous = 1 << 3, // has embedded _inner_classes field
7596 212c5b9c38e7 Merge dlong parents: 7593 7587 diff changeset	239 _misc_is_contended = 1 << 4, // marked with contended annotation
212c5b9c38e7 Merge dlong parents: 7593 7587 diff changeset	240 _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	241 };
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	242 u2 _misc_flags;
0 a61af66fc99e Initial load duke parents: diff changeset	243 u2 _minor_version; // minor version number of class file
a61af66fc99e Initial load duke parents: diff changeset	244 u2 _major_version; // major version number of class file
a61af66fc99e Initial load duke parents: diff changeset	245 Thread* _init_thread; // Pointer to current thread doing initialization (to handle recusive initialization)
a61af66fc99e Initial load duke parents: diff changeset	246 int _vtable_len; // length of Java vtable (in words)
a61af66fc99e Initial load duke parents: diff changeset	247 int _itable_len; // length of Java itable (in words)
a61af66fc99e Initial load duke parents: diff changeset	248 OopMapCache* volatile _oop_map_cache; // OopMapCache for all methods in the klass (allocated lazily)
a61af66fc99e Initial load duke parents: diff changeset	249 JNIid* _jni_ids; // First JNI identifier for static fields in this class
a61af66fc99e Initial load duke parents: diff changeset	250 jmethodID* _methods_jmethod_ids; // jmethodIDs corresponding to method_idnum, or NULL if none
a61af66fc99e Initial load duke parents: diff changeset	251 int* _methods_cached_itable_indices; // itable_index cache for JNI invoke corresponding to methods idnum, or NULL
a61af66fc99e Initial load duke parents: diff changeset	252 nmethodBucket* _dependencies; // list of dependent nmethods
a61af66fc99e Initial load duke parents: diff changeset	253 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	254 BreakpointInfo* _breakpoints; // bpt lists, managed by Method*
0 a61af66fc99e Initial load duke parents: diff changeset	255 // 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	256 // InstanceKlass. See PreviousVersionWalker below.
0 a61af66fc99e Initial load duke parents: diff changeset	257 GrowableArray<PreviousVersionNode > _previous_versions;
a61af66fc99e Initial load duke parents: diff changeset	258 // JVMTI fields can be moved to their own structure - see 6315920
a61af66fc99e Initial load duke parents: diff changeset	259 unsigned char * _cached_class_file_bytes; // JVMTI: cached class file, before retransformable agent modified it in CFLH
a61af66fc99e Initial load duke parents: diff changeset	260 jint _cached_class_file_len; // JVMTI: length of above
7968 44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7596 diff changeset	261
44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7596 diff changeset	262 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	263
44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7596 diff changeset	264 // 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	265 // 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	266 // _idnum_allocated_count.
44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7596 diff changeset	267 u1 _init_state; // state of class
44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7596 diff changeset	268 u1 _reference_type; // reference type
44c5fcd9cb25 8006280: Need to reorder metadata structures to reduce size (64-bit) iklam parents: 7596 diff changeset	269
0 a61af66fc99e Initial load duke parents: diff changeset	270 JvmtiCachedClassFieldMap* _jvmti_cached_class_field_map; // JVMTI: used during heap iteration
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	271
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	272 NOT_PRODUCT(int _verify_count;) // to avoid redundant verifies
3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	273
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	274 // Method array.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	275 Array<Method> _methods;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	276 // 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	277 Array<Klass> _local_interfaces;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	278 // Interface (Klass*s) this class implements transitively.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	279 Array<Klass> _transitive_interfaces;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	280 // 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	281 Array<int>* _method_ordering;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	282 // 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	283 // [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	284 // 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	285 // 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	286 // 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	287 //
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	288 // 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	289 // 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	290 // ...
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	291 // 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	292 // [generic signature index]
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	293 // [generic signature index]
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	294 // ...
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	295 Array<u2>* _fields;
0 a61af66fc99e Initial load duke parents: diff changeset	296
a61af66fc99e Initial load duke parents: diff changeset	297 // embedded Java vtable follows here
a61af66fc99e Initial load duke parents: diff changeset	298 // embedded Java itables follows here
a61af66fc99e Initial load duke parents: diff changeset	299 // embedded static fields follows here
a61af66fc99e Initial load duke parents: diff changeset	300 // 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	301 // 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	302 // 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	303 // 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	304 // three cases:
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	305 // NULL: no implementor.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	306 // 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	307 // 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	308 // 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	309 // 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	310 // 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	311 // 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	312 // 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	313 // 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	314 // 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	315 //
0 a61af66fc99e Initial load duke parents: diff changeset	316
a61af66fc99e Initial load duke parents: diff changeset	317 friend class SystemDictionary;
a61af66fc99e Initial load duke parents: diff changeset	318
a61af66fc99e Initial load duke parents: diff changeset	319 public:
6038 8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	320 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	321 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	322 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	323 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	324 if (b) {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	325 _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	326 } else {
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 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	329 }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 49 diff changeset	330
0 a61af66fc99e Initial load duke parents: diff changeset	331 // field sizes
a61af66fc99e Initial load duke parents: diff changeset	332 int nonstatic_field_size() const { return _nonstatic_field_size; }
a61af66fc99e Initial load duke parents: diff changeset	333 void set_nonstatic_field_size(int size) { _nonstatic_field_size = size; }
a61af66fc99e Initial load duke parents: diff changeset	334
a61af66fc99e Initial load duke parents: diff changeset	335 int static_field_size() const { return _static_field_size; }
a61af66fc99e Initial load duke parents: diff changeset	336 void set_static_field_size(int size) { _static_field_size = size; }
a61af66fc99e Initial load duke parents: diff changeset	337
4744 cd5d8cafcc84 7123315: instanceKlass::_static_oop_field_count and instanceKlass::_java_fields_count should be u2 type. jiangli parents: 4739 diff changeset	338 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	339 void set_static_oop_field_count(u2 size) { _static_oop_field_count = size; }
0 a61af66fc99e Initial load duke parents: diff changeset	340
a61af66fc99e Initial load duke parents: diff changeset	341 // Java vtable
a61af66fc99e Initial load duke parents: diff changeset	342 int vtable_length() const { return _vtable_len; }
a61af66fc99e Initial load duke parents: diff changeset	343 void set_vtable_length(int len) { _vtable_len = len; }
a61af66fc99e Initial load duke parents: diff changeset	344
a61af66fc99e Initial load duke parents: diff changeset	345 // Java itable
a61af66fc99e Initial load duke parents: diff changeset	346 int itable_length() const { return _itable_len; }
a61af66fc99e Initial load duke parents: diff changeset	347 void set_itable_length(int len) { _itable_len = len; }
a61af66fc99e Initial load duke parents: diff changeset	348
a61af66fc99e Initial load duke parents: diff changeset	349 // array klasses
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	350 Klass* array_klasses() const { return _array_klasses; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	351 void set_array_klasses(Klass* k) { _array_klasses = k; }
0 a61af66fc99e Initial load duke parents: diff changeset	352
a61af66fc99e Initial load duke parents: diff changeset	353 // methods
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	354 Array<Method> methods() const { return _methods; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	355 void set_methods(Array<Method> a) { _methods = a; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	356 Method* method_with_idnum(int idnum);
0 a61af66fc99e Initial load duke parents: diff changeset	357
a61af66fc99e Initial load duke parents: diff changeset	358 // method ordering
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	359 Array<int>* method_ordering() const { return _method_ordering; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	360 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	361 void copy_method_ordering(intArray* m, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	362
a61af66fc99e Initial load duke parents: diff changeset	363 // interfaces
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	364 Array<Klass> local_interfaces() const { return _local_interfaces; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	365 void set_local_interfaces(Array<Klass> a) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	366 guarantee(_local_interfaces == NULL \|\| a == NULL, "Just checking");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	367 _local_interfaces = a; }
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	368
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	369 Array<Klass> transitive_interfaces() const { return _transitive_interfaces; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	370 void set_transitive_interfaces(Array<Klass> a) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	371 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	372 _transitive_interfaces = a;
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	373 }
0 a61af66fc99e Initial load duke parents: diff changeset	374
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	375 private:
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	376 friend class fieldDescriptor;
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	377 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	378
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	379 public:
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	380 int field_offset (int index) const { return field(index)->offset(); }
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	381 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	382 Symbol* field_name (int index) const { return field(index)->name(constants()); }
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	383 Symbol* field_signature (int index) const { return field(index)->signature(constants()); }
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	384
e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	385 // 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	386 int java_fields_count() const { return (int)_java_fields_count; }
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	387
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	388 Array<u2>* fields() const { return _fields; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	389 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	390 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	391 _fields = f;
3938 e6b1331a51d2 7086585: make Java field injection more flexible never parents: 3748 diff changeset	392 _java_fields_count = java_fields_count;
0 a61af66fc99e Initial load duke parents: diff changeset	393 }
a61af66fc99e Initial load duke parents: diff changeset	394
a61af66fc99e Initial load duke parents: diff changeset	395 // inner classes
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	396 Array<u2>* inner_classes() const { return _inner_classes; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	397 void set_inner_classes(Array<u2>* f) { _inner_classes = f; }
0 a61af66fc99e Initial load duke parents: diff changeset	398
a61af66fc99e Initial load duke parents: diff changeset	399 enum InnerClassAttributeOffset {
a61af66fc99e Initial load duke parents: diff changeset	400 // From http://mirror.eng/products/jdk/1.1/docs/guide/innerclasses/spec/innerclasses.doc10.html#18814
a61af66fc99e Initial load duke parents: diff changeset	401 inner_class_inner_class_info_offset = 0,
a61af66fc99e Initial load duke parents: diff changeset	402 inner_class_outer_class_info_offset = 1,
a61af66fc99e Initial load duke parents: diff changeset	403 inner_class_inner_name_offset = 2,
a61af66fc99e Initial load duke parents: diff changeset	404 inner_class_access_flags_offset = 3,
a61af66fc99e Initial load duke parents: diff changeset	405 inner_class_next_offset = 4
a61af66fc99e Initial load duke parents: diff changeset	406 };
a61af66fc99e Initial load duke parents: diff changeset	407
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	408 enum EnclosingMethodAttributeOffset {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	409 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	410 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	411 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	412 };
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	413
652 4aaa9f5e02a8 4766230: Hotspot vtable inconsistencies cause core dumps. 6579515. 6582242. acorn parents: 431 diff changeset	414 // method override check
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	415 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	416
0 a61af66fc99e Initial load duke parents: diff changeset	417 // package
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	418 bool is_same_class_package(Klass* class2);
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	419 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	420 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	421
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 431 diff changeset	422 // 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	423 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	424 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	425 return compute_enclosing_class_impl(self, inner_is_member, THREAD);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 431 diff changeset	426 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	427 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	428 bool* inner_is_member, TRAPS);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 431 diff changeset	429
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 431 diff changeset	430 // 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	431 bool is_same_package_member(Klass* class2, TRAPS) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	432 instanceKlassHandle self(THREAD, this);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 431 diff changeset	433 return is_same_package_member_impl(self, class2, THREAD);
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 431 diff changeset	434 }
c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 431 diff changeset	435 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	436 Klass* class2, TRAPS);
665 c89f86385056 6814659: separable cleanups and subroutines for 6655638 jrose parents: 431 diff changeset	437
0 a61af66fc99e Initial load duke parents: diff changeset	438 // initialization state
a61af66fc99e Initial load duke parents: diff changeset	439 bool is_loaded() const { return _init_state >= loaded; }
a61af66fc99e Initial load duke parents: diff changeset	440 bool is_linked() const { return _init_state >= linked; }
a61af66fc99e Initial load duke parents: diff changeset	441 bool is_initialized() const { return _init_state == fully_initialized; }
a61af66fc99e Initial load duke parents: diff changeset	442 bool is_not_initialized() const { return _init_state < being_initialized; }
a61af66fc99e Initial load duke parents: diff changeset	443 bool is_being_initialized() const { return _init_state == being_initialized; }
a61af66fc99e Initial load duke parents: diff changeset	444 bool is_in_error_state() const { return _init_state == initialization_error; }
a61af66fc99e Initial load duke parents: diff changeset	445 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	446 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	447 bool is_rewritten() const { return (_misc_flags & _misc_rewritten) != 0; }
973 ad6585fd4087 6830542: Performance: JVM_DefineClass already verified. acorn parents: 726 diff changeset	448
ad6585fd4087 6830542: Performance: JVM_DefineClass already verified. acorn parents: 726 diff changeset	449 // 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	450 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	451 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	452 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	453 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	454 if (value) {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	455 _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	456 } else {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	457 _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	458 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	459 }
0 a61af66fc99e Initial load duke parents: diff changeset	460
a61af66fc99e Initial load duke parents: diff changeset	461 // marking
4772 8f8b94305aff 7129240: backout fix for 7102776 until 7128770 is resolved dcubed parents: 4771 diff changeset	462 bool is_marked_dependent() const { return _is_marked_dependent; }
8f8b94305aff 7129240: backout fix for 7102776 until 7128770 is resolved dcubed parents: 4771 diff changeset	463 void set_is_marked_dependent(bool value) { _is_marked_dependent = value; }
0 a61af66fc99e Initial load duke parents: diff changeset	464
a61af66fc99e Initial load duke parents: diff changeset	465 // initialization (virtuals from Klass)
a61af66fc99e Initial load duke parents: diff changeset	466 bool should_be_initialized() const; // means that initialize should be called
a61af66fc99e Initial load duke parents: diff changeset	467 void initialize(TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	468 void link_class(TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	469 bool link_class_or_fail(TRAPS); // returns false on failure
a61af66fc99e Initial load duke parents: diff changeset	470 void unlink_class();
a61af66fc99e Initial load duke parents: diff changeset	471 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	472 void link_methods(TRAPS);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	473 Method* class_initializer();
0 a61af66fc99e Initial load duke parents: diff changeset	474
a61af66fc99e Initial load duke parents: diff changeset	475 // set the class to initialized if no static initializer is present
a61af66fc99e Initial load duke parents: diff changeset	476 void eager_initialize(Thread *thread);
a61af66fc99e Initial load duke parents: diff changeset	477
a61af66fc99e Initial load duke parents: diff changeset	478 // reference type
4899 a79cb7c55012 7132690: InstanceKlass:_reference_type should be u1 type jiangli parents: 4772 diff changeset	479 ReferenceType reference_type() const { return (ReferenceType)_reference_type; }
a79cb7c55012 7132690: InstanceKlass:_reference_type should be u1 type jiangli parents: 4772 diff changeset	480 void set_reference_type(ReferenceType t) {
a79cb7c55012 7132690: InstanceKlass:_reference_type should be u1 type jiangli parents: 4772 diff changeset	481 assert(t == (u1)t, "overflow");
a79cb7c55012 7132690: InstanceKlass:_reference_type should be u1 type jiangli parents: 4772 diff changeset	482 _reference_type = (u1)t;
a79cb7c55012 7132690: InstanceKlass:_reference_type should be u1 type jiangli parents: 4772 diff changeset	483 }
0 a61af66fc99e Initial load duke parents: diff changeset	484
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	485 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	486
0 a61af66fc99e Initial load duke parents: diff changeset	487 // find local field, returns true if found
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	488 bool find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
0 a61af66fc99e Initial load duke parents: diff changeset	489 // 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	490 Klass* find_interface_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
0 a61af66fc99e Initial load duke parents: diff changeset	491 // 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	492 Klass* find_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const;
0 a61af66fc99e Initial load duke parents: diff changeset	493 // 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	494 Klass* find_field(Symbol* name, Symbol* sig, bool is_static, fieldDescriptor* fd) const;
0 a61af66fc99e Initial load duke parents: diff changeset	495
a61af66fc99e Initial load duke parents: diff changeset	496 // find a non-static or static field given its offset within the class.
a61af66fc99e Initial load duke parents: diff changeset	497 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	498 return instanceOopDesc::contains_field_offset(offset, nonstatic_field_size());
0 a61af66fc99e Initial load duke parents: diff changeset	499 }
a61af66fc99e Initial load duke parents: diff changeset	500
a61af66fc99e Initial load duke parents: diff changeset	501 bool find_local_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const;
a61af66fc99e Initial load duke parents: diff changeset	502 bool find_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const;
a61af66fc99e Initial load duke parents: diff changeset	503
a61af66fc99e Initial load duke parents: diff changeset	504 // 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	505 Method* find_method(Symbol* name, Symbol* signature) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	506 static Method* find_method(Array<Method> methods, Symbol* name, Symbol* signature);
0 a61af66fc99e Initial load duke parents: diff changeset	507
a61af66fc99e Initial load duke parents: diff changeset	508 // lookup operation (returns NULL if not found)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	509 Method* uncached_lookup_method(Symbol* name, Symbol* signature) const;
0 a61af66fc99e Initial load duke parents: diff changeset	510
a61af66fc99e Initial load duke parents: diff changeset	511 // lookup a method in all the interfaces that this class implements
a61af66fc99e Initial load duke parents: diff changeset	512 // (returns NULL if not found)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	513 Method* lookup_method_in_all_interfaces(Symbol* name, Symbol* signature) const;
0 a61af66fc99e Initial load duke parents: diff changeset	514
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	515 // 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	516 // 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	517 // 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	518 // -1 is returned.
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	519 int find_method_by_name(Symbol* name, int* end);
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	520 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	521
0 a61af66fc99e Initial load duke parents: diff changeset	522 // constant pool
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	523 ConstantPool* constants() const { return _constants; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	524 void set_constants(ConstantPool* c) { _constants = c; }
0 a61af66fc99e Initial load duke parents: diff changeset	525
a61af66fc99e Initial load duke parents: diff changeset	526 // protection domain
a61af66fc99e Initial load duke parents: diff changeset	527 oop protection_domain() { return _protection_domain; }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	528 void set_protection_domain(oop pd) { klass_oop_store(&_protection_domain, pd); }
0 a61af66fc99e Initial load duke parents: diff changeset	529
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 356 diff changeset	530 // host class
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	531 Klass* host_klass() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	532 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	533 if (hk == NULL) {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	534 return NULL;
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	535 } else {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	536 return *hk;
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	537 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	538 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	539 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	540 assert(is_anonymous(), "not anonymous");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	541 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	542 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	543 if (addr != NULL) {
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	544 *addr = host;
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	545 }
6038 8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	546 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	547 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	548 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	549 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	550 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	551 if (value) {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	552 _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	553 } else {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	554 _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	555 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	556 }
431 a45484ea312d 6653858: dynamic languages need to be able to load anonymous classes jrose parents: 356 diff changeset	557
7409 30866cd626b0 8004883: NPG: clean up anonymous class fix coleenp parents: 6972 diff changeset	558 // Oop that keeps the metadata for this class from being unloaded
30866cd626b0 8004883: NPG: clean up anonymous class fix coleenp parents: 6972 diff changeset	559 // 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	560 oop klass_holder() const {
30866cd626b0 8004883: NPG: clean up anonymous class fix coleenp parents: 6972 diff changeset	561 return is_anonymous() ? java_mirror() : class_loader();
30866cd626b0 8004883: NPG: clean up anonymous class fix coleenp parents: 6972 diff changeset	562 }
30866cd626b0 8004883: NPG: clean up anonymous class fix coleenp parents: 6972 diff changeset	563
7587 4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	564 bool is_contended() const {
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	565 return (_misc_flags & _misc_is_contended) != 0;
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	566 }
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	567 void set_is_contended(bool value) {
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	568 if (value) {
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	569 _misc_flags \|= _misc_is_contended;
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	570 } else {
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	571 _misc_flags &= ~_misc_is_contended;
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	572 }
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	573 }
4a916f2ce331 8003985: Support @Contended Annotation - JEP 142 jwilhelm parents: 7465 diff changeset	574
0 a61af66fc99e Initial load duke parents: diff changeset	575 // signers
a61af66fc99e Initial load duke parents: diff changeset	576 objArrayOop signers() const { return _signers; }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	577 void set_signers(objArrayOop s) { klass_oop_store((oop*)&_signers, s); }
0 a61af66fc99e Initial load duke parents: diff changeset	578
a61af66fc99e Initial load duke parents: diff changeset	579 // source file name
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	580 Symbol* source_file_name() const { return _source_file_name; }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	581 void set_source_file_name(Symbol* n);
0 a61af66fc99e Initial load duke parents: diff changeset	582
a61af66fc99e Initial load duke parents: diff changeset	583 // minor and major version numbers of class file
a61af66fc99e Initial load duke parents: diff changeset	584 u2 minor_version() const { return _minor_version; }
a61af66fc99e Initial load duke parents: diff changeset	585 void set_minor_version(u2 minor_version) { _minor_version = minor_version; }
a61af66fc99e Initial load duke parents: diff changeset	586 u2 major_version() const { return _major_version; }
a61af66fc99e Initial load duke parents: diff changeset	587 void set_major_version(u2 major_version) { _major_version = major_version; }
a61af66fc99e Initial load duke parents: diff changeset	588
a61af66fc99e Initial load duke parents: diff changeset	589 // source debug extension
6203 04ade88d9712 6294277: java -Xdebug crashes on SourceDebugExtension attribute larger than 64K fparain parents: 6197 diff changeset	590 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	591 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	592
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	593 // symbol unloading support (refcount already added)
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	594 Symbol* array_name() { return _array_name; }
8712 3efdfd6ddbf2 8003553: NPG: metaspace objects should be zeroed in constructors coleenp parents: 8031 diff changeset	595 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	596
a61af66fc99e Initial load duke parents: diff changeset	597 // nonstatic oop-map blocks
939 9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	598 static int nonstatic_oop_map_size(unsigned int oop_map_count) {
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	599 return oop_map_count * OopMapBlock::size_in_words();
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	600 }
939 9eebd3ac74cf 6845368: large objects cause a crash or unexpected exception jcoomes parents: 938 diff changeset	601 unsigned int nonstatic_oop_map_count() const {
938 b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	602 return _nonstatic_oop_map_size / OopMapBlock::size_in_words();
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	603 }
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	604 int nonstatic_oop_map_size() const { return _nonstatic_oop_map_size; }
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	605 void set_nonstatic_oop_map_size(int words) {
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	606 _nonstatic_oop_map_size = words;
b37c246bf7ce 6861660: OopMapBlock count/size confusion jcoomes parents: 726 diff changeset	607 }
0 a61af66fc99e Initial load duke parents: diff changeset	608
a61af66fc99e Initial load duke parents: diff changeset	609 // RedefineClasses() support for previous versions:
a61af66fc99e Initial load duke parents: diff changeset	610 void add_previous_version(instanceKlassHandle ikh, BitMap *emcp_methods,
a61af66fc99e Initial load duke parents: diff changeset	611 int emcp_method_count);
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	612 // 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	613 // 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	614 // tracking a previous version.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	615 bool has_been_redefined() const { return _previous_versions != NULL; }
0 a61af66fc99e Initial load duke parents: diff changeset	616 bool has_previous_version() const;
a61af66fc99e Initial load duke parents: diff changeset	617 void init_previous_versions() {
a61af66fc99e Initial load duke parents: diff changeset	618 _previous_versions = NULL;
a61af66fc99e Initial load duke parents: diff changeset	619 }
a61af66fc99e Initial load duke parents: diff changeset	620 GrowableArray<PreviousVersionNode > previous_versions() const {
a61af66fc99e Initial load duke parents: diff changeset	621 return _previous_versions;
a61af66fc99e Initial load duke parents: diff changeset	622 }
a61af66fc99e Initial load duke parents: diff changeset	623
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	624 static void purge_previous_versions(InstanceKlass* ik);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	625
0 a61af66fc99e Initial load duke parents: diff changeset	626 // JVMTI: Support for caching a class file before it is modified by an agent that can do retransformation
a61af66fc99e Initial load duke parents: diff changeset	627 void set_cached_class_file(unsigned char *class_file_bytes,
a61af66fc99e Initial load duke parents: diff changeset	628 jint class_file_len) { _cached_class_file_len = class_file_len;
a61af66fc99e Initial load duke parents: diff changeset	629 _cached_class_file_bytes = class_file_bytes; }
a61af66fc99e Initial load duke parents: diff changeset	630 jint get_cached_class_file_len() { return _cached_class_file_len; }
a61af66fc99e Initial load duke parents: diff changeset	631 unsigned char * get_cached_class_file_bytes() { return _cached_class_file_bytes; }
a61af66fc99e Initial load duke parents: diff changeset	632
a61af66fc99e Initial load duke parents: diff changeset	633 // JVMTI: Support for caching of field indices, types, and offsets
a61af66fc99e Initial load duke parents: diff changeset	634 void set_jvmti_cached_class_field_map(JvmtiCachedClassFieldMap* descriptor) {
a61af66fc99e Initial load duke parents: diff changeset	635 _jvmti_cached_class_field_map = descriptor;
a61af66fc99e Initial load duke parents: diff changeset	636 }
a61af66fc99e Initial load duke parents: diff changeset	637 JvmtiCachedClassFieldMap* jvmti_cached_class_field_map() const {
a61af66fc99e Initial load duke parents: diff changeset	638 return _jvmti_cached_class_field_map;
a61af66fc99e Initial load duke parents: diff changeset	639 }
a61af66fc99e Initial load duke parents: diff changeset	640
7593 337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	641 bool has_default_methods() const {
337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	642 return (_misc_flags & _misc_has_default_methods) != 0;
337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	643 }
337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	644 void set_has_default_methods(bool b) {
337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	645 if (b) {
337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	646 _misc_flags \|= _misc_has_default_methods;
337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	647 } else {
337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	648 _misc_flags &= ~_misc_has_default_methods;
337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	649 }
337e1dd9d902 8005895: Inefficient InstanceKlass field packing wasts memory. jiangli parents: 7465 diff changeset	650 }
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	651
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	652 // for adding methods, ConstMethod::UNSET_IDNUM means no more ids available
0 a61af66fc99e Initial load duke parents: diff changeset	653 inline u2 next_method_idnum();
a61af66fc99e Initial load duke parents: diff changeset	654 void set_initial_method_idnum(u2 value) { _idnum_allocated_count = value; }
a61af66fc99e Initial load duke parents: diff changeset	655
a61af66fc99e Initial load duke parents: diff changeset	656 // generics support
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	657 Symbol* generic_signature() const { return _generic_signature; }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	658 void set_generic_signature(Symbol* sig) { _generic_signature = sig; }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	659
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	660 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	661 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	662 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	663 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	664 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	665 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	666 }
0 a61af66fc99e Initial load duke parents: diff changeset	667 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	668 u2 method_index);
0 a61af66fc99e Initial load duke parents: diff changeset	669
a61af66fc99e Initial load duke parents: diff changeset	670 // jmethodID support
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	671 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	672 methodHandle method_h);
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	673 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	674 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	675 jmethodID* to_dealloc_id_p,
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	676 jmethodID** to_dealloc_jmeths_p);
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	677 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	678 size_t length_p, jmethodID id_p);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	679 jmethodID jmethod_id_or_null(Method* method);
0 a61af66fc99e Initial load duke parents: diff changeset	680
a61af66fc99e Initial load duke parents: diff changeset	681 // cached itable index support
a61af66fc99e Initial load duke parents: diff changeset	682 void set_cached_itable_index(size_t idnum, int index);
a61af66fc99e Initial load duke parents: diff changeset	683 int cached_itable_index(size_t idnum);
a61af66fc99e Initial load duke parents: diff changeset	684
a61af66fc99e Initial load duke parents: diff changeset	685 // annotations support
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	686 Annotations* annotations() const { return _annotations; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	687 void set_annotations(Annotations* anno) { _annotations = anno; }
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	688
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	689 AnnotationArray* class_annotations() const {
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	690 return (_annotations != NULL) ? _annotations->class_annotations() : NULL;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	691 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	692 Array<AnnotationArray> fields_annotations() const {
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	693 return (_annotations != NULL) ? _annotations->fields_annotations() : NULL;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	694 }
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	695 AnnotationArray* class_type_annotations() const {
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	696 return (_annotations != NULL) ? _annotations->class_type_annotations() : NULL;
7457 35431a769282 8004823: Add VM support for type annotation reflection stefank parents: 7409 diff changeset	697 }
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	698 Array<AnnotationArray> fields_type_annotations() const {
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	699 return (_annotations != NULL) ? _annotations->fields_type_annotations() : NULL;
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	700 }
0 a61af66fc99e Initial load duke parents: diff changeset	701 // allocation
a61af66fc99e Initial load duke parents: diff changeset	702 instanceOop allocate_instance(TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	703
a61af66fc99e Initial load duke parents: diff changeset	704 // additional member function to return a handle
a61af66fc99e Initial load duke parents: diff changeset	705 instanceHandle allocate_instance_handle(TRAPS) { return instanceHandle(THREAD, allocate_instance(THREAD)); }
a61af66fc99e Initial load duke parents: diff changeset	706
a61af66fc99e Initial load duke parents: diff changeset	707 objArrayOop allocate_objArray(int n, int length, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	708 // Helper function
a61af66fc99e Initial load duke parents: diff changeset	709 static instanceOop register_finalizer(instanceOop i, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	710
a61af66fc99e Initial load duke parents: diff changeset	711 // Check whether reflection/jni/jvm code is allowed to instantiate this class;
a61af66fc99e Initial load duke parents: diff changeset	712 // if not, throw either an Error or an Exception.
a61af66fc99e Initial load duke parents: diff changeset	713 virtual void check_valid_for_instantiation(bool throwError, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	714
a61af66fc99e Initial load duke parents: diff changeset	715 // initialization
a61af66fc99e Initial load duke parents: diff changeset	716 void call_class_initializer(TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	717 void set_initialization_state_and_notify(ClassState state, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	718
a61af66fc99e Initial load duke parents: diff changeset	719 // OopMapCache support
a61af66fc99e Initial load duke parents: diff changeset	720 OopMapCache* oop_map_cache() { return _oop_map_cache; }
a61af66fc99e Initial load duke parents: diff changeset	721 void set_oop_map_cache(OopMapCache *cache) { _oop_map_cache = cache; }
a61af66fc99e Initial load duke parents: diff changeset	722 void mask_for(methodHandle method, int bci, InterpreterOopMap* entry);
a61af66fc99e Initial load duke parents: diff changeset	723
a61af66fc99e Initial load duke parents: diff changeset	724 // JNI identifier support (for static fields - for jni performance)
a61af66fc99e Initial load duke parents: diff changeset	725 JNIid* jni_ids() { return _jni_ids; }
a61af66fc99e Initial load duke parents: diff changeset	726 void set_jni_ids(JNIid* ids) { _jni_ids = ids; }
a61af66fc99e Initial load duke parents: diff changeset	727 JNIid* jni_id_for(int offset);
a61af66fc99e Initial load duke parents: diff changeset	728
a61af66fc99e Initial load duke parents: diff changeset	729 // maintenance of deoptimization dependencies
a61af66fc99e Initial load duke parents: diff changeset	730 int mark_dependent_nmethods(DepChange& changes);
a61af66fc99e Initial load duke parents: diff changeset	731 void add_dependent_nmethod(nmethod* nm);
a61af66fc99e Initial load duke parents: diff changeset	732 void remove_dependent_nmethod(nmethod* nm);
a61af66fc99e Initial load duke parents: diff changeset	733
a61af66fc99e Initial load duke parents: diff changeset	734 // On-stack replacement support
a61af66fc99e Initial load duke parents: diff changeset	735 nmethod* osr_nmethods_head() const { return _osr_nmethods_head; };
a61af66fc99e Initial load duke parents: diff changeset	736 void set_osr_nmethods_head(nmethod* h) { _osr_nmethods_head = h; };
a61af66fc99e Initial load duke parents: diff changeset	737 void add_osr_nmethod(nmethod* n);
a61af66fc99e Initial load duke parents: diff changeset	738 void remove_osr_nmethod(nmethod* n);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	739 nmethod* lookup_osr_nmethod(Method* const m, int bci, int level, bool match_level) const;
0 a61af66fc99e Initial load duke parents: diff changeset	740
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	741 // Breakpoint support (see methods on Method* for details)
0 a61af66fc99e Initial load duke parents: diff changeset	742 BreakpointInfo* breakpoints() const { return _breakpoints; };
a61af66fc99e Initial load duke parents: diff changeset	743 void set_breakpoints(BreakpointInfo* bps) { _breakpoints = bps; };
a61af66fc99e Initial load duke parents: diff changeset	744
a61af66fc99e Initial load duke parents: diff changeset	745 // support for stub routines
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	746 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	747 TRACE_DEFINE_OFFSET;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	748 static ByteSize init_thread_offset() { return in_ByteSize(offset_of(InstanceKlass, _init_thread)); }
0 a61af66fc99e Initial load duke parents: diff changeset	749
a61af66fc99e Initial load duke parents: diff changeset	750 // subclass/subinterface checks
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	751 bool implements_interface(Klass* k) const;
0 a61af66fc99e Initial load duke parents: diff changeset	752
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	753 // Access to the implementor of an interface.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	754 Klass* implementor() const
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	755 {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	756 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	757 if (k == NULL) {
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	758 return NULL;
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	759 } else {
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	760 return *k;
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	761 }
0 a61af66fc99e Initial load duke parents: diff changeset	762 }
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	763
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	764 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	765 assert(is_interface(), "not interface");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	766 Klass** addr = adr_implementor();
8693 872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	767 assert(addr != NULL, "null addr");
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	768 if (addr != NULL) {
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	769 *addr = k;
872b3feace55 8008750: [partfait] Null pointer deference in hotspot/src/share/vm/oops/instanceKlass.hpp morris parents: 8031 diff changeset	770 }
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	771 }
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	772
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	773 int nof_implementors() const {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	774 Klass* k = implementor();
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	775 if (k == NULL) {
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	776 return 0;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	777 } 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	778 return 1;
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	779 } else {
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	780 return 2;
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	781 }
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	782 }
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	783
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	784 void add_implementor(Klass* k); // k is a new class that implements this interface
0 a61af66fc99e Initial load duke parents: diff changeset	785 void init_implementor(); // initialize
a61af66fc99e Initial load duke parents: diff changeset	786
a61af66fc99e Initial load duke parents: diff changeset	787 // link this class into the implementors list of every interface it implements
a61af66fc99e Initial load duke parents: diff changeset	788 void process_interfaces(Thread *thread);
a61af66fc99e Initial load duke parents: diff changeset	789
a61af66fc99e Initial load duke parents: diff changeset	790 // virtual operations from Klass
a61af66fc99e Initial load duke parents: diff changeset	791 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	792 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	793 bool compute_is_subtype_of(Klass* k);
0 a61af66fc99e Initial load duke parents: diff changeset	794 bool can_be_primary_super_slow() const;
a61af66fc99e Initial load duke parents: diff changeset	795 int oop_size(oop obj) const { return size_helper(); }
a61af66fc99e Initial load duke parents: diff changeset	796 bool oop_is_instance_slow() const { return true; }
a61af66fc99e Initial load duke parents: diff changeset	797
a61af66fc99e Initial load duke parents: diff changeset	798 // Iterators
a61af66fc99e Initial load duke parents: diff changeset	799 void do_local_static_fields(FieldClosure* cl);
a61af66fc99e Initial load duke parents: diff changeset	800 void do_nonstatic_fields(FieldClosure* cl); // including inherited fields
a61af66fc99e Initial load duke parents: diff changeset	801 void do_local_static_fields(void f(fieldDescriptor*, TRAPS), TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	802
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	803 void methods_do(void f(Method* method));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	804 void array_klasses_do(void f(Klass* k));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	805 void array_klasses_do(void f(Klass* k, TRAPS), TRAPS);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	806 void with_array_klasses_do(void f(Klass* k));
0 a61af66fc99e Initial load duke parents: diff changeset	807 bool super_types_do(SuperTypeClosure* blk);
a61af66fc99e Initial load duke parents: diff changeset	808
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	809 // Casting from Klass*
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	810 static InstanceKlass* cast(Klass* k) {
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	811 assert(k->is_klass(), "must be");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	812 assert(k->oop_is_instance(), "cast to InstanceKlass");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	813 return (InstanceKlass*) k;
0 a61af66fc99e Initial load duke parents: diff changeset	814 }
a61af66fc99e Initial load duke parents: diff changeset	815
6934 4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	816 InstanceKlass* java_super() const {
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	817 return (super() == NULL) ? NULL : cast(super());
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	818 }
4735d2c84362 7200776: Implement default methods in interfaces kamg parents: 6725 diff changeset	819
0 a61af66fc99e Initial load duke parents: diff changeset	820 // Sizing (in words)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	821 static int header_size() { return align_object_offset(sizeof(InstanceKlass)/HeapWordSize); }
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	822
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	823 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	824 int nonstatic_oop_map_size,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	825 bool is_interface, bool is_anonymous) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	826 return align_object_size(header_size() +
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	827 align_object_offset(vtable_length) +
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	828 align_object_offset(itable_length) +
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	829 ((is_interface \|\| is_anonymous) ?
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	830 align_object_offset(nonstatic_oop_map_size) :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	831 nonstatic_oop_map_size) +
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	832 (is_interface ? (int)sizeof(Klass*)/HeapWordSize : 0) +
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	833 (is_anonymous ? (int)sizeof(Klass*)/HeapWordSize : 0));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	834 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	835 int size() const { return size(vtable_length(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	836 itable_length(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	837 nonstatic_oop_map_size(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	838 is_interface(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	839 is_anonymous());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	840 }
7956 16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7596 diff changeset	841 #if INCLUDE_SERVICES
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7596 diff changeset	842 virtual void collect_statistics(KlassSizeStats *sz) const;
16fb9f942703 6479360: PrintClassHistogram improvements acorn parents: 7596 diff changeset	843 #endif
5998 49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	844
0 a61af66fc99e Initial load duke parents: diff changeset	845 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	846 static int vtable_length_offset() { return offset_of(InstanceKlass, _vtable_len) / HeapWordSize; }
0 a61af66fc99e Initial load duke parents: diff changeset	847
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	848 intptr_t* start_of_vtable() const { return ((intptr_t*)this) + vtable_start_offset(); }
0 a61af66fc99e Initial load duke parents: diff changeset	849 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	850 int itable_offset_in_words() const { return start_of_itable() - (intptr_t*)this; }
0 a61af66fc99e Initial load duke parents: diff changeset	851
a61af66fc99e Initial load duke parents: diff changeset	852 intptr_t* end_of_itable() const { return start_of_itable() + itable_length(); }
a61af66fc99e Initial load duke parents: diff changeset	853
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	854 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	855
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 49 diff changeset	856 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	857 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	858 }
0 a61af66fc99e Initial load duke parents: diff changeset	859
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	860 Klass** end_of_nonstatic_oop_maps() const {
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	861 return (Klass**)(start_of_nonstatic_oop_maps() +
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	862 nonstatic_oop_map_count());
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	863 }
927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	864
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	865 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	866 if (is_interface()) {
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	867 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	868 } else {
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	869 return NULL;
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	870 }
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	871 };
49036505ab5f 7154670: The instanceKlass _implementors[] and _nof_implementors are not needed for non-interface klass. jiangli parents: 5967 diff changeset	872
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	873 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	874 if (is_anonymous()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	875 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	876 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	877 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	878 } else {
8031 927a311d00f9 8007320: NPG: move method annotations coleenp parents: 8003 diff changeset	879 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	880 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	881 } else {
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	882 return NULL;
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	883 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	884 }
8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	885
0 a61af66fc99e Initial load duke parents: diff changeset	886 // Allocation profiling support
a61af66fc99e Initial load duke parents: diff changeset	887 juint alloc_size() const { return _alloc_count * size_helper(); }
a61af66fc99e Initial load duke parents: diff changeset	888 void set_alloc_size(juint n) {}
a61af66fc99e Initial load duke parents: diff changeset	889
a61af66fc99e Initial load duke parents: diff changeset	890 // Use this to return the size of an instance in heap words:
a61af66fc99e Initial load duke parents: diff changeset	891 int size_helper() const {
a61af66fc99e Initial load duke parents: diff changeset	892 return layout_helper_to_size_helper(layout_helper());
a61af66fc99e Initial load duke parents: diff changeset	893 }
a61af66fc99e Initial load duke parents: diff changeset	894
a61af66fc99e Initial load duke parents: diff changeset	895 // This bit is initialized in classFileParser.cpp.
a61af66fc99e Initial load duke parents: diff changeset	896 // It is false under any of the following conditions:
a61af66fc99e Initial load duke parents: diff changeset	897 // - the class is abstract (including any interface)
a61af66fc99e Initial load duke parents: diff changeset	898 // - the class has a finalizer (if !RegisterFinalizersAtInit)
a61af66fc99e Initial load duke parents: diff changeset	899 // - the class size is larger than FastAllocateSizeLimit
a61af66fc99e Initial load duke parents: diff changeset	900 // - the class is java/lang/Class, which cannot be allocated directly
a61af66fc99e Initial load duke parents: diff changeset	901 bool can_be_fastpath_allocated() const {
a61af66fc99e Initial load duke parents: diff changeset	902 return !layout_helper_needs_slow_path(layout_helper());
a61af66fc99e Initial load duke parents: diff changeset	903 }
a61af66fc99e Initial load duke parents: diff changeset	904
a61af66fc99e Initial load duke parents: diff changeset	905 // Java vtable/itable
a61af66fc99e Initial load duke parents: diff changeset	906 klassVtable* vtable() const; // return new klassVtable wrapper
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	907 inline Method* method_at_vtable(int index);
0 a61af66fc99e Initial load duke parents: diff changeset	908 klassItable* itable() const; // return new klassItable wrapper
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	909 Method* method_at_itable(Klass* holder, int index, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	910
a61af66fc99e Initial load duke parents: diff changeset	911 // Garbage collection
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	912 virtual void oops_do(OopClosure* cl);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	913
0 a61af66fc99e Initial load duke parents: diff changeset	914 void oop_follow_contents(oop obj);
a61af66fc99e Initial load duke parents: diff changeset	915 int oop_adjust_pointers(oop obj);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	916
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	917 void clean_implementors_list(BoolObjectClosure* is_alive);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	918 void clean_method_data(BoolObjectClosure* is_alive);
0 a61af66fc99e Initial load duke parents: diff changeset	919
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	920 // Explicit metaspace deallocation of fields
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	921 // 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	922 // instanceKlasses and the metadata they point to.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	923 void deallocate_contents(ClassLoaderData* loader_data);
8719 c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	924 static void deallocate_methods(ClassLoaderData* loader_data,
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	925 Array<Method> methods);
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	926 void static deallocate_interfaces(ClassLoaderData* loader_data,
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	927 Klass* super_klass,
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	928 Array<Klass> local_interfaces,
c8b31b461e1a 8003419: NPG: Clean up metadata created during class loading if failure coleenp parents: 8714 diff changeset	929 Array<Klass> transitive_interfaces);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	930
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	931 // 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	932 // referenced by handles.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	933 bool on_stack() const { return _constants->on_stack(); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	934
0 a61af66fc99e Initial load duke parents: diff changeset	935 void release_C_heap_structures();
a61af66fc99e Initial load duke parents: diff changeset	936
a61af66fc99e Initial load duke parents: diff changeset	937 // Parallel Scavenge and Parallel Old
a61af66fc99e Initial load duke parents: diff changeset	938 PARALLEL_GC_DECLS
a61af66fc99e Initial load duke parents: diff changeset	939
a61af66fc99e Initial load duke parents: diff changeset	940 // Naming
1039 987e948ebbc8 6815692: method handle code needs some cleanup (post-6655638) jrose parents: 977 diff changeset	941 const char* signature_name() const;
0 a61af66fc99e Initial load duke parents: diff changeset	942
a61af66fc99e Initial load duke parents: diff changeset	943 // Iterators
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	944 int oop_oop_iterate(oop obj, ExtendedOopClosure* blk) {
0 a61af66fc99e Initial load duke parents: diff changeset	945 return oop_oop_iterate_v(obj, blk);
a61af66fc99e Initial load duke parents: diff changeset	946 }
a61af66fc99e Initial load duke parents: diff changeset	947
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	948 int oop_oop_iterate_m(oop obj, ExtendedOopClosure* blk, MemRegion mr) {
0 a61af66fc99e Initial load duke parents: diff changeset	949 return oop_oop_iterate_v_m(obj, blk, mr);
a61af66fc99e Initial load duke parents: diff changeset	950 }
a61af66fc99e Initial load duke parents: diff changeset	951
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	952 #define InstanceKlass_OOP_OOP_ITERATE_DECL(OopClosureType, nv_suffix) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	953 int oop_oop_iterate##nv_suffix(oop obj, OopClosureType* blk); \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	954 int oop_oop_iterate##nv_suffix##_m(oop obj, OopClosureType* blk, \
0 a61af66fc99e Initial load duke parents: diff changeset	955 MemRegion mr);
a61af66fc99e Initial load duke parents: diff changeset	956
a61af66fc99e Initial load duke parents: diff changeset	957 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	958 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	959
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 7596 diff changeset	960 #if INCLUDE_ALL_GCS
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	961 #define InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	962 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	963
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 113 diff changeset	964 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	965 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	966 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	967
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	968 u2 idnum_allocated_count() const { return _idnum_allocated_count; }
0 a61af66fc99e Initial load duke parents: diff changeset	969 private:
a61af66fc99e Initial load duke parents: diff changeset	970 // initialization state
a61af66fc99e Initial load duke parents: diff changeset	971 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	972 void set_init_state(ClassState state);
a61af66fc99e Initial load duke parents: diff changeset	973 #else
4739 52b5d32fbfaf 7117052: instanceKlass::_init_state can be u1 type coleenp parents: 4737 diff changeset	974 void set_init_state(ClassState state) { _init_state = (u1)state; }
0 a61af66fc99e Initial load duke parents: diff changeset	975 #endif
6038 8bafad97cd26 7158552: The instanceKlsss::_host_klass is only needed for anonymous class for JSR 292 support. jiangli parents: 6006 diff changeset	976 void set_rewritten() { _misc_flags \|= _misc_rewritten; }
0 a61af66fc99e Initial load duke parents: diff changeset	977 void set_init_thread(Thread *thread) { _init_thread = thread; }
a61af66fc99e Initial load duke parents: diff changeset	978
977 74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	979 // 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	980 // 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	981 // 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	982 // going from NULL to non-NULL.
74a5db69c1fe 6419370: 4/4 new jmethodID code has tiny holes in synchronization dcubed parents: 975 diff changeset	983 bool idnum_can_increment() const { return has_been_redefined(); }
0 a61af66fc99e Initial load duke parents: diff changeset	984 jmethodID* methods_jmethod_ids_acquire() const
a61af66fc99e Initial load duke parents: diff changeset	985 { return (jmethodID*)OrderAccess::load_ptr_acquire(&_methods_jmethod_ids); }
a61af66fc99e Initial load duke parents: diff changeset	986 void release_set_methods_jmethod_ids(jmethodID* jmeths)
a61af66fc99e Initial load duke parents: diff changeset	987 { OrderAccess::release_store_ptr(&_methods_jmethod_ids, jmeths); }
a61af66fc99e Initial load duke parents: diff changeset	988
a61af66fc99e Initial load duke parents: diff changeset	989 int* methods_cached_itable_indices_acquire() const
a61af66fc99e Initial load duke parents: diff changeset	990 { return (int*)OrderAccess::load_ptr_acquire(&_methods_cached_itable_indices); }
a61af66fc99e Initial load duke parents: diff changeset	991 void release_set_methods_cached_itable_indices(int* indices)
a61af66fc99e Initial load duke parents: diff changeset	992 { OrderAccess::release_store_ptr(&_methods_cached_itable_indices, indices); }
a61af66fc99e Initial load duke parents: diff changeset	993
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	994 // Lock during initialization
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	995 volatile oop init_lock() const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	996 void set_init_lock(oop value) { klass_oop_store(&_init_lock, value); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	997 void fence_and_clear_init_lock(); // after fully_initialized
0 a61af66fc99e Initial load duke parents: diff changeset	998
a61af66fc99e Initial load duke parents: diff changeset	999 // Offsets for memory management
a61af66fc99e Initial load duke parents: diff changeset	1000 oop* adr_protection_domain() const { return (oop*)&this->_protection_domain;}
a61af66fc99e Initial load duke parents: diff changeset	1001 oop* adr_signers() const { return (oop*)&this->_signers;}
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1002 oop* adr_init_lock() const { return (oop*)&this->_init_lock;}
0 a61af66fc99e Initial load duke parents: diff changeset	1003
a61af66fc99e Initial load duke parents: diff changeset	1004 // Static methods that are used to implement member methods where an exposed this pointer
a61af66fc99e Initial load duke parents: diff changeset	1005 // is needed due to possible GCs
a61af66fc99e Initial load duke parents: diff changeset	1006 static bool link_class_impl (instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	1007 static bool verify_code (instanceKlassHandle this_oop, bool throw_verifyerror, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	1008 static void initialize_impl (instanceKlassHandle this_oop, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	1009 static void eager_initialize_impl (instanceKlassHandle this_oop);
a61af66fc99e Initial load duke parents: diff changeset	1010 static void set_initialization_state_and_notify_impl (instanceKlassHandle this_oop, ClassState state, TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	1011 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	1012 static Klass* array_klass_impl (instanceKlassHandle this_oop, bool or_null, int n, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	1013 static void do_local_static_fields_impl (instanceKlassHandle this_oop, void f(fieldDescriptor* fd, TRAPS), TRAPS);
a61af66fc99e Initial load duke parents: diff changeset	1014 /* jni_id_for_impl for jfieldID only */
a61af66fc99e Initial load duke parents: diff changeset	1015 static JNIid* jni_id_for_impl (instanceKlassHandle this_oop, int offset);
a61af66fc99e Initial load duke parents: diff changeset	1016
a61af66fc99e Initial load duke parents: diff changeset	1017 // 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	1018 Klass* array_klass_impl(bool or_null, int n, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	1019
a61af66fc99e Initial load duke parents: diff changeset	1020 // 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	1021 Klass* array_klass_impl(bool or_null, TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	1022
a61af66fc99e Initial load duke parents: diff changeset	1023 public:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1024 // CDS support - remove and restore oops from metadata. Oops are not shared.
0 a61af66fc99e Initial load duke parents: diff changeset	1025 virtual void remove_unshareable_info();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1026 virtual void restore_unshareable_info(TRAPS);
0 a61af66fc99e Initial load duke parents: diff changeset	1027
a61af66fc99e Initial load duke parents: diff changeset	1028 // jvm support
a61af66fc99e Initial load duke parents: diff changeset	1029 jint compute_modifier_flags(TRAPS) const;
a61af66fc99e Initial load duke parents: diff changeset	1030
a61af66fc99e Initial load duke parents: diff changeset	1031 public:
a61af66fc99e Initial load duke parents: diff changeset	1032 // JVMTI support
a61af66fc99e Initial load duke parents: diff changeset	1033 jint jvmti_class_status() const;
a61af66fc99e Initial load duke parents: diff changeset	1034
a61af66fc99e Initial load duke parents: diff changeset	1035 public:
a61af66fc99e Initial load duke parents: diff changeset	1036 // Printing
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1037 #ifndef PRODUCT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1038 void print_on(outputStream* st) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1039 #endif
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1040 void print_value_on(outputStream* st) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1041
1155 4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1126 diff changeset	1042 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	1043
1155 4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1126 diff changeset	1044 #ifndef PRODUCT
0 a61af66fc99e Initial load duke parents: diff changeset	1045 void oop_print_on (oop obj, outputStream* st);
a61af66fc99e Initial load duke parents: diff changeset	1046
a61af66fc99e Initial load duke parents: diff changeset	1047 void print_dependent_nmethods(bool verbose = false);
a61af66fc99e Initial load duke parents: diff changeset	1048 bool is_dependent_nmethod(nmethod* nm);
a61af66fc99e Initial load duke parents: diff changeset	1049 #endif
a61af66fc99e Initial load duke parents: diff changeset	1050
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1051 const char* internal_name() const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1052
0 a61af66fc99e Initial load duke parents: diff changeset	1053 // Verification
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1054 void verify_on(outputStream* st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1055
0 a61af66fc99e Initial load duke parents: diff changeset	1056 void oop_verify_on(oop obj, outputStream* st);
a61af66fc99e Initial load duke parents: diff changeset	1057 };
a61af66fc99e Initial load duke parents: diff changeset	1058
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1059 inline Method* InstanceKlass::method_at_vtable(int index) {
0 a61af66fc99e Initial load duke parents: diff changeset	1060 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	1061 assert(index >= 0, "valid vtable index");
a61af66fc99e Initial load duke parents: diff changeset	1062 if (DebugVtables) {
a61af66fc99e Initial load duke parents: diff changeset	1063 verify_vtable_index(index);
a61af66fc99e Initial load duke parents: diff changeset	1064 }
a61af66fc99e Initial load duke parents: diff changeset	1065 #endif
a61af66fc99e Initial load duke parents: diff changeset	1066 vtableEntry* ve = (vtableEntry*)start_of_vtable();
a61af66fc99e Initial load duke parents: diff changeset	1067 return ve[index].method();
a61af66fc99e Initial load duke parents: diff changeset	1068 }
a61af66fc99e Initial load duke parents: diff changeset	1069
a61af66fc99e Initial load duke parents: diff changeset	1070 // for adding methods
a61af66fc99e Initial load duke parents: diff changeset	1071 // 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	1072 inline u2 InstanceKlass::next_method_idnum() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1073 if (_idnum_allocated_count == ConstMethod::MAX_IDNUM) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1074 return ConstMethod::UNSET_IDNUM; // no more ids available
0 a61af66fc99e Initial load duke parents: diff changeset	1075 } else {
a61af66fc99e Initial load duke parents: diff changeset	1076 return _idnum_allocated_count++;
a61af66fc99e Initial load duke parents: diff changeset	1077 }
a61af66fc99e Initial load duke parents: diff changeset	1078 }
a61af66fc99e Initial load duke parents: diff changeset	1079
a61af66fc99e Initial load duke parents: diff changeset	1080
a61af66fc99e Initial load duke parents: diff changeset	1081 /* JNIid class for jfieldIDs only */
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6100 diff changeset	1082 class JNIid: public CHeapObj<mtClass> {
0 a61af66fc99e Initial load duke parents: diff changeset	1083 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	1084 private:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1085 Klass* _holder;
0 a61af66fc99e Initial load duke parents: diff changeset	1086 JNIid* _next;
a61af66fc99e Initial load duke parents: diff changeset	1087 int _offset;
a61af66fc99e Initial load duke parents: diff changeset	1088 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	1089 bool _is_static_field_id;
a61af66fc99e Initial load duke parents: diff changeset	1090 #endif
a61af66fc99e Initial load duke parents: diff changeset	1091
a61af66fc99e Initial load duke parents: diff changeset	1092 public:
a61af66fc99e Initial load duke parents: diff changeset	1093 // Accessors
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1094 Klass* holder() const { return _holder; }
0 a61af66fc99e Initial load duke parents: diff changeset	1095 int offset() const { return _offset; }
a61af66fc99e Initial load duke parents: diff changeset	1096 JNIid* next() { return _next; }
a61af66fc99e Initial load duke parents: diff changeset	1097 // Constructor
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1098 JNIid(Klass* holder, int offset, JNIid* next);
0 a61af66fc99e Initial load duke parents: diff changeset	1099 // Identifier lookup
a61af66fc99e Initial load duke parents: diff changeset	1100 JNIid* find(int offset);
a61af66fc99e Initial load duke parents: diff changeset	1101
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	1102 bool find_local_field(fieldDescriptor* fd) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1103 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	1104 }
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2357 diff changeset	1105
0 a61af66fc99e Initial load duke parents: diff changeset	1106 static void deallocate(JNIid* id);
a61af66fc99e Initial load duke parents: diff changeset	1107 // Debugging
a61af66fc99e Initial load duke parents: diff changeset	1108 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	1109 bool is_static_field_id() const { return _is_static_field_id; }
a61af66fc99e Initial load duke parents: diff changeset	1110 void set_is_static_field_id() { _is_static_field_id = true; }
a61af66fc99e Initial load duke parents: diff changeset	1111 #endif
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1112 void verify(Klass* holder);
0 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 // If breakpoints are more numerous than just JVMTI breakpoints,
a61af66fc99e Initial load duke parents: diff changeset	1117 // consider compressing this data structure.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1118 // It is currently a simple linked list defined in method.hpp.
0 a61af66fc99e Initial load duke parents: diff changeset	1119
a61af66fc99e Initial load duke parents: diff changeset	1120 class BreakpointInfo;
a61af66fc99e Initial load duke parents: diff changeset	1121
a61af66fc99e Initial load duke parents: diff changeset	1122
a61af66fc99e Initial load duke parents: diff changeset	1123 // A collection point for interesting information about the previous
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1124 // version(s) of an InstanceKlass. This class uses weak references to
0 a61af66fc99e Initial load duke parents: diff changeset	1125 // the information so that the information may be collected as needed
47 2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash dcubed parents: 0 diff changeset	1126 // by the system. If the information is shared, then a regular
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash dcubed parents: 0 diff changeset	1127 // reference must be used because a weak reference would be seen as
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash dcubed parents: 0 diff changeset	1128 // collectible. A GrowableArray of PreviousVersionNodes is attached
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1129 // to the InstanceKlass as needed. See PreviousVersionWalker below.
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6100 diff changeset	1130 class PreviousVersionNode : public CHeapObj<mtClass> {
0 a61af66fc99e Initial load duke parents: diff changeset	1131 private:
47 2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash dcubed parents: 0 diff changeset	1132 // A shared ConstantPool is never collected so we'll always have
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash dcubed parents: 0 diff changeset	1133 // a reference to it so we can update items in the cache. We'll
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash dcubed parents: 0 diff changeset	1134 // have a weak reference to a non-shared ConstantPool until all
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash dcubed parents: 0 diff changeset	1135 // of the methods (EMCP or obsolete) have been collected; the
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash dcubed parents: 0 diff changeset	1136 // non-shared ConstantPool becomes collectible at that point.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1137 ConstantPool* _prev_constant_pool; // regular or weak reference
47 2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash dcubed parents: 0 diff changeset	1138 bool _prev_cp_is_weak; // true if not a shared ConstantPool
2c106685d6d0 6497639: 4/3 Profiling Swing application caused JVM crash dcubed parents: 0 diff changeset	1139
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1140 // If the previous version of the InstanceKlass doesn't have any
0 a61af66fc99e Initial load duke parents: diff changeset	1141 // EMCP methods, then _prev_EMCP_methods will be NULL. If all the
a61af66fc99e Initial load duke parents: diff changeset	1142 // EMCP methods have been collected, then _prev_EMCP_methods can
a61af66fc99e Initial load duke parents: diff changeset	1143 // have a length of zero.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1144 GrowableArray<Method> _prev_EMCP_methods;
0 a61af66fc99e Initial load duke parents: diff changeset	1145
a61af66fc99e Initial load duke parents: diff changeset	1146 public:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1147 PreviousVersionNode(ConstantPool* prev_constant_pool, bool prev_cp_is_weak,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1148 GrowableArray<Method> prev_EMCP_methods);
0 a61af66fc99e Initial load duke parents: diff changeset	1149 ~PreviousVersionNode();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1150 ConstantPool* prev_constant_pool() const {
0 a61af66fc99e Initial load duke parents: diff changeset	1151 return _prev_constant_pool;
a61af66fc99e Initial load duke parents: diff changeset	1152 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1153 GrowableArray<Method> prev_EMCP_methods() const {
0 a61af66fc99e Initial load duke parents: diff changeset	1154 return _prev_EMCP_methods;
a61af66fc99e Initial load duke parents: diff changeset	1155 }
a61af66fc99e Initial load duke parents: diff changeset	1156 };
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 Handle-ized version of PreviousVersionNode.
a61af66fc99e Initial load duke parents: diff changeset	1160 class PreviousVersionInfo : public ResourceObj {
a61af66fc99e Initial load duke parents: diff changeset	1161 private:
a61af66fc99e Initial load duke parents: diff changeset	1162 constantPoolHandle _prev_constant_pool_handle;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1163 // If the previous version of the InstanceKlass doesn't have any
0 a61af66fc99e Initial load duke parents: diff changeset	1164 // EMCP methods, then _prev_EMCP_methods will be NULL. Since the
a61af66fc99e Initial load duke parents: diff changeset	1165 // methods cannot be collected while we hold a handle,
a61af66fc99e Initial load duke parents: diff changeset	1166 // _prev_EMCP_methods should never have a length of zero.
a61af66fc99e Initial load duke parents: diff changeset	1167 GrowableArray<methodHandle>* _prev_EMCP_method_handles;
a61af66fc99e Initial load duke parents: diff changeset	1168
a61af66fc99e Initial load duke parents: diff changeset	1169 public:
a61af66fc99e Initial load duke parents: diff changeset	1170 PreviousVersionInfo(PreviousVersionNode *pv_node);
a61af66fc99e Initial load duke parents: diff changeset	1171 ~PreviousVersionInfo();
a61af66fc99e Initial load duke parents: diff changeset	1172 constantPoolHandle prev_constant_pool_handle() const {
a61af66fc99e Initial load duke parents: diff changeset	1173 return _prev_constant_pool_handle;
a61af66fc99e Initial load duke parents: diff changeset	1174 }
a61af66fc99e Initial load duke parents: diff changeset	1175 GrowableArray<methodHandle>* prev_EMCP_method_handles() const {
a61af66fc99e Initial load duke parents: diff changeset	1176 return _prev_EMCP_method_handles;
a61af66fc99e Initial load duke parents: diff changeset	1177 }
a61af66fc99e Initial load duke parents: diff changeset	1178 };
a61af66fc99e Initial load duke parents: diff changeset	1179
a61af66fc99e Initial load duke parents: diff changeset	1180
a61af66fc99e Initial load duke parents: diff changeset	1181 // Helper object for walking previous versions. This helper cleans up
a61af66fc99e Initial load duke parents: diff changeset	1182 // the Handles that it allocates when the helper object is destroyed.
a61af66fc99e Initial load duke parents: diff changeset	1183 // The PreviousVersionInfo object returned by next_previous_version()
a61af66fc99e Initial load duke parents: diff changeset	1184 // is only valid until a subsequent call to next_previous_version() or
a61af66fc99e Initial load duke parents: diff changeset	1185 // the helper object is destroyed.
a61af66fc99e Initial load duke parents: diff changeset	1186 class PreviousVersionWalker : public StackObj {
a61af66fc99e Initial load duke parents: diff changeset	1187 private:
a61af66fc99e Initial load duke parents: diff changeset	1188 GrowableArray<PreviousVersionNode > _previous_versions;
a61af66fc99e Initial load duke parents: diff changeset	1189 int _current_index;
a61af66fc99e Initial load duke parents: diff changeset	1190 // Fields for cleaning up when we are done walking the previous versions:
a61af66fc99e Initial load duke parents: diff changeset	1191 // A HandleMark for the PreviousVersionInfo handles:
a61af66fc99e Initial load duke parents: diff changeset	1192 HandleMark _hm;
a61af66fc99e Initial load duke parents: diff changeset	1193
a61af66fc99e Initial load duke parents: diff changeset	1194 // It would be nice to have a ResourceMark field in this helper also,
a61af66fc99e Initial load duke parents: diff changeset	1195 // but the ResourceMark code says to be careful to delete handles held
a61af66fc99e Initial load duke parents: diff changeset	1196 // in GrowableArrays _before_ deleting the GrowableArray. Since we
a61af66fc99e Initial load duke parents: diff changeset	1197 // can't guarantee the order in which the fields are destroyed, we
a61af66fc99e Initial load duke parents: diff changeset	1198 // have to let the creator of the PreviousVersionWalker object do
a61af66fc99e Initial load duke parents: diff changeset	1199 // the right thing. Also, adding a ResourceMark here causes an
a61af66fc99e Initial load duke parents: diff changeset	1200 // include loop.
a61af66fc99e Initial load duke parents: diff changeset	1201
a61af66fc99e Initial load duke parents: diff changeset	1202 // A pointer to the current info object so we can handle the deletes.
a61af66fc99e Initial load duke parents: diff changeset	1203 PreviousVersionInfo * _current_p;
a61af66fc99e Initial load duke parents: diff changeset	1204
a61af66fc99e Initial load duke parents: diff changeset	1205 public:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1206 PreviousVersionWalker(InstanceKlass *ik);
0 a61af66fc99e Initial load duke parents: diff changeset	1207 ~PreviousVersionWalker();
a61af66fc99e Initial load duke parents: diff changeset	1208
a61af66fc99e Initial load duke parents: diff changeset	1209 // Return the interesting information for the next previous version
a61af66fc99e Initial load duke parents: diff changeset	1210 // of the klass. Returns NULL if there are no more previous versions.
a61af66fc99e Initial load duke parents: diff changeset	1211 PreviousVersionInfo* next_previous_version();
a61af66fc99e Initial load duke parents: diff changeset	1212 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	1213
3939 f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1214
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1215 //
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1216 // nmethodBucket is used to record dependent nmethods for
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1217 // deoptimization. nmethod dependencies are actually <klass, method>
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1218 // 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	1219 // finding nmethods which might need to be deoptimized. Instead of
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1220 // 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	1221 // 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	1222 // 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	1223 // added.
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1224 //
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 6100 diff changeset	1225 class nmethodBucket: public CHeapObj<mtClass> {
3939 f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1226 friend class VMStructs;
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1227 private:
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1228 nmethod* _nmethod;
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1229 int _count;
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1230 nmethodBucket* _next;
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1231
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1232 public:
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1233 nmethodBucket(nmethod* nmethod, nmethodBucket* next) {
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1234 _nmethod = nmethod;
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1235 _next = next;
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1236 _count = 1;
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 int count() { return _count; }
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1239 int increment() { _count += 1; return _count; }
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1240 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	1241 nmethodBucket* next() { return _next; }
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1242 void set_next(nmethodBucket* b) { _next = b; }
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1243 nmethod* get_nmethod() { return _nmethod; }
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1244 };
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3938 diff changeset	1245
5967 f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1246 // 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	1247 // 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	1248 class InnerClassesIterator : public StackObj {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1249 private:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1250 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	1251 int _length;
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1252 int _idx;
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1253 public:
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1254
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1255 InnerClassesIterator(instanceKlassHandle k) {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1256 _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	1257 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	1258 _length = _inner_classes->length();
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1259 // 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	1260 // 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	1261 // 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	1262 // 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	1263 // if it also contains the EnclosingMethod data.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1264 assert((_length % InstanceKlass::inner_class_next_offset == 0 \|\|
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1265 _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	1266 "just checking");
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1267 // Remove the enclosing_method portion if exists.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1268 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	1269 _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	1270 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1271 } else {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1272 _length = 0;
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 _idx = 0;
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1275 }
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 int length() const {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1278 return _length;
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1279 }
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 void next() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1282 _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	1283 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1284
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1285 bool done() const {
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1286 return (_idx >= _length);
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1287 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1288
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1289 u2 inner_class_info_index() const {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1290 return _inner_classes->at(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1291 _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	1292 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1293
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1294 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	1295 _inner_classes->at_put(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1296 _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	1297 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1298
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1299 u2 outer_class_info_index() const {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1300 return _inner_classes->at(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1301 _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	1302 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1303
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1304 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	1305 _inner_classes->at_put(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1306 _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	1307 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1308
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1309 u2 inner_name_index() const {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1310 return _inner_classes->at(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1311 _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	1312 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1313
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1314 void set_inner_name_index(u2 index) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1315 _inner_classes->at_put(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1316 _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	1317 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1318
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1319 u2 inner_access_flags() const {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1320 return _inner_classes->at(
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6203 diff changeset	1321 _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	1322 }
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1323 };
f7c4174b33ba 7109878: The instanceKlass EnclosingMethhod attribute fields can be folded into the _inner_class field. jiangli parents: 4901 diff changeset	1324
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	1325 #endif // SHARE_VM_OOPS_INSTANCEKLASS_HPP

Mercurial > hg > graal-compiler

annotate src/share/vm/oops/instanceKlass.hpp @ 10185:d50cc62e94ff