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_CIMETHOD_HPP
26 #define SHARE_VM_CI_CIMETHOD_HPP
28 #include "ci/ciFlags.hpp"
29 #include "ci/ciInstanceKlass.hpp"
30 #include "ci/ciObject.hpp"
31 #include "ci/ciSignature.hpp"
32 #include "compiler/methodLiveness.hpp"
33 #include "prims/methodHandles.hpp"
34 #include "utilities/bitMap.hpp"
36 class ciMethodBlocks;
37 class MethodLiveness;
38 class BitMap;
39 class Arena;
40 class BCEscapeAnalyzer;
43 // ciMethod
44 //
45 // This class represents a Method* in the HotSpot virtual
46 // machine.
47 class ciMethod : public ciMetadata {
48 friend class CompileBroker;
49 CI_PACKAGE_ACCESS
50 friend class ciEnv;
51 friend class ciExceptionHandlerStream;
52 friend class ciBytecodeStream;
53 friend class ciMethodHandle;
54 friend class ciReplay;
56 private:
57 // General method information.
58 ciFlags _flags;
59 ciSymbol* _name;
60 ciInstanceKlass* _holder;
61 ciSignature* _signature;
62 ciMethodData* _method_data;
63 ciMethodBlocks* _method_blocks;
65 // Code attributes.
66 int _code_size;
67 int _max_stack;
68 int _max_locals;
69 vmIntrinsics::ID _intrinsic_id;
70 int _handler_count;
71 int _interpreter_invocation_count;
72 int _interpreter_throwout_count;
73 int _instructions_size;
75 bool _uses_monitors;
76 bool _balanced_monitors;
77 bool _is_c1_compilable;
78 bool _is_c2_compilable;
79 bool _can_be_statically_bound;
81 // Lazy fields, filled in on demand
82 address _code;
83 ciExceptionHandler** _exception_handlers;
85 // Optional liveness analyzer.
86 MethodLiveness* _liveness;
87 #if defined(COMPILER2) || defined(SHARK)
88 ciTypeFlow* _flow;
89 BCEscapeAnalyzer* _bcea;
90 #endif
92 ciMethod(methodHandle h_m);
93 ciMethod(ciInstanceKlass* holder, ciSymbol* name, ciSymbol* signature, ciInstanceKlass* accessor);
95 Method* get_Method() const {
96 Method* m = (Method*)_metadata;
97 assert(m != NULL, "illegal use of unloaded method");
98 return m;
99 }
101 oop loader() const { return _holder->loader(); }
103 const char* type_string() { return "ciMethod"; }
105 void print_impl(outputStream* st);
107 void load_code();
109 void check_is_loaded() const { assert(is_loaded(), "not loaded"); }
111 bool ensure_method_data(methodHandle h_m);
113 void code_at_put(int bci, Bytecodes::Code code) {
114 Bytecodes::check(code);
115 assert(0 <= bci && bci < code_size(), "valid bci");
116 address bcp = _code + bci;
117 *bcp = code;
118 }
120 public:
121 // Basic method information.
122 ciFlags flags() const { check_is_loaded(); return _flags; }
123 ciSymbol* name() const { return _name; }
124 ciInstanceKlass* holder() const { return _holder; }
125 ciMethodData* method_data();
126 ciMethodData* method_data_or_null();
128 // Signature information.
129 ciSignature* signature() const { return _signature; }
130 ciType* return_type() const { return _signature->return_type(); }
131 int arg_size_no_receiver() const { return _signature->size(); }
132 // Can only be used on loaded ciMethods
133 int arg_size() const {
134 check_is_loaded();
135 return _signature->size() + (_flags.is_static() ? 0 : 1);
136 }
137 // Report the number of elements on stack when invoking this method.
138 // This is different than the regular arg_size because invokedynamic
139 // has an implicit receiver.
140 int invoke_arg_size(Bytecodes::Code code) const {
141 if (is_loaded()) {
142 return arg_size();
143 } else {
144 int arg_size = _signature->size();
145 // Add a receiver argument, maybe:
146 if (code != Bytecodes::_invokestatic &&
147 code != Bytecodes::_invokedynamic) {
148 arg_size++;
149 }
150 return arg_size;
151 }
152 }
155 // Method code and related information.
156 address code() { if (_code == NULL) load_code(); return _code; }
157 int code_size() const { check_is_loaded(); return _code_size; }
158 int max_stack() const { check_is_loaded(); return _max_stack; }
159 int max_locals() const { check_is_loaded(); return _max_locals; }
160 vmIntrinsics::ID intrinsic_id() const { check_is_loaded(); return _intrinsic_id; }
161 bool has_exception_handlers() const { check_is_loaded(); return _handler_count > 0; }
162 int exception_table_length() const { check_is_loaded(); return _handler_count; }
163 int interpreter_invocation_count() const { check_is_loaded(); return _interpreter_invocation_count; }
164 int interpreter_throwout_count() const { check_is_loaded(); return _interpreter_throwout_count; }
166 // Code size for inlining decisions.
167 int code_size_for_inlining();
169 bool force_inline() { return get_Method()->force_inline(); }
170 bool dont_inline() { return get_Method()->dont_inline(); }
172 int comp_level();
173 int highest_osr_comp_level();
175 Bytecodes::Code java_code_at_bci(int bci) {
176 address bcp = code() + bci;
177 return Bytecodes::java_code_at(NULL, bcp);
178 }
179 BCEscapeAnalyzer *get_bcea();
180 ciMethodBlocks *get_method_blocks();
182 bool has_linenumber_table() const; // length unknown until decompression
183 u_char* compressed_linenumber_table() const; // not preserved by gc
185 int line_number_from_bci(int bci) const;
187 // Runtime information.
188 int vtable_index();
189 #ifdef SHARK
190 int itable_index();
191 #endif // SHARK
192 address native_entry();
193 address interpreter_entry();
195 // Analysis and profiling.
196 //
197 // Usage note: liveness_at_bci and init_vars should be wrapped in ResourceMarks.
198 bool uses_monitors() const { return _uses_monitors; } // this one should go away, it has a misleading name
199 bool has_monitor_bytecodes() const { return _uses_monitors; }
200 bool has_balanced_monitors();
202 // Returns a bitmap indicating which locals are required to be
203 // maintained as live for deopt. raw_liveness_at_bci is always the
204 // direct output of the liveness computation while liveness_at_bci
205 // may mark all locals as live to improve support for debugging Java
206 // code by maintaining the state of as many locals as possible.
207 MethodLivenessResult raw_liveness_at_bci(int bci);
208 MethodLivenessResult liveness_at_bci(int bci);
210 // Get the interpreters viewpoint on oop liveness. MethodLiveness is
211 // conservative in the sense that it may consider locals to be live which
212 // cannot be live, like in the case where a local could contain an oop or
213 // a primitive along different paths. In that case the local must be
214 // dead when those paths merge. Since the interpreter's viewpoint is
215 // used when gc'ing an interpreter frame we need to use its viewpoint
216 // during OSR when loading the locals.
218 BitMap live_local_oops_at_bci(int bci);
220 #ifdef COMPILER1
221 const BitMap bci_block_start();
222 #endif
224 ciTypeFlow* get_flow_analysis();
225 ciTypeFlow* get_osr_flow_analysis(int osr_bci); // alternate entry point
226 ciCallProfile call_profile_at_bci(int bci);
227 int interpreter_call_site_count(int bci);
229 // Given a certain calling environment, find the monomorphic target
230 // for the call. Return NULL if the call is not monomorphic in
231 // its calling environment.
232 ciMethod* find_monomorphic_target(ciInstanceKlass* caller,
233 ciInstanceKlass* callee_holder,
234 ciInstanceKlass* actual_receiver);
236 // Given a known receiver klass, find the target for the call.
237 // Return NULL if the call has no target or is abstract.
238 ciMethod* resolve_invoke(ciKlass* caller, ciKlass* exact_receiver);
240 // Find the proper vtable index to invoke this method.
241 int resolve_vtable_index(ciKlass* caller, ciKlass* receiver);
243 // Compilation directives
244 bool will_link(ciKlass* accessing_klass,
245 ciKlass* declared_method_holder,
246 Bytecodes::Code bc);
247 bool should_exclude();
248 bool should_inline();
249 bool should_not_inline();
250 bool should_print_assembly();
251 bool break_at_execute();
252 bool has_option(const char *option);
253 bool can_be_compiled();
254 bool can_be_osr_compiled(int entry_bci);
255 void set_not_compilable();
256 bool has_compiled_code();
257 void log_nmethod_identity(xmlStream* log);
258 bool is_not_reached(int bci);
259 bool was_executed_more_than(int times);
260 bool has_unloaded_classes_in_signature();
261 bool is_klass_loaded(int refinfo_index, bool must_be_resolved) const;
262 bool check_call(int refinfo_index, bool is_static) const;
263 bool ensure_method_data(); // make sure it exists in the VM also
264 int instructions_size();
265 int scale_count(int count, float prof_factor = 1.); // make MDO count commensurate with IIC
267 // JSR 292 support
268 bool is_method_handle_intrinsic() const;
269 bool is_compiled_lambda_form() const;
270 bool has_member_arg() const;
272 // What kind of ciObject is this?
273 bool is_method() const { return true; }
275 // Java access flags
276 bool is_public () const { return flags().is_public(); }
277 bool is_private () const { return flags().is_private(); }
278 bool is_protected () const { return flags().is_protected(); }
279 bool is_static () const { return flags().is_static(); }
280 bool is_final () const { return flags().is_final(); }
281 bool is_synchronized() const { return flags().is_synchronized(); }
282 bool is_native () const { return flags().is_native(); }
283 bool is_interface () const { return flags().is_interface(); }
284 bool is_abstract () const { return flags().is_abstract(); }
285 bool is_strict () const { return flags().is_strict(); }
287 // Other flags
288 bool is_empty_method() const;
289 bool is_vanilla_constructor() const;
290 bool is_final_method() const { return is_final() || holder()->is_final(); }
291 bool has_loops () const;
292 bool has_jsrs () const;
293 bool is_accessor () const;
294 bool is_initializer () const;
295 bool can_be_statically_bound() const { return _can_be_statically_bound; }
296 void dump_replay_data(outputStream* st);
298 // Print the bytecodes of this method.
299 void print_codes_on(outputStream* st);
300 void print_codes() {
301 print_codes_on(tty);
302 }
303 void print_codes_on(int from, int to, outputStream* st);
305 // Print the name of this method in various incarnations.
306 void print_name(outputStream* st = tty);
307 void print_short_name(outputStream* st = tty);
308 };
310 #endif // SHARE_VM_CI_CIMETHOD_HPP