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_CIOBJECT_HPP
26 #define SHARE_VM_CI_CIOBJECT_HPP
28 #include "ci/ciBaseObject.hpp"
29 #include "ci/ciClassList.hpp"
30 #include "memory/allocation.hpp"
31 #include "runtime/handles.hpp"
32 #include "runtime/jniHandles.hpp"
34 // ciObject
35 //
36 // This class represents an oop in the HotSpot virtual machine.
37 // Its subclasses are structured in a hierarchy which mirrors
38 // an aggregate of the VM's oop and klass hierarchies (see
39 // oopHierarchy.hpp). Each instance of ciObject holds a handle
40 // to a corresponding oop on the VM side and provides routines
41 // for accessing the information in its oop. By using the ciObject
42 // hierarchy for accessing oops in the VM, the compiler ensures
43 // that it is safe with respect to garbage collection; that is,
44 // GC and compilation can proceed independently without
45 // interference.
46 //
47 // Within the VM, the oop and klass hierarchies are separate.
48 // The compiler interface does not preserve this separation --
49 // the distinction between `Klass*' and `Klass' are not
50 // reflected in the interface and instead the Klass hierarchy
51 // is directly modeled as the subclasses of ciKlass.
52 class ciObject : public ciBaseObject {
53 CI_PACKAGE_ACCESS
54 friend class ciEnv;
56 private:
57 // A JNI handle referring to an oop in the VM. This
58 // handle may, in a small set of cases, correctly be NULL.
59 jobject _handle;
60 ciKlass* _klass;
62 protected:
63 ciObject();
64 ciObject(oop o);
65 ciObject(Handle h);
66 ciObject(ciKlass* klass);
68 jobject handle() const { return _handle; }
69 // Get the VM oop that this object holds.
70 oop get_oop() const {
71 assert(_handle != NULL, "null oop");
72 return JNIHandles::resolve_non_null(_handle);
73 }
75 void init_flags_from(oop x);
77 // Virtual behavior of the print() method.
78 virtual void print_impl(outputStream* st) {}
80 virtual const char* type_string() { return "ciObject"; }
82 public:
83 // The klass of this ciObject.
84 ciKlass* klass();
86 // Are two ciObjects equal?
87 bool equals(ciObject* obj);
89 // A hash value for the convenience of compilers.
90 int hash();
92 // Tells if this oop has an encoding as a constant.
93 // True if is_perm is true.
94 // Also true if ScavengeRootsInCode is non-zero.
95 // If it does not have an encoding, the compiler is responsible for
96 // making other arrangements for dealing with the oop.
97 // See ciEnv::make_array
98 bool can_be_constant();
100 // Tells if this oop should be made a constant.
101 // True if is_perm is true or ScavengeRootsInCode > 1.
102 bool should_be_constant();
104 // Might this object possibly move during a scavenge operation?
105 // If the answer is true and ScavengeRootsInCode==0, the oop cannot be embedded in code.
106 bool is_scavengable() { return (_ident & SCAVENGABLE_FLAG) != 0; }
108 // The address which the compiler should embed into the
109 // generated code to represent this oop. This address
110 // is not the true address of the oop -- it will get patched
111 // during nmethod creation.
112 //
113 // Usage note: no address arithmetic allowed. Oop must
114 // be registered with the oopRecorder.
115 jobject constant_encoding();
117 virtual bool is_object() const { return true; }
119 // What kind of ciObject is this?
120 virtual bool is_null_object() const { return false; }
121 virtual bool is_call_site() const { return false; }
122 virtual bool is_cpcache() const { return false; }
123 virtual bool is_instance() { return false; }
124 virtual bool is_member_name() const { return false; }
125 virtual bool is_method_handle() const { return false; }
126 virtual bool is_method_type() const { return false; }
127 virtual bool is_array() { return false; }
128 virtual bool is_obj_array() { return false; }
129 virtual bool is_type_array() { return false; }
131 // Is this a type or value which has no associated class?
132 // It is true of primitive types and null objects.
133 virtual bool is_classless() const { return false; }
134 virtual void dump_replay_data(outputStream* st) { /* do nothing */ }
136 // Note: some ciObjects refer to oops which have yet to be created.
137 // We refer to these as "unloaded". Specifically, there are
138 // unloaded instances of java.lang.Class,
139 // java.lang.invoke.MethodHandle, and java.lang.invoke.MethodType.
140 // By convention the ciNullObject is considered loaded, and
141 // primitive types are considered loaded.
142 bool is_loaded() const {
143 return handle() != NULL || is_classless();
144 }
146 // Subclass casting with assertions.
147 ciNullObject* as_null_object() {
148 assert(is_null_object(), "bad cast");
149 return (ciNullObject*)this;
150 }
151 ciCallSite* as_call_site() {
152 assert(is_call_site(), "bad cast");
153 return (ciCallSite*)this;
154 }
155 ciInstance* as_instance() {
156 assert(is_instance(), "bad cast");
157 return (ciInstance*)this;
158 }
159 ciMemberName* as_member_name() {
160 assert(is_member_name(), "bad cast");
161 return (ciMemberName*)this;
162 }
163 ciMethodHandle* as_method_handle() {
164 assert(is_method_handle(), "bad cast");
165 return (ciMethodHandle*)this;
166 }
167 ciMethodType* as_method_type() {
168 assert(is_method_type(), "bad cast");
169 return (ciMethodType*)this;
170 }
171 ciArray* as_array() {
172 assert(is_array(), "bad cast");
173 return (ciArray*)this;
174 }
175 ciObjArray* as_obj_array() {
176 assert(is_obj_array(), "bad cast");
177 return (ciObjArray*)this;
178 }
179 ciTypeArray* as_type_array() {
180 assert(is_type_array(), "bad cast");
181 return (ciTypeArray*)this;
182 }
184 // Print debugging output about this ciObject.
185 void print(outputStream* st);
186 void print() { print(tty); } // GDB cannot handle default arguments
188 // Print debugging output about the oop this ciObject represents.
189 void print_oop(outputStream* st = tty);
190 };
192 #endif // SHARE_VM_CI_CIOBJECT_HPP