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

annotate src/share/vm/oops/instanceKlass.hpp @ 6972:bd7a7ce2e264

6830717: replay of compilations would help with debugging Summary: When java process crashed in compiler thread, repeat the compilation process will help finding root cause. This is done with using SA dump application class data and replay data from core dump, then use debug version of jvm to recompile the problematic java method. Reviewed-by: kvn, twisti, sspitsyn Contributed-by: yumin.qi@oracle.com

author	minqi
date	Mon, 12 Nov 2012 14:03:53 -0800
parents	4735d2c84362
children	2cb439954abf 30866cd626b0 ecd24264898b

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

Mercurial > hg > graal-compiler

annotate src/share/vm/oops/instanceKlass.hpp @ 6972:bd7a7ce2e264