jdk8-mips64-public/hotspot: src/share/vm/ci/ciMethod.hpp@4ce7240d622c

     1 /*

     2  * Copyright 1999-2009 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    25 class ciMethodBlocks;

    26 class MethodLiveness;

    27 class BitMap;

    28 class Arena;

    29 class BCEscapeAnalyzer;

    32 // ciMethod

    33 //

    34 // This class represents a methodOop in the HotSpot virtual

    35 // machine.

    36 class ciMethod : public ciObject {

    37   friend class CompileBroker;

    38   CI_PACKAGE_ACCESS

    39   friend class ciEnv;

    40   friend class ciExceptionHandlerStream;

    41   friend class ciBytecodeStream;

    42   friend class ciMethodHandle;

    44  private:

    45   // General method information.

    46   ciFlags          _flags;

    47   ciSymbol*        _name;

    48   ciInstanceKlass* _holder;

    49   ciSignature*     _signature;

    50   ciMethodData*    _method_data;

    51   BCEscapeAnalyzer* _bcea;

    52   ciMethodBlocks*   _method_blocks;

    54   // Code attributes.

    55   int _code_size;

    56   int _max_stack;

    57   int _max_locals;

    58   vmIntrinsics::ID _intrinsic_id;

    59   int _handler_count;

    60   int _interpreter_invocation_count;

    61   int _interpreter_throwout_count;

    63   bool _uses_monitors;

    64   bool _balanced_monitors;

    65   bool _is_compilable;

    66   bool _can_be_statically_bound;

    68   // Lazy fields, filled in on demand

    69   address              _code;

    70   ciExceptionHandler** _exception_handlers;

    72   // Optional liveness analyzer.

    73   MethodLiveness* _liveness;

    74 #ifdef COMPILER2

    75   ciTypeFlow*     _flow;

    76 #endif

    78   ciMethod(methodHandle h_m);

    79   ciMethod(ciInstanceKlass* holder, ciSymbol* name, ciSymbol* signature);

    81   methodOop get_methodOop() const {

    82     methodOop m = (methodOop)get_oop();

    83     assert(m != NULL, "illegal use of unloaded method");

    84     return m;

    85   }

    87   oop loader() const                             { return _holder->loader(); }

    89   const char* type_string()                      { return "ciMethod"; }

    91   void print_impl(outputStream* st);

    93   void load_code();

    95   void check_is_loaded() const                   { assert(is_loaded(), "not loaded"); }

    97   void build_method_data(methodHandle h_m);

    99   void code_at_put(int bci, Bytecodes::Code code) {

   100     Bytecodes::check(code);

   101     assert(0 <= bci && bci < code_size(), "valid bci");

   102     address bcp = _code + bci;

   103     *bcp = code;

   104   }

   106  public:

   107   // Basic method information.

   108   ciFlags flags() const                          { check_is_loaded(); return _flags; }

   109   ciSymbol* name() const                         { return _name; }

   110   ciInstanceKlass* holder() const                { return _holder; }

   111   ciMethodData* method_data();

   113   // Signature information.

   114   ciSignature* signature() const                 { return _signature; }

   115   ciType*      return_type() const               { return _signature->return_type(); }

   116   int          arg_size_no_receiver() const      { return _signature->size(); }

   117   int          arg_size() const                  { return _signature->size() + (_flags.is_static() ? 0 : 1); }

   119   // Method code and related information.

   120   address code()                                 { if (_code == NULL) load_code(); return _code; }

   121   int code_size() const                          { check_is_loaded(); return _code_size; }

   122   int max_stack() const                          { check_is_loaded(); return _max_stack; }

   123   int max_locals() const                         { check_is_loaded(); return _max_locals; }

   124   vmIntrinsics::ID intrinsic_id() const          { check_is_loaded(); return _intrinsic_id; }

   125   bool has_exception_handlers() const            { check_is_loaded(); return _handler_count > 0; }

   126   int exception_table_length() const             { check_is_loaded(); return _handler_count; }

   127   int interpreter_invocation_count() const       { check_is_loaded(); return _interpreter_invocation_count; }

   128   int interpreter_throwout_count() const         { check_is_loaded(); return _interpreter_throwout_count; }

   130   Bytecodes::Code java_code_at_bci(int bci) {

   131     address bcp = code() + bci;

   132     return Bytecodes::java_code_at(bcp);

   133   }

   134   BCEscapeAnalyzer  *get_bcea();

   135   ciMethodBlocks    *get_method_blocks();

   137   bool    has_linenumber_table() const;          // length unknown until decompression

   138   u_char* compressed_linenumber_table() const;   // not preserved by gc

   140   int line_number_from_bci(int bci) const;

   142   // Runtime information.

   143   int           vtable_index();

   144   address       native_entry();

   145   address       interpreter_entry();

   147   // Analysis and profiling.

   148   //

   149   // Usage note: liveness_at_bci and init_vars should be wrapped in ResourceMarks.

   150   bool          uses_monitors() const            { return _uses_monitors; } // this one should go away, it has a misleading name

   151   bool          has_monitor_bytecodes() const    { return _uses_monitors; }

   152   bool          has_balanced_monitors();

   154   // Returns a bitmap indicating which locals are required to be

   155   // maintained as live for deopt.  raw_liveness_at_bci is always the

   156   // direct output of the liveness computation while liveness_at_bci

   157   // may mark all locals as live to improve support for debugging Java

   158   // code by maintaining the state of as many locals as possible.

   159   MethodLivenessResult raw_liveness_at_bci(int bci);

   160   MethodLivenessResult liveness_at_bci(int bci);

   162   // Get the interpreters viewpoint on oop liveness.  MethodLiveness is

   163   // conservative in the sense that it may consider locals to be live which

   164   // cannot be live, like in the case where a local could contain an oop or

   165   // a primitive along different paths.  In that case the local must be

   166   // dead when those paths merge. Since the interpreter's viewpoint is

   167   // used when gc'ing an interpreter frame we need to use its viewpoint

   168   // during OSR when loading the locals.

   170   BitMap  live_local_oops_at_bci(int bci);

   172 #ifdef COMPILER1

   173   const BitMap  bci_block_start();

   174 #endif

   176   ciTypeFlow*   get_flow_analysis();

   177   ciTypeFlow*   get_osr_flow_analysis(int osr_bci);  // alternate entry point

   178   ciCallProfile call_profile_at_bci(int bci);

   179   int           interpreter_call_site_count(int bci);

   181   // Given a certain calling environment, find the monomorphic target

   182   // for the call.  Return NULL if the call is not monomorphic in

   183   // its calling environment.

   184   ciMethod* find_monomorphic_target(ciInstanceKlass* caller,

   185                                     ciInstanceKlass* callee_holder,

   186                                     ciInstanceKlass* actual_receiver);

   188   // Given a known receiver klass, find the target for the call.

   189   // Return NULL if the call has no target or is abstract.

   190   ciMethod* resolve_invoke(ciKlass* caller, ciKlass* exact_receiver);

   192   // Find the proper vtable index to invoke this method.

   193   int resolve_vtable_index(ciKlass* caller, ciKlass* receiver);

   195   // Compilation directives

   196   bool will_link(ciKlass* accessing_klass,

   197                  ciKlass* declared_method_holder,

   198                  Bytecodes::Code bc);

   199   bool should_exclude();

   200   bool should_inline();

   201   bool should_not_inline();

   202   bool should_print_assembly();

   203   bool break_at_execute();

   204   bool has_option(const char *option);

   205   bool can_be_compiled();

   206   bool can_be_osr_compiled(int entry_bci);

   207   void set_not_compilable();

   208   bool has_compiled_code();

   209   int  instructions_size();

   210   void log_nmethod_identity(xmlStream* log);

   211   bool is_not_reached(int bci);

   212   bool was_executed_more_than(int times);

   213   bool has_unloaded_classes_in_signature();

   214   bool is_klass_loaded(int refinfo_index, bool must_be_resolved) const;

   215   bool check_call(int refinfo_index, bool is_static) const;

   216   void build_method_data();  // make sure it exists in the VM also

   217   int scale_count(int count, float prof_factor = 1.);  // make MDO count commensurate with IIC

   218   bool is_method_handle_invoke() const;

   219   ciInstance* method_handle_type();

   221   // What kind of ciObject is this?

   222   bool is_method()                               { return true; }

   224   // Java access flags

   225   bool is_public      () const                   { return flags().is_public(); }

   226   bool is_private     () const                   { return flags().is_private(); }

   227   bool is_protected   () const                   { return flags().is_protected(); }

   228   bool is_static      () const                   { return flags().is_static(); }

   229   bool is_final       () const                   { return flags().is_final(); }

   230   bool is_synchronized() const                   { return flags().is_synchronized(); }

   231   bool is_native      () const                   { return flags().is_native(); }

   232   bool is_interface   () const                   { return flags().is_interface(); }

   233   bool is_abstract    () const                   { return flags().is_abstract(); }

   234   bool is_strict      () const                   { return flags().is_strict(); }

   236   // Other flags

   237   bool is_empty_method() const;

   238   bool is_vanilla_constructor() const;

   239   bool is_final_method() const                   { return is_final() || holder()->is_final(); }

   240   bool has_loops      () const;

   241   bool has_jsrs       () const;

   242   bool is_accessor    () const;

   243   bool is_initializer () const;

   244   bool can_be_statically_bound() const           { return _can_be_statically_bound; }

   246   // Print the bytecodes of this method.

   247   void print_codes_on(outputStream* st);

   248   void print_codes() {

   249     print_codes_on(tty);

   250   }

   251   void print_codes_on(int from, int to, outputStream* st);

   253   // Print the name of this method in various incarnations.

   254   void print_name(outputStream* st = tty);

   255   void print_short_name(outputStream* st = tty);

   257   methodOop get_method_handle_target() {

   258     klassOop receiver_limit_oop = NULL;

   259     int flags = 0;

   260     return MethodHandles::decode_method(get_oop(), receiver_limit_oop, flags);

   261   }

   262 };

Mercurial > jdk8-mips64-public > hotspot / file revision

src/share/vm/ci/ciMethod.hpp@4ce7240d622c

src/share/vm/ci/ciMethod.hpp