< prev index next >

src/hotspot/share/ci/ciMethod.hpp

Print this page

 55 //
 56 // This class represents a Method* in the HotSpot virtual
 57 // machine.
 58 class ciMethod : public ciMetadata {
 59   friend class CompileBroker;
 60   CI_PACKAGE_ACCESS
 61   friend class ciEnv;
 62   friend class ciExceptionHandlerStream;
 63   friend class ciBytecodeStream;
 64   friend class ciMethodHandle;
 65   friend class ciReplay;
 66   friend class InlineTree;
 67 
 68  private:
 69   // General method information.
 70   ciFlags          _flags;
 71   ciSymbol*        _name;
 72   ciInstanceKlass* _holder;
 73   ciSignature*     _signature;
 74   ciMethodData*    _method_data;

 75   ciMethodBlocks*   _method_blocks;
 76 
 77   // Code attributes.
 78   int _code_size;
 79   int _max_stack;
 80   int _max_locals;
 81   vmIntrinsicID _intrinsic_id;
 82   int _handler_count;
 83   int _interpreter_invocation_count;
 84   int _interpreter_throwout_count;
 85   int _inline_instructions_size;
 86   int _size_of_parameters;
 87 
 88   bool _uses_monitors;
 89   bool _balanced_monitors;
 90   bool _is_c1_compilable;
 91   bool _is_c2_compilable;
 92   bool _can_be_parsed;
 93   bool _can_be_statically_bound;
 94   bool _can_omit_stack_trace;
 95   bool _has_reserved_stack_access;
 96   bool _is_overpass;
 97 


 98   // Lazy fields, filled in on demand
 99   address              _code;
100   ciExceptionHandler** _exception_handlers;
101 
102   // Optional liveness analyzer.
103   MethodLiveness* _liveness;
104 #if defined(COMPILER2)
105   ciTypeFlow*         _flow;
106   BCEscapeAnalyzer*   _bcea;
107 #endif
108 
109   ciMethod(const methodHandle& h_m, ciInstanceKlass* holder);
110   ciMethod(ciInstanceKlass* holder, ciSymbol* name, ciSymbol* signature, ciInstanceKlass* accessor);
111 
112   oop loader() const                             { return _holder->loader(); }
113 
114   const char* type_string()                      { return "ciMethod"; }
115 
116   void print_impl(outputStream* st);
117 
118   void load_code();
119 
120   bool ensure_method_data(const methodHandle& h_m);
121 
122   void code_at_put(int bci, Bytecodes::Code code) {
123     Bytecodes::check(code);
124     assert(0 <= bci && bci < code_size(), "valid bci");
125     address bcp = _code + bci;
126     *bcp = code;
127   }
128 
129   // Check bytecode and profile data collected are compatible
130   void assert_virtual_call_type_ok(int bci);
131   void assert_call_type_ok(int bci);
132 
133   // Check and update the profile counter in case of overflow
134   static int check_overflow(int c, Bytecodes::Code code);
135 
136  public:
137   void check_is_loaded() const                   { assert(is_loaded(), "not loaded"); }
138 
139   // Basic method information.
140   ciFlags flags() const                          { check_is_loaded(); return _flags; }

297                                     bool check_access = true);
298 
299   // Given a known receiver klass, find the target for the call.
300   // Return null if the call has no target or is abstract.
301   ciMethod* resolve_invoke(ciKlass* caller, ciKlass* exact_receiver, bool check_access = true, bool allow_abstract = false);
302 
303   // Find the proper vtable index to invoke this method.
304   int resolve_vtable_index(ciKlass* caller, ciKlass* receiver);
305 
306   bool has_option(enum CompileCommand option);
307   bool has_option_value(enum CompileCommand option, double& value);
308   bool can_be_compiled();
309   bool can_be_parsed() const { return _can_be_parsed; }
310   bool has_compiled_code();
311   void log_nmethod_identity(xmlStream* log);
312   bool is_not_reached(int bci);
313   bool was_executed_more_than(int times);
314   bool has_unloaded_classes_in_signature();
315   bool is_klass_loaded(int refinfo_index, Bytecodes::Code bc, bool must_be_resolved) const;
316   bool check_call(int refinfo_index, bool is_static) const;
317   bool ensure_method_data();  // make sure it exists in the VM also
318   MethodCounters* ensure_method_counters();
319 
320   int inline_instructions_size();
321   int scale_count(int count, float prof_factor = 1.);  // make MDO count commensurate with IIC
322 
323   // Stack walking support
324   bool is_ignored_by_security_stack_walk() const;
325 
326   // JSR 292 support
327   bool is_method_handle_intrinsic()  const;
328   bool is_compiled_lambda_form() const;
329   bool has_member_arg() const;
330 
331   // What kind of ciObject is this?
332   bool is_method() const                         { return true; }
333 
334   // Java access flags
335   bool is_public      () const                   { return flags().is_public(); }
336   bool is_private     () const                   { return flags().is_private(); }
337   bool is_protected   () const                   { return flags().is_protected(); }

365 
366   bool can_omit_stack_trace() const;
367 
368   // Replay data methods
369   static void dump_name_as_ascii(outputStream* st, Method* method);
370   void dump_name_as_ascii(outputStream* st);
371   void dump_replay_data(outputStream* st);
372 
373   // Print the bytecodes of this method.
374   void print_codes_on(outputStream* st);
375   void print_codes() {
376     print_codes_on(tty);
377   }
378   void print_codes_on(int from, int to, outputStream* st);
379 
380   // Print the name of this method in various incarnations.
381   void print_name(outputStream* st = tty);
382   void print_short_name(outputStream* st = tty);
383 
384   static bool is_consistent_info(ciMethod* declared_method, ciMethod* resolved_method);




385 };
386 
387 #endif // SHARE_CI_CIMETHOD_HPP

 55 //
 56 // This class represents a Method* in the HotSpot virtual
 57 // machine.
 58 class ciMethod : public ciMetadata {
 59   friend class CompileBroker;
 60   CI_PACKAGE_ACCESS
 61   friend class ciEnv;
 62   friend class ciExceptionHandlerStream;
 63   friend class ciBytecodeStream;
 64   friend class ciMethodHandle;
 65   friend class ciReplay;
 66   friend class InlineTree;
 67 
 68  private:
 69   // General method information.
 70   ciFlags          _flags;
 71   ciSymbol*        _name;
 72   ciInstanceKlass* _holder;
 73   ciSignature*     _signature;
 74   ciMethodData*    _method_data;
 75   ciMethodData*    _method_data_recorded;
 76   ciMethodBlocks*   _method_blocks;
 77 
 78   // Code attributes.
 79   int _code_size;
 80   int _max_stack;
 81   int _max_locals;
 82   vmIntrinsicID _intrinsic_id;
 83   int _handler_count;
 84   int _interpreter_invocation_count;
 85   int _interpreter_throwout_count;
 86   int _inline_instructions_size;
 87   int _size_of_parameters;
 88 
 89   bool _uses_monitors;
 90   bool _balanced_monitors;
 91   bool _is_c1_compilable;
 92   bool _is_c2_compilable;
 93   bool _can_be_parsed;
 94   bool _can_be_statically_bound;
 95   bool _can_omit_stack_trace;
 96   bool _has_reserved_stack_access;
 97   bool _is_overpass;
 98 
 99   GrowableArray<int>* _has_trap_at_bci;
100 
101   // Lazy fields, filled in on demand
102   address              _code;
103   ciExceptionHandler** _exception_handlers;
104 
105   // Optional liveness analyzer.
106   MethodLiveness* _liveness;
107 #if defined(COMPILER2)
108   ciTypeFlow*         _flow;
109   BCEscapeAnalyzer*   _bcea;
110 #endif
111 
112   ciMethod(const methodHandle& h_m, ciInstanceKlass* holder);
113   ciMethod(ciInstanceKlass* holder, ciSymbol* name, ciSymbol* signature, ciInstanceKlass* accessor);
114 
115   oop loader() const                             { return _holder->loader(); }
116 
117   const char* type_string()                      { return "ciMethod"; }
118 
119   void print_impl(outputStream* st);
120 
121   void load_code();
122 
123   bool ensure_method_data(const methodHandle& h_m, bool training_data_only);
124 
125   void code_at_put(int bci, Bytecodes::Code code) {
126     Bytecodes::check(code);
127     assert(0 <= bci && bci < code_size(), "valid bci");
128     address bcp = _code + bci;
129     *bcp = code;
130   }
131 
132   // Check bytecode and profile data collected are compatible
133   void assert_virtual_call_type_ok(int bci);
134   void assert_call_type_ok(int bci);
135 
136   // Check and update the profile counter in case of overflow
137   static int check_overflow(int c, Bytecodes::Code code);
138 
139  public:
140   void check_is_loaded() const                   { assert(is_loaded(), "not loaded"); }
141 
142   // Basic method information.
143   ciFlags flags() const                          { check_is_loaded(); return _flags; }

300                                     bool check_access = true);
301 
302   // Given a known receiver klass, find the target for the call.
303   // Return null if the call has no target or is abstract.
304   ciMethod* resolve_invoke(ciKlass* caller, ciKlass* exact_receiver, bool check_access = true, bool allow_abstract = false);
305 
306   // Find the proper vtable index to invoke this method.
307   int resolve_vtable_index(ciKlass* caller, ciKlass* receiver);
308 
309   bool has_option(enum CompileCommand option);
310   bool has_option_value(enum CompileCommand option, double& value);
311   bool can_be_compiled();
312   bool can_be_parsed() const { return _can_be_parsed; }
313   bool has_compiled_code();
314   void log_nmethod_identity(xmlStream* log);
315   bool is_not_reached(int bci);
316   bool was_executed_more_than(int times);
317   bool has_unloaded_classes_in_signature();
318   bool is_klass_loaded(int refinfo_index, Bytecodes::Code bc, bool must_be_resolved) const;
319   bool check_call(int refinfo_index, bool is_static) const;
320   bool ensure_method_data(bool training_data_only = false);  // make sure it exists in the VM also
321   MethodCounters* ensure_method_counters();
322 
323   int inline_instructions_size();
324   int scale_count(int count, float prof_factor = 1.);  // make MDO count commensurate with IIC
325 
326   // Stack walking support
327   bool is_ignored_by_security_stack_walk() const;
328 
329   // JSR 292 support
330   bool is_method_handle_intrinsic()  const;
331   bool is_compiled_lambda_form() const;
332   bool has_member_arg() const;
333 
334   // What kind of ciObject is this?
335   bool is_method() const                         { return true; }
336 
337   // Java access flags
338   bool is_public      () const                   { return flags().is_public(); }
339   bool is_private     () const                   { return flags().is_private(); }
340   bool is_protected   () const                   { return flags().is_protected(); }

368 
369   bool can_omit_stack_trace() const;
370 
371   // Replay data methods
372   static void dump_name_as_ascii(outputStream* st, Method* method);
373   void dump_name_as_ascii(outputStream* st);
374   void dump_replay_data(outputStream* st);
375 
376   // Print the bytecodes of this method.
377   void print_codes_on(outputStream* st);
378   void print_codes() {
379     print_codes_on(tty);
380   }
381   void print_codes_on(int from, int to, outputStream* st);
382 
383   // Print the name of this method in various incarnations.
384   void print_name(outputStream* st = tty);
385   void print_short_name(outputStream* st = tty);
386 
387   static bool is_consistent_info(ciMethod* declared_method, ciMethod* resolved_method);
388   bool has_trap_at(int bci) {
389     return _has_trap_at_bci != nullptr &&
390            _has_trap_at_bci->contains(bci);
391   }
392 };
393 
394 #endif // SHARE_CI_CIMETHOD_HPP
< prev index next >