Mon, 12 Nov 2012 14:03:53 -0800
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
1 /*
2 * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 #ifndef SHARE_VM_CI_CIINSTANCEKLASS_HPP
26 #define SHARE_VM_CI_CIINSTANCEKLASS_HPP
28 #include "ci/ciConstantPoolCache.hpp"
29 #include "ci/ciFlags.hpp"
30 #include "ci/ciKlass.hpp"
31 #include "ci/ciSymbol.hpp"
33 // ciInstanceKlass
34 //
35 // This class represents a Klass* in the HotSpot virtual machine
36 // whose Klass part is an InstanceKlass. It may or may not
37 // be loaded.
38 class ciInstanceKlass : public ciKlass {
39 CI_PACKAGE_ACCESS
40 friend class ciBytecodeStream;
41 friend class ciEnv;
42 friend class ciExceptionHandler;
43 friend class ciMethod;
44 friend class ciField;
46 private:
47 jobject _loader;
48 jobject _protection_domain;
50 InstanceKlass::ClassState _init_state; // state of class
51 bool _is_shared;
52 bool _has_finalizer;
53 bool _has_subklass;
54 bool _has_nonstatic_fields;
56 ciFlags _flags;
57 jint _nonstatic_field_size;
58 jint _nonstatic_oop_map_size;
60 // Lazy fields get filled in only upon request.
61 ciInstanceKlass* _super;
62 ciInstance* _java_mirror;
64 ciConstantPoolCache* _field_cache; // cached map index->field
65 GrowableArray<ciField*>* _nonstatic_fields;
67 // The possible values of the _implementor fall into following three cases:
68 // NULL: no implementor.
69 // A ciInstanceKlass that's not itself: one implementor.
70 // Itsef: more than one implementors.
71 ciInstanceKlass* _implementor;
73 GrowableArray<ciField*>* _non_static_fields;
75 protected:
76 ciInstanceKlass(KlassHandle h_k);
77 ciInstanceKlass(ciSymbol* name, jobject loader, jobject protection_domain);
79 InstanceKlass* get_instanceKlass() const {
80 return (InstanceKlass*)get_Klass();
81 }
83 oop loader();
84 jobject loader_handle();
86 oop protection_domain();
87 jobject protection_domain_handle();
89 const char* type_string() { return "ciInstanceKlass"; }
91 bool is_in_package_impl(const char* packagename, int len);
93 void print_impl(outputStream* st);
95 ciConstantPoolCache* field_cache();
97 bool is_shared() { return _is_shared; }
99 void compute_shared_init_state();
100 bool compute_shared_has_subklass();
101 int compute_nonstatic_fields();
102 GrowableArray<ciField*>* compute_nonstatic_fields_impl(GrowableArray<ciField*>* super_fields);
104 // Update the init_state for shared klasses
105 void update_if_shared(InstanceKlass::ClassState expected) {
106 if (_is_shared && _init_state != expected) {
107 if (is_loaded()) compute_shared_init_state();
108 }
109 }
111 public:
112 // Has this klass been initialized?
113 bool is_initialized() {
114 update_if_shared(InstanceKlass::fully_initialized);
115 return _init_state == InstanceKlass::fully_initialized;
116 }
117 // Is this klass being initialized?
118 bool is_being_initialized() {
119 update_if_shared(InstanceKlass::being_initialized);
120 return _init_state == InstanceKlass::being_initialized;
121 }
122 // Has this klass been linked?
123 bool is_linked() {
124 update_if_shared(InstanceKlass::linked);
125 return _init_state >= InstanceKlass::linked;
126 }
128 // General klass information.
129 ciFlags flags() {
130 assert(is_loaded(), "must be loaded");
131 return _flags;
132 }
133 bool has_finalizer() {
134 assert(is_loaded(), "must be loaded");
135 return _has_finalizer; }
136 bool has_subklass() {
137 assert(is_loaded(), "must be loaded");
138 if (_is_shared && !_has_subklass) {
139 if (flags().is_final()) {
140 return false;
141 } else {
142 return compute_shared_has_subklass();
143 }
144 }
145 return _has_subklass;
146 }
147 jint size_helper() {
148 return (Klass::layout_helper_size_in_bytes(layout_helper())
149 >> LogHeapWordSize);
150 }
151 jint nonstatic_field_size() {
152 assert(is_loaded(), "must be loaded");
153 return _nonstatic_field_size; }
154 jint has_nonstatic_fields() {
155 assert(is_loaded(), "must be loaded");
156 return _has_nonstatic_fields; }
157 jint nonstatic_oop_map_size() {
158 assert(is_loaded(), "must be loaded");
159 return _nonstatic_oop_map_size; }
160 ciInstanceKlass* super();
161 jint nof_implementors() {
162 ciInstanceKlass* impl;
163 assert(is_loaded(), "must be loaded");
164 impl = implementor();
165 if (impl == NULL) {
166 return 0;
167 } else if (impl != this) {
168 return 1;
169 } else {
170 return 2;
171 }
172 }
174 ciInstanceKlass* get_canonical_holder(int offset);
175 ciField* get_field_by_offset(int field_offset, bool is_static);
176 ciField* get_field_by_name(ciSymbol* name, ciSymbol* signature, bool is_static);
178 GrowableArray<ciField*>* non_static_fields();
180 // total number of nonstatic fields (including inherited):
181 int nof_nonstatic_fields() {
182 if (_nonstatic_fields == NULL)
183 return compute_nonstatic_fields();
184 else
185 return _nonstatic_fields->length();
186 }
187 // nth nonstatic field (presented by ascending address)
188 ciField* nonstatic_field_at(int i) {
189 assert(_nonstatic_fields != NULL, "");
190 return _nonstatic_fields->at(i);
191 }
193 ciInstanceKlass* unique_concrete_subklass();
194 bool has_finalizable_subclass();
196 bool contains_field_offset(int offset) {
197 return instanceOopDesc::contains_field_offset(offset, nonstatic_field_size());
198 }
200 // Get the instance of java.lang.Class corresponding to
201 // this klass. This instance is used for locking of
202 // synchronized static methods of this klass.
203 ciInstance* java_mirror();
205 // Java access flags
206 bool is_public () { return flags().is_public(); }
207 bool is_final () { return flags().is_final(); }
208 bool is_super () { return flags().is_super(); }
209 bool is_interface () { return flags().is_interface(); }
210 bool is_abstract () { return flags().is_abstract(); }
212 ciMethod* find_method(ciSymbol* name, ciSymbol* signature);
213 // Note: To find a method from name and type strings, use ciSymbol::make,
214 // but consider adding to vmSymbols.hpp instead.
216 bool is_leaf_type();
217 ciInstanceKlass* implementor();
219 // Is the defining class loader of this class the default loader?
220 bool uses_default_loader();
222 bool is_java_lang_Object() const;
224 // Is this klass in the given package?
225 bool is_in_package(const char* packagename) {
226 return is_in_package(packagename, (int) strlen(packagename));
227 }
228 bool is_in_package(const char* packagename, int len);
230 // What kind of ciObject is this?
231 bool is_instance_klass() const { return true; }
232 bool is_java_klass() const { return true; }
234 // Dump the current state of this klass for compilation replay.
235 virtual void dump_replay_data(outputStream* out);
236 };
238 #endif // SHARE_VM_CI_CIINSTANCEKLASS_HPP