1 /*

     2  * Copyright (c) 2015, 2016, 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  */

    24 

    25 #ifndef SHARE_VM_CODE_COMPILEDMETHOD_HPP

    26 #define SHARE_VM_CODE_COMPILEDMETHOD_HPP

    27 

    28 #include "code/codeBlob.hpp"

    29 #include "code/pcDesc.hpp"

    30 #include "oops/metadata.hpp"

    31 

    32 class Dependencies;

    33 class ExceptionHandlerTable;

    34 class ImplicitExceptionTable;

    35 class AbstractCompiler;

    36 class xmlStream;

    37 class CompiledStaticCall;

    38 

    39 // This class is used internally by nmethods, to cache

    40 // exception/pc/handler information.

    41 

    42 class ExceptionCache : public CHeapObj<mtCode> {

    43   friend class VMStructs;

    44  private:

    45   enum { cache_size = 16 };

    46   Klass*   _exception_type;

    47   address  _pc[cache_size];

    48   address  _handler[cache_size];

    49   volatile int _count;

    50   ExceptionCache* _next;

    51 

    52   address pc_at(int index)                     { assert(index >= 0 && index < count(),""); return _pc[index]; }

    53   void    set_pc_at(int index, address a)      { assert(index >= 0 && index < cache_size,""); _pc[index] = a; }

    54   address handler_at(int index)                { assert(index >= 0 && index < count(),""); return _handler[index]; }

    55   void    set_handler_at(int index, address a) { assert(index >= 0 && index < cache_size,""); _handler[index] = a; }

    56   int     count()                              { return OrderAccess::load_acquire(&_count); }

    57   // increment_count is only called under lock, but there may be concurrent readers.

    58   void    increment_count()                    { OrderAccess::release_store(&_count, _count + 1); }

    59 

    60  public:

    61 

    62   ExceptionCache(Handle exception, address pc, address handler);

    63 

    64   Klass*    exception_type()                { return _exception_type; }

    65   ExceptionCache* next()                    { return _next; }

    66   void      set_next(ExceptionCache *ec)    { _next = ec; }

    67 

    68   address match(Handle exception, address pc);

    69   bool    match_exception_with_space(Handle exception) ;

    70   address test_address(address addr);

    71   bool    add_address_and_handler(address addr, address handler) ;

    72 };

    73 

    74 class nmethod;

    75 

    76 // cache pc descs found in earlier inquiries

    77 class PcDescCache VALUE_OBJ_CLASS_SPEC {

    78   friend class VMStructs;

    79  private:

    80   enum { cache_size = 4 };

    81   // The array elements MUST be volatile! Several threads may modify

    82   // and read from the cache concurrently. find_pc_desc_internal has

    83   // returned wrong results. C++ compiler (namely xlC12) may duplicate

    84   // C++ field accesses if the elements are not volatile.

    85   typedef PcDesc* PcDescPtr;

    86   volatile PcDescPtr _pc_descs[cache_size]; // last cache_size pc_descs found

    87  public:

    88   PcDescCache() { debug_only(_pc_descs[0] = NULL); }

    89   void    reset_to(PcDesc* initial_pc_desc);

    90   PcDesc* find_pc_desc(int pc_offset, bool approximate);

    91   void    add_pc_desc(PcDesc* pc_desc);

    92   PcDesc* last_pc_desc() { return _pc_descs[0]; }

    93 };

    94 

    95 class PcDescSearch {

    96 private:

    97   address _code_begin;

    98   PcDesc* _lower;

    99   PcDesc* _upper;

   100 public:

   101   PcDescSearch(address code, PcDesc* lower, PcDesc* upper) :

   102     _code_begin(code), _lower(lower), _upper(upper)

   103   {

   104   }

   105 

   106   address code_begin() const { return _code_begin; }

   107   PcDesc* scopes_pcs_begin() const { return _lower; }

   108   PcDesc* scopes_pcs_end() const { return _upper; }

   109 };

   110 

   111 class PcDescContainer VALUE_OBJ_CLASS_SPEC {

   112 private:

   113   PcDescCache _pc_desc_cache;

   114 public:

   115   PcDescContainer() {}

   116 

   117   PcDesc* find_pc_desc_internal(address pc, bool approximate, const PcDescSearch& search);

   118   void    reset_to(PcDesc* initial_pc_desc) { _pc_desc_cache.reset_to(initial_pc_desc); }

   119 

   120   PcDesc* find_pc_desc(address pc, bool approximate, const PcDescSearch& search) {

   121     address base_address = search.code_begin();

   122     PcDesc* desc = _pc_desc_cache.last_pc_desc();

   123     if (desc != NULL && desc->pc_offset() == pc - base_address) {

   124       return desc;

   125     }

   126     return find_pc_desc_internal(pc, approximate, search);

   127   }

   128 };

   129 

   130 

   131 class CompiledMethod : public CodeBlob {

   132   friend class VMStructs;

   133   friend class NMethodSweeper;

   134 

   135   void init_defaults();

   136 protected:

   137   enum MarkForDeoptimizationStatus {

   138     not_marked,

   139     deoptimize,

   140     deoptimize_noupdate

   141   };

   142 

   143   MarkForDeoptimizationStatus _mark_for_deoptimization_status; // Used for stack deoptimization

   144 

   145   bool _is_far_code; // Code is far from CodeCache.

   146                      // Have to use far call instructions to call it from code in CodeCache.

   147   // set during construction

   148   unsigned int _has_unsafe_access:1;         // May fault due to unsafe access.

   149   unsigned int _has_method_handle_invokes:1; // Has this method MethodHandle invokes?

   150   unsigned int _lazy_critical_native:1;      // Lazy JNI critical native

   151   unsigned int _has_wide_vectors:1;          // Preserve wide vectors at safepoints

   152 

   153   Method*   _method;

   154   address _scopes_data_begin;

   155   // All deoptee's will resume execution at this location described by

   156   // this address.

   157   address _deopt_handler_begin;

   158   // All deoptee's at a MethodHandle call site will resume execution

   159   // at this location described by this offset.

   160   address _deopt_mh_handler_begin;

   161 

   162   PcDescContainer _pc_desc_container;

   163   ExceptionCache * volatile _exception_cache;

   164 

   165   virtual void flush() = 0;

   166 protected:

   167   CompiledMethod(Method* method, const char* name, const CodeBlobLayout& layout, int frame_complete_offset, int frame_size, ImmutableOopMapSet* oop_maps, bool caller_must_gc_arguments);

   168   CompiledMethod(Method* method, const char* name, int size, int header_size, CodeBuffer* cb, int frame_complete_offset, int frame_size, OopMapSet* oop_maps, bool caller_must_gc_arguments);

   169 

   170 public:

   171   virtual bool is_compiled() const                { return true; }

   172 

   173   bool  has_unsafe_access() const                 { return _has_unsafe_access; }

   174   void  set_has_unsafe_access(bool z)             { _has_unsafe_access = z; }

   175 

   176   bool  has_method_handle_invokes() const         { return _has_method_handle_invokes; }

   177   void  set_has_method_handle_invokes(bool z)     { _has_method_handle_invokes = z; }

   178 

   179   bool  is_lazy_critical_native() const           { return _lazy_critical_native; }

   180   void  set_lazy_critical_native(bool z)          { _lazy_critical_native = z; }

   181 

   182   bool  has_wide_vectors() const                  { return _has_wide_vectors; }

   183   void  set_has_wide_vectors(bool z)              { _has_wide_vectors = z; }

   184 

   185   enum { in_use       = 0,   // executable nmethod

   186          not_used     = 1,   // not entrant, but revivable

   187          not_entrant  = 2,   // marked for deoptimization but activations may still exist,

   188                              // will be transformed to zombie when all activations are gone

   189          zombie       = 3,   // no activations exist, nmethod is ready for purge

   190          unloaded     = 4    // there should be no activations, should not be called,

   191                              // will be transformed to zombie immediately

   192   };

   193 

   194   virtual AbstractCompiler* compiler() const = 0;

   195   virtual bool  is_in_use() const = 0;

   196   virtual int   comp_level() const = 0;

   197   virtual int   compile_id() const = 0;

   198 

   199 

   200   virtual address verified_entry_point() const = 0;

   201   virtual void log_identity(xmlStream* log) const = 0;

   202   virtual void log_state_change() const = 0;

   203   virtual bool make_not_used() = 0;

   204   virtual bool make_not_entrant() = 0;

   205   virtual bool make_entrant() = 0;

   206   virtual address entry_point() const = 0;

   207   virtual bool make_zombie() = 0;

   208   virtual bool is_osr_method() const = 0;

   209   virtual int osr_entry_bci() const = 0;

   210   Method* method() const                          { return _method; }

   211   virtual void print_pcs() = 0;

   212   bool is_native_method() const { return _method != NULL && _method->is_native(); }

   213   bool is_java_method() const { return _method != NULL && !_method->is_native(); }

   214 

   215   // ScopeDesc retrieval operation

   216   PcDesc* pc_desc_at(address pc)   { return find_pc_desc(pc, false); }

   217   // pc_desc_near returns the first PcDesc at or after the givne pc.

   218   PcDesc* pc_desc_near(address pc) { return find_pc_desc(pc, true); }

   219 

   220   // ScopeDesc for an instruction

   221   ScopeDesc* scope_desc_at(address pc);

   222 

   223   bool is_at_poll_return(address pc);

   224   bool is_at_poll_or_poll_return(address pc);

   225 

   226   bool  is_marked_for_deoptimization() const      { return _mark_for_deoptimization_status != not_marked; }

   227   void  mark_for_deoptimization(bool inc_recompile_counts = true) {

   228     _mark_for_deoptimization_status = (inc_recompile_counts ? deoptimize : deoptimize_noupdate);

   229   }

   230   bool update_recompile_counts() const {

   231     // Update recompile counts when either the update is explicitly requested (deoptimize)

   232     // or the nmethod is not marked for deoptimization at all (not_marked).

   233     // The latter happens during uncommon traps when deoptimized nmethod is made not entrant.

   234     return _mark_for_deoptimization_status != deoptimize_noupdate;

   235   }

   236 

   237   // tells whether frames described by this nmethod can be deoptimized

   238   // note: native wrappers cannot be deoptimized.

   239   bool can_be_deoptimized() const { return is_java_method(); }

   240 

   241   virtual oop oop_at(int index) const = 0;

   242   virtual Metadata* metadata_at(int index) const = 0;

   243 

   244   address scopes_data_begin() const { return _scopes_data_begin; }

   245   virtual address scopes_data_end() const = 0;

   246   int scopes_data_size() const { return scopes_data_end() - scopes_data_begin(); }

   247 

   248   virtual PcDesc* scopes_pcs_begin() const = 0;

   249   virtual PcDesc* scopes_pcs_end() const = 0;

   250   int scopes_pcs_size() const { return (intptr_t) scopes_pcs_end() - (intptr_t) scopes_pcs_begin(); }

   251 

   252   address insts_begin() const { return code_begin(); }

   253   address insts_end() const { return stub_begin(); }

   254   bool insts_contains(address addr) const { return insts_begin() <= addr && addr < insts_end(); }

   255   int insts_size() const { return insts_end() - insts_begin(); }

   256 

   257   virtual address consts_begin() const = 0;

   258   virtual address consts_end() const = 0;

   259   bool consts_contains(address addr) const { return consts_begin() <= addr && addr < consts_end(); }

   260   int consts_size() const { return consts_end() - consts_begin(); }

   261 

   262   virtual address stub_begin() const = 0;

   263   virtual address stub_end() const = 0;

   264   bool stub_contains(address addr) const { return stub_begin() <= addr && addr < stub_end(); }

   265   int stub_size() const { return stub_end() - stub_begin(); }

   266 

   267   virtual address handler_table_begin() const = 0;

   268   virtual address handler_table_end() const = 0;

   269   bool handler_table_contains(address addr) const { return handler_table_begin() <= addr && addr < handler_table_end(); }

   270   int handler_table_size() const { return handler_table_end() - handler_table_begin(); }

   271 

   272   virtual address nul_chk_table_begin() const = 0;

   273   virtual address nul_chk_table_end() const = 0;

   274   bool nul_chk_table_contains(address addr) const { return nul_chk_table_begin() <= addr && addr < nul_chk_table_end(); }

   275   int nul_chk_table_size() const { return nul_chk_table_end() - nul_chk_table_begin(); }

   276 

   277   virtual oop* oop_addr_at(int index) const = 0;

   278   virtual Metadata** metadata_addr_at(int index) const = 0;

   279   virtual void    set_original_pc(const frame* fr, address pc) = 0;

   280 

   281   // Exception cache support

   282   // Note: _exception_cache may be read concurrently. We rely on memory_order_consume here.

   283   ExceptionCache* exception_cache() const         { return _exception_cache; }

   284   void set_exception_cache(ExceptionCache *ec)    { _exception_cache = ec; }

   285   void release_set_exception_cache(ExceptionCache *ec) { OrderAccess::release_store_ptr(&_exception_cache, ec); }

   286   address handler_for_exception_and_pc(Handle exception, address pc);

   287   void add_handler_for_exception_and_pc(Handle exception, address pc, address handler);

   288   void clean_exception_cache(BoolObjectClosure* is_alive);

   289 

   290   void add_exception_cache_entry(ExceptionCache* new_entry);

   291   ExceptionCache* exception_cache_entry_for_exception(Handle exception);

   292 

   293   // MethodHandle

   294   bool is_method_handle_return(address return_pc);

   295   address deopt_mh_handler_begin() const  { return _deopt_mh_handler_begin; }

   296 

   297   address deopt_handler_begin() const { return _deopt_handler_begin; }

   298   virtual address get_original_pc(const frame* fr) = 0;

   299   // Deopt

   300   // Return true is the PC is one would expect if the frame is being deopted.

   301   bool is_deopt_pc      (address pc) { return is_deopt_entry(pc) || is_deopt_mh_entry(pc); }

   302   bool is_deopt_mh_entry(address pc) { return pc == deopt_mh_handler_begin(); }

   303   bool is_deopt_entry(address pc);

   304 

   305   virtual bool can_convert_to_zombie() = 0;

   306   virtual const char* compile_kind() const = 0;

   307   virtual int get_state() const = 0;

   308 

   309   const char* state() const;

   310 

   311   bool is_far_code() const { return _is_far_code; }

   312 

   313   bool inlinecache_check_contains(address addr) const {

   314     return (addr >= code_begin() && addr < verified_entry_point());

   315   }

   316 

   317   void preserve_callee_argument_oops(frame fr, const RegisterMap *reg_map, OopClosure* f);

   318 

   319   // implicit exceptions support

   320   virtual address continuation_for_implicit_exception(address pc) { return NULL; }

   321 

   322   static address get_deopt_original_pc(const frame* fr);

   323 

   324   // Inline cache support

   325   void cleanup_inline_caches(bool clean_all = false);

   326   virtual void clear_inline_caches();

   327   void clear_ic_stubs();

   328 

   329   // Verify and count cached icholder relocations.

   330   int  verify_icholder_relocations();

   331   void verify_oop_relocations();

   332 

   333   virtual bool is_evol_dependent_on(Klass* dependee) = 0;

   334   // Fast breakpoint support. Tells if this compiled method is

   335   // dependent on the given method. Returns true if this nmethod

   336   // corresponds to the given method as well.

   337   virtual bool is_dependent_on_method(Method* dependee) = 0;

   338 

   339   Method* attached_method(address call_pc);

   340   Method* attached_method_before_pc(address pc);

   341 

   342   virtual void metadata_do(void f(Metadata*)) = 0;

   343 

   344   // GC support

   345 

   346   void set_unloading_next(CompiledMethod* next) { _unloading_next = next; }

   347   CompiledMethod* unloading_next()              { return _unloading_next; }

   348 

   349   void static clean_ic_if_metadata_is_dead(CompiledIC *ic, BoolObjectClosure *is_alive);

   350 

   351   // Check that all metadata is still alive

   352   void verify_metadata_loaders(address low_boundary, BoolObjectClosure* is_alive);

   353 

   354   virtual void do_unloading(BoolObjectClosure* is_alive, bool unloading_occurred);

   355   //  The parallel versions are used by G1.

   356   virtual bool do_unloading_parallel(BoolObjectClosure* is_alive, bool unloading_occurred);

   357   virtual void do_unloading_parallel_postponed(BoolObjectClosure* is_alive, bool unloading_occurred);

   358 

   359   static unsigned char global_unloading_clock()   { return _global_unloading_clock; }

   360   static void increase_unloading_clock();

   361 

   362   void set_unloading_clock(unsigned char unloading_clock);

   363   unsigned char unloading_clock();

   364 

   365 protected:

   366   virtual bool do_unloading_oops(address low_boundary, BoolObjectClosure* is_alive, bool unloading_occurred) = 0;

   367 #if INCLUDE_JVMCI

   368   virtual bool do_unloading_jvmci(BoolObjectClosure* is_alive, bool unloading_occurred) = 0;

   369 #endif

   370 

   371 private:

   372   // GC support to help figure out if an nmethod has been

   373   // cleaned/unloaded by the current GC.

   374   static unsigned char _global_unloading_clock;

   375 

   376   volatile unsigned char _unloading_clock;   // Incremented after GC unloaded/cleaned the nmethod

   377 

   378   PcDesc* find_pc_desc(address pc, bool approximate) {

   379     return _pc_desc_container.find_pc_desc(pc, approximate, PcDescSearch(code_begin(), scopes_pcs_begin(), scopes_pcs_end()));

   380   }

   381 

   382 protected:

   383   union {

   384     // Used by G1 to chain nmethods.

   385     CompiledMethod* _unloading_next;

   386     // Used by non-G1 GCs to chain nmethods.

   387     nmethod* _scavenge_root_link; // from CodeCache::scavenge_root_nmethods

   388   };

   389 };

   390 

   391 #endif //SHARE_VM_CODE_COMPILEDMETHOD_HPP