src/share/vm/ci/ciMethod.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File hotspot Sdiff src/share/vm/ci

src/share/vm/ci/ciMethod.hpp

Print this page
rev 9032 : 8137167: JEP165: Compiler Control: Implementation task
Summary: Compiler Control JEP
Reviewed-by: roland, twisti


  87   ciExceptionHandler** _exception_handlers;
  88 
  89   // Optional liveness analyzer.
  90   MethodLiveness* _liveness;
  91 #if defined(COMPILER2) || defined(SHARK)
  92   ciTypeFlow*         _flow;
  93   BCEscapeAnalyzer*   _bcea;
  94 #endif
  95 
  96   ciMethod(methodHandle h_m, ciInstanceKlass* holder);
  97   ciMethod(ciInstanceKlass* holder, ciSymbol* name, ciSymbol* signature, ciInstanceKlass* accessor);
  98 
  99   oop loader() const                             { return _holder->loader(); }
 100 
 101   const char* type_string()                      { return "ciMethod"; }
 102 
 103   void print_impl(outputStream* st);
 104 
 105   void load_code();
 106 
 107   void check_is_loaded() const                   { assert(is_loaded(), "not loaded"); }
 108 
 109   bool ensure_method_data(methodHandle h_m);
 110 
 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   }
 117 
 118   // Check bytecode and profile data collected are compatible
 119   void assert_virtual_call_type_ok(int bci);
 120   void assert_call_type_ok(int bci);
 121 
 122  public:


 123   // Basic method information.
 124   ciFlags flags() const                          { check_is_loaded(); return _flags; }
 125   ciSymbol* name() const                         { return _name; }
 126   ciInstanceKlass* holder() const                { return _holder; }
 127   ciMethodData* method_data();
 128   ciMethodData* method_data_or_null();
 129 
 130   // Signature information.
 131   ciSignature* signature() const                 { return _signature; }
 132   ciType*      return_type() const               { return _signature->return_type(); }
 133   int          arg_size_no_receiver() const      { return _signature->size(); }
 134   // Can only be used on loaded ciMethods
 135   int          arg_size() const                  {
 136     check_is_loaded();
 137     return _signature->size() + (_flags.is_static() ? 0 : 1);
 138   }
 139   // Report the number of elements on stack when invoking this method.
 140   // This is different than the regular arg_size because invokedynamic
 141   // has an implicit receiver.
 142   int invoke_arg_size(Bytecodes::Code code) const {


 248   bool          parameter_profiled_type(int i, ciKlass*& type, bool& maybe_null);
 249   bool          return_profiled_type(int bci, ciKlass*& type, bool& maybe_null);
 250 
 251   ciField*      get_field_at_bci( int bci, bool &will_link);
 252   ciMethod*     get_method_at_bci(int bci, bool &will_link, ciSignature* *declared_signature);
 253   // Given a certain calling environment, find the monomorphic target
 254   // for the call.  Return NULL if the call is not monomorphic in
 255   // its calling environment.
 256   ciMethod* find_monomorphic_target(ciInstanceKlass* caller,
 257                                     ciInstanceKlass* callee_holder,
 258                                     ciInstanceKlass* actual_receiver,
 259                                     bool check_access = true);
 260 
 261   // Given a known receiver klass, find the target for the call.
 262   // Return NULL if the call has no target or is abstract.
 263   ciMethod* resolve_invoke(ciKlass* caller, ciKlass* exact_receiver, bool check_access = true);
 264 
 265   // Find the proper vtable index to invoke this method.
 266   int resolve_vtable_index(ciKlass* caller, ciKlass* receiver);
 267 
 268   // Compilation directives
 269   bool should_inline();
 270   bool should_not_inline();
 271   bool should_print_assembly();
 272   bool break_at_execute();
 273   bool has_option(const char *option);
 274   template<typename T>
 275   bool has_option_value(const char* option, T& value);
 276   bool can_be_compiled();
 277   bool can_be_osr_compiled(int entry_bci);
 278   void set_not_compilable(const char* reason = NULL);
 279   bool has_compiled_code();
 280   void log_nmethod_identity(xmlStream* log);
 281   bool is_not_reached(int bci);
 282   bool was_executed_more_than(int times);
 283   bool has_unloaded_classes_in_signature();
 284   bool is_klass_loaded(int refinfo_index, bool must_be_resolved) const;
 285   bool check_call(int refinfo_index, bool is_static) const;
 286   bool ensure_method_data();  // make sure it exists in the VM also
 287   MethodCounters* ensure_method_counters();
 288   int instructions_size();
 289   int scale_count(int count, float prof_factor = 1.);  // make MDO count commensurate with IIC
 290 
 291   // Stack walking support
 292   bool is_ignored_by_security_stack_walk() const;
 293 
 294   // JSR 292 support
 295   bool is_method_handle_intrinsic()  const;




  87   ciExceptionHandler** _exception_handlers;
  88 
  89   // Optional liveness analyzer.
  90   MethodLiveness* _liveness;
  91 #if defined(COMPILER2) || defined(SHARK)
  92   ciTypeFlow*         _flow;
  93   BCEscapeAnalyzer*   _bcea;
  94 #endif
  95 
  96   ciMethod(methodHandle h_m, ciInstanceKlass* holder);
  97   ciMethod(ciInstanceKlass* holder, ciSymbol* name, ciSymbol* signature, ciInstanceKlass* accessor);
  98 
  99   oop loader() const                             { return _holder->loader(); }
 100 
 101   const char* type_string()                      { return "ciMethod"; }
 102 
 103   void print_impl(outputStream* st);
 104 
 105   void load_code();
 106 


 107   bool ensure_method_data(methodHandle h_m);
 108 
 109   void code_at_put(int bci, Bytecodes::Code code) {
 110     Bytecodes::check(code);
 111     assert(0 <= bci && bci < code_size(), "valid bci");
 112     address bcp = _code + bci;
 113     *bcp = code;
 114   }
 115 
 116   // Check bytecode and profile data collected are compatible
 117   void assert_virtual_call_type_ok(int bci);
 118   void assert_call_type_ok(int bci);
 119 
 120  public:
 121   void check_is_loaded() const                   { assert(is_loaded(), "not loaded"); }
 122 
 123   // Basic method information.
 124   ciFlags flags() const                          { check_is_loaded(); return _flags; }
 125   ciSymbol* name() const                         { return _name; }
 126   ciInstanceKlass* holder() const                { return _holder; }
 127   ciMethodData* method_data();
 128   ciMethodData* method_data_or_null();
 129 
 130   // Signature information.
 131   ciSignature* signature() const                 { return _signature; }
 132   ciType*      return_type() const               { return _signature->return_type(); }
 133   int          arg_size_no_receiver() const      { return _signature->size(); }
 134   // Can only be used on loaded ciMethods
 135   int          arg_size() const                  {
 136     check_is_loaded();
 137     return _signature->size() + (_flags.is_static() ? 0 : 1);
 138   }
 139   // Report the number of elements on stack when invoking this method.
 140   // This is different than the regular arg_size because invokedynamic
 141   // has an implicit receiver.
 142   int invoke_arg_size(Bytecodes::Code code) const {


 248   bool          parameter_profiled_type(int i, ciKlass*& type, bool& maybe_null);
 249   bool          return_profiled_type(int bci, ciKlass*& type, bool& maybe_null);
 250 
 251   ciField*      get_field_at_bci( int bci, bool &will_link);
 252   ciMethod*     get_method_at_bci(int bci, bool &will_link, ciSignature* *declared_signature);
 253   // Given a certain calling environment, find the monomorphic target
 254   // for the call.  Return NULL if the call is not monomorphic in
 255   // its calling environment.
 256   ciMethod* find_monomorphic_target(ciInstanceKlass* caller,
 257                                     ciInstanceKlass* callee_holder,
 258                                     ciInstanceKlass* actual_receiver,
 259                                     bool check_access = true);
 260 
 261   // Given a known receiver klass, find the target for the call.
 262   // Return NULL if the call has no target or is abstract.
 263   ciMethod* resolve_invoke(ciKlass* caller, ciKlass* exact_receiver, bool check_access = true);
 264 
 265   // Find the proper vtable index to invoke this method.
 266   int resolve_vtable_index(ciKlass* caller, ciKlass* receiver);
 267 





 268   bool has_option(const char *option);
 269   bool has_option_value(const char* option, double& value);

 270   bool can_be_compiled();
 271   bool can_be_osr_compiled(int entry_bci);
 272   void set_not_compilable(const char* reason = NULL);
 273   bool has_compiled_code();
 274   void log_nmethod_identity(xmlStream* log);
 275   bool is_not_reached(int bci);
 276   bool was_executed_more_than(int times);
 277   bool has_unloaded_classes_in_signature();
 278   bool is_klass_loaded(int refinfo_index, bool must_be_resolved) const;
 279   bool check_call(int refinfo_index, bool is_static) const;
 280   bool ensure_method_data();  // make sure it exists in the VM also
 281   MethodCounters* ensure_method_counters();
 282   int instructions_size();
 283   int scale_count(int count, float prof_factor = 1.);  // make MDO count commensurate with IIC
 284 
 285   // Stack walking support
 286   bool is_ignored_by_security_stack_walk() const;
 287 
 288   // JSR 292 support
 289   bool is_method_handle_intrinsic()  const;


src/share/vm/ci/ciMethod.hpp
Index Unified diffs Context diffs Sdiffs Patch New Old Previous File Next File