Thu, 02 Dec 2010 17:21:12 -0800
7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
Summary: C1 with profiling doesn't check whether the MDO has been really allocated, which can silently fail if the perm gen is full. The solution is to check if the allocation failed and bailout out of inlining or compilation.
Reviewed-by: kvn, never
1 /*
2 * Copyright (c) 1999, 2010, 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 methodOop in the HotSpot virtual
46 // machine.
47 class ciMethod : public ciObject {
48 friend class CompileBroker;
49 CI_PACKAGE_ACCESS
50 friend class ciEnv;
51 friend class ciExceptionHandlerStream;
52 friend class ciBytecodeStream;
53 friend class ciMethodHandle;
55 private:
56 // General method information.
57 ciFlags _flags;
58 ciSymbol* _name;
59 ciInstanceKlass* _holder;
60 ciSignature* _signature;
61 ciMethodData* _method_data;
62 ciMethodBlocks* _method_blocks;
64 // Code attributes.
65 int _code_size;
66 int _max_stack;
67 int _max_locals;
68 vmIntrinsics::ID _intrinsic_id;
69 int _handler_count;
70 int _interpreter_invocation_count;
71 int _interpreter_throwout_count;
73 bool _uses_monitors;
74 bool _balanced_monitors;
75 bool _is_c1_compilable;
76 bool _is_c2_compilable;
77 bool _can_be_statically_bound;
79 // Lazy fields, filled in on demand
80 address _code;
81 ciExceptionHandler** _exception_handlers;
83 // Optional liveness analyzer.
84 MethodLiveness* _liveness;
85 #if defined(COMPILER2) || defined(SHARK)
86 ciTypeFlow* _flow;
87 BCEscapeAnalyzer* _bcea;
88 #endif
90 ciMethod(methodHandle h_m);
91 ciMethod(ciInstanceKlass* holder, ciSymbol* name, ciSymbol* signature);
93 methodOop get_methodOop() const {
94 methodOop m = (methodOop)get_oop();
95 assert(m != NULL, "illegal use of unloaded method");
96 return m;
97 }
99 oop loader() const { return _holder->loader(); }
101 const char* type_string() { return "ciMethod"; }
103 void print_impl(outputStream* st);
105 void load_code();
107 void check_is_loaded() const { assert(is_loaded(), "not loaded"); }
109 bool ensure_method_data(methodHandle h_m);
111 void code_at_put(int bci, Bytecodes::Code code) {
112 Bytecodes::check(code);
113 assert(0 <= bci && bci < code_size(), "valid bci");
114 address bcp = _code + bci;
115 *bcp = code;
116 }
118 public:
119 // Basic method information.
120 ciFlags flags() const { check_is_loaded(); return _flags; }
121 ciSymbol* name() const { return _name; }
122 ciInstanceKlass* holder() const { return _holder; }
123 ciMethodData* method_data();
124 ciMethodData* method_data_or_null();
126 // Signature information.
127 ciSignature* signature() const { return _signature; }
128 ciType* return_type() const { return _signature->return_type(); }
129 int arg_size_no_receiver() const { return _signature->size(); }
130 int arg_size() const { return _signature->size() + (_flags.is_static() ? 0 : 1); }
132 // Method code and related information.
133 address code() { if (_code == NULL) load_code(); return _code; }
134 int code_size() const { check_is_loaded(); return _code_size; }
135 int max_stack() const { check_is_loaded(); return _max_stack; }
136 int max_locals() const { check_is_loaded(); return _max_locals; }
137 vmIntrinsics::ID intrinsic_id() const { check_is_loaded(); return _intrinsic_id; }
138 bool has_exception_handlers() const { check_is_loaded(); return _handler_count > 0; }
139 int exception_table_length() const { check_is_loaded(); return _handler_count; }
140 int interpreter_invocation_count() const { check_is_loaded(); return _interpreter_invocation_count; }
141 int interpreter_throwout_count() const { check_is_loaded(); return _interpreter_throwout_count; }
143 int comp_level();
145 Bytecodes::Code java_code_at_bci(int bci) {
146 address bcp = code() + bci;
147 return Bytecodes::java_code_at(bcp);
148 }
149 BCEscapeAnalyzer *get_bcea();
150 ciMethodBlocks *get_method_blocks();
152 bool has_linenumber_table() const; // length unknown until decompression
153 u_char* compressed_linenumber_table() const; // not preserved by gc
155 int line_number_from_bci(int bci) const;
157 // Runtime information.
158 int vtable_index();
159 #ifdef SHARK
160 int itable_index();
161 #endif // SHARK
162 address native_entry();
163 address interpreter_entry();
165 // Analysis and profiling.
166 //
167 // Usage note: liveness_at_bci and init_vars should be wrapped in ResourceMarks.
168 bool uses_monitors() const { return _uses_monitors; } // this one should go away, it has a misleading name
169 bool has_monitor_bytecodes() const { return _uses_monitors; }
170 bool has_balanced_monitors();
172 // Returns a bitmap indicating which locals are required to be
173 // maintained as live for deopt. raw_liveness_at_bci is always the
174 // direct output of the liveness computation while liveness_at_bci
175 // may mark all locals as live to improve support for debugging Java
176 // code by maintaining the state of as many locals as possible.
177 MethodLivenessResult raw_liveness_at_bci(int bci);
178 MethodLivenessResult liveness_at_bci(int bci);
180 // Get the interpreters viewpoint on oop liveness. MethodLiveness is
181 // conservative in the sense that it may consider locals to be live which
182 // cannot be live, like in the case where a local could contain an oop or
183 // a primitive along different paths. In that case the local must be
184 // dead when those paths merge. Since the interpreter's viewpoint is
185 // used when gc'ing an interpreter frame we need to use its viewpoint
186 // during OSR when loading the locals.
188 BitMap live_local_oops_at_bci(int bci);
190 #ifdef COMPILER1
191 const BitMap bci_block_start();
192 #endif
194 ciTypeFlow* get_flow_analysis();
195 ciTypeFlow* get_osr_flow_analysis(int osr_bci); // alternate entry point
196 ciCallProfile call_profile_at_bci(int bci);
197 int interpreter_call_site_count(int bci);
199 // Given a certain calling environment, find the monomorphic target
200 // for the call. Return NULL if the call is not monomorphic in
201 // its calling environment.
202 ciMethod* find_monomorphic_target(ciInstanceKlass* caller,
203 ciInstanceKlass* callee_holder,
204 ciInstanceKlass* actual_receiver);
206 // Given a known receiver klass, find the target for the call.
207 // Return NULL if the call has no target or is abstract.
208 ciMethod* resolve_invoke(ciKlass* caller, ciKlass* exact_receiver);
210 // Find the proper vtable index to invoke this method.
211 int resolve_vtable_index(ciKlass* caller, ciKlass* receiver);
213 // Compilation directives
214 bool will_link(ciKlass* accessing_klass,
215 ciKlass* declared_method_holder,
216 Bytecodes::Code bc);
217 bool should_exclude();
218 bool should_inline();
219 bool should_not_inline();
220 bool should_print_assembly();
221 bool break_at_execute();
222 bool has_option(const char *option);
223 bool can_be_compiled();
224 bool can_be_osr_compiled(int entry_bci);
225 void set_not_compilable();
226 bool has_compiled_code();
227 int instructions_size(int comp_level = CompLevel_any);
228 void log_nmethod_identity(xmlStream* log);
229 bool is_not_reached(int bci);
230 bool was_executed_more_than(int times);
231 bool has_unloaded_classes_in_signature();
232 bool is_klass_loaded(int refinfo_index, bool must_be_resolved) const;
233 bool check_call(int refinfo_index, bool is_static) const;
234 bool ensure_method_data(); // make sure it exists in the VM also
235 int scale_count(int count, float prof_factor = 1.); // make MDO count commensurate with IIC
237 // JSR 292 support
238 bool is_method_handle_invoke() const;
239 bool is_method_handle_adapter() const;
240 ciInstance* method_handle_type();
242 // What kind of ciObject is this?
243 bool is_method() { return true; }
245 // Java access flags
246 bool is_public () const { return flags().is_public(); }
247 bool is_private () const { return flags().is_private(); }
248 bool is_protected () const { return flags().is_protected(); }
249 bool is_static () const { return flags().is_static(); }
250 bool is_final () const { return flags().is_final(); }
251 bool is_synchronized() const { return flags().is_synchronized(); }
252 bool is_native () const { return flags().is_native(); }
253 bool is_interface () const { return flags().is_interface(); }
254 bool is_abstract () const { return flags().is_abstract(); }
255 bool is_strict () const { return flags().is_strict(); }
257 // Other flags
258 bool is_empty_method() const;
259 bool is_vanilla_constructor() const;
260 bool is_final_method() const { return is_final() || holder()->is_final(); }
261 bool has_loops () const;
262 bool has_jsrs () const;
263 bool is_accessor () const;
264 bool is_initializer () const;
265 bool can_be_statically_bound() const { return _can_be_statically_bound; }
267 // Print the bytecodes of this method.
268 void print_codes_on(outputStream* st);
269 void print_codes() {
270 print_codes_on(tty);
271 }
272 void print_codes_on(int from, int to, outputStream* st);
274 // Print the name of this method in various incarnations.
275 void print_name(outputStream* st = tty);
276 void print_short_name(outputStream* st = tty);
278 methodOop get_method_handle_target() {
279 klassOop receiver_limit_oop = NULL;
280 int flags = 0;
281 return MethodHandles::decode_method(get_oop(), receiver_limit_oop, flags);
282 }
283 };
285 #endif // SHARE_VM_CI_CIMETHOD_HPP