1 /*

        2  * Copyright 1997-2010 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  */

       24 

       25 # include "incls/_precompiled.incl"

       26 # include "incls/_nmethod.cpp.incl"

       27 

       28 #ifdef DTRACE_ENABLED

       29 

       30 // Only bother with this argument setup if dtrace is available

       31 

       32 HS_DTRACE_PROBE_DECL8(hotspot, compiled__method__load,

       33   const char*, int, const char*, int, const char*, int, void*, size_t);

       34 

       35 HS_DTRACE_PROBE_DECL6(hotspot, compiled__method__unload,

       36   char*, int, char*, int, char*, int);

       37 

       38 #define DTRACE_METHOD_UNLOAD_PROBE(method)                                \

       39   {                                                                       \

       40     methodOop m = (method);                                               \

       41     if (m != NULL) {                                                      \

       42       symbolOop klass_name = m->klass_name();                             \

       43       symbolOop name = m->name();                                         \

       44       symbolOop signature = m->signature();                               \

       45       HS_DTRACE_PROBE6(hotspot, compiled__method__unload,                 \

       46         klass_name->bytes(), klass_name->utf8_length(),                   \

       47         name->bytes(), name->utf8_length(),                               \

       48         signature->bytes(), signature->utf8_length());                    \

       49     }                                                                     \

       50   }

       51 

       52 #else //  ndef DTRACE_ENABLED

       53 

       54 #define DTRACE_METHOD_UNLOAD_PROBE(method)

       55 

       56 #endif

       57 

       58 bool nmethod::is_compiled_by_c1() const {

       59   if (compiler() == NULL || method() == NULL)  return false;  // can happen during debug printing

       60   if (is_native_method()) return false;

       61   return compiler()->is_c1();

       62 }

       63 bool nmethod::is_compiled_by_c2() const {

       64   if (compiler() == NULL || method() == NULL)  return false;  // can happen during debug printing

       65   if (is_native_method()) return false;

       66   return compiler()->is_c2();

       67 }

       68 

       69 

       70 

       71 //---------------------------------------------------------------------------------

       72 // NMethod statistics

       73 // They are printed under various flags, including:

       74 //   PrintC1Statistics, PrintOptoStatistics, LogVMOutput, and LogCompilation.

       75 // (In the latter two cases, they like other stats are printed to the log only.)

       76 

       77 #ifndef PRODUCT

       78 // These variables are put into one block to reduce relocations

       79 // and make it simpler to print from the debugger.

       80 static

       81 struct nmethod_stats_struct {

       82   int nmethod_count;

       83   int total_size;

       84   int relocation_size;

       85   int code_size;

       86   int stub_size;

       87   int consts_size;

       88   int scopes_data_size;

       89   int scopes_pcs_size;

       90   int dependencies_size;

       91   int handler_table_size;

       92   int nul_chk_table_size;

       93   int oops_size;

       94 

       95   void note_nmethod(nmethod* nm) {

       96     nmethod_count += 1;

       97     total_size          += nm->size();

       98     relocation_size     += nm->relocation_size();

       99     code_size           += nm->code_size();

      100     stub_size           += nm->stub_size();

      101     consts_size         += nm->consts_size();

      102     scopes_data_size    += nm->scopes_data_size();

      103     scopes_pcs_size     += nm->scopes_pcs_size();

      104     dependencies_size   += nm->dependencies_size();

      105     handler_table_size  += nm->handler_table_size();

      106     nul_chk_table_size  += nm->nul_chk_table_size();

      107     oops_size += nm->oops_size();

      108   }

      109   void print_nmethod_stats() {

      110     if (nmethod_count == 0)  return;

      111     tty->print_cr("Statistics for %d bytecoded nmethods:", nmethod_count);

      112     if (total_size != 0)          tty->print_cr(" total in heap  = %d", total_size);

      113     if (relocation_size != 0)     tty->print_cr(" relocation     = %d", relocation_size);

      114     if (code_size != 0)           tty->print_cr(" main code      = %d", code_size);

      115     if (stub_size != 0)           tty->print_cr(" stub code      = %d", stub_size);

      116     if (consts_size != 0)         tty->print_cr(" constants      = %d", consts_size);

      117     if (scopes_data_size != 0)    tty->print_cr(" scopes data    = %d", scopes_data_size);

      118     if (scopes_pcs_size != 0)     tty->print_cr(" scopes pcs     = %d", scopes_pcs_size);

      119     if (dependencies_size != 0)   tty->print_cr(" dependencies   = %d", dependencies_size);

      120     if (handler_table_size != 0)  tty->print_cr(" handler table  = %d", handler_table_size);

      121     if (nul_chk_table_size != 0)  tty->print_cr(" nul chk table  = %d", nul_chk_table_size);

      122     if (oops_size != 0)           tty->print_cr(" oops           = %d", oops_size);

      123   }

      124 

      125   int native_nmethod_count;

      126   int native_total_size;

      127   int native_relocation_size;

      128   int native_code_size;

      129   int native_oops_size;

      130   void note_native_nmethod(nmethod* nm) {

      131     native_nmethod_count += 1;

      132     native_total_size       += nm->size();

      133     native_relocation_size  += nm->relocation_size();

      134     native_code_size        += nm->code_size();

      135     native_oops_size        += nm->oops_size();

      136   }

      137   void print_native_nmethod_stats() {

      138     if (native_nmethod_count == 0)  return;

      139     tty->print_cr("Statistics for %d native nmethods:", native_nmethod_count);

      140     if (native_total_size != 0)       tty->print_cr(" N. total size  = %d", native_total_size);

      141     if (native_relocation_size != 0)  tty->print_cr(" N. relocation  = %d", native_relocation_size);

      142     if (native_code_size != 0)        tty->print_cr(" N. main code   = %d", native_code_size);

      143     if (native_oops_size != 0)        tty->print_cr(" N. oops        = %d", native_oops_size);

      144   }

      145 

      146   int pc_desc_resets;   // number of resets (= number of caches)

      147   int pc_desc_queries;  // queries to nmethod::find_pc_desc

      148   int pc_desc_approx;   // number of those which have approximate true

      149   int pc_desc_repeats;  // number of _last_pc_desc hits

      150   int pc_desc_hits;     // number of LRU cache hits

      151   int pc_desc_tests;    // total number of PcDesc examinations

      152   int pc_desc_searches; // total number of quasi-binary search steps

      153   int pc_desc_adds;     // number of LUR cache insertions

      154 

      155   void print_pc_stats() {

      156     tty->print_cr("PcDesc Statistics:  %d queries, %.2f comparisons per query",

      157                   pc_desc_queries,

      158                   (double)(pc_desc_tests + pc_desc_searches)

      159                   / pc_desc_queries);

      160     tty->print_cr("  caches=%d queries=%d/%d, hits=%d+%d, tests=%d+%d, adds=%d",

      161                   pc_desc_resets,

      162                   pc_desc_queries, pc_desc_approx,

      163                   pc_desc_repeats, pc_desc_hits,

      164                   pc_desc_tests, pc_desc_searches, pc_desc_adds);

      165   }

      166 } nmethod_stats;

      167 #endif //PRODUCT

      168 

      169 //---------------------------------------------------------------------------------

      170 

      171 

      172 // The _unwind_handler is a special marker address, which says that

      173 // for given exception oop and address, the frame should be removed

      174 // as the tuple cannot be caught in the nmethod

      175 address ExceptionCache::_unwind_handler = (address) -1;

      176 

      177 

      178 ExceptionCache::ExceptionCache(Handle exception, address pc, address handler) {

      179   assert(pc != NULL, "Must be non null");

      180   assert(exception.not_null(), "Must be non null");

      181   assert(handler != NULL, "Must be non null");

      182 

      183   _count = 0;

      184   _exception_type = exception->klass();

      185   _next = NULL;

      186 

      187   add_address_and_handler(pc,handler);

      188 }

      189 

      190 

      191 address ExceptionCache::match(Handle exception, address pc) {

      192   assert(pc != NULL,"Must be non null");

      193   assert(exception.not_null(),"Must be non null");

      194   if (exception->klass() == exception_type()) {

      195     return (test_address(pc));

      196   }

      197 

      198   return NULL;

      199 }

      200 

      201 

      202 bool ExceptionCache::match_exception_with_space(Handle exception) {

      203   assert(exception.not_null(),"Must be non null");

      204   if (exception->klass() == exception_type() && count() < cache_size) {

      205     return true;

      206   }

      207   return false;

      208 }

      209 

      210 

      211 address ExceptionCache::test_address(address addr) {

      212   for (int i=0; i<count(); i++) {

      213     if (pc_at(i) == addr) {

      214       return handler_at(i);

      215     }

      216   }

      217   return NULL;

      218 }

      219 

      220 

      221 bool ExceptionCache::add_address_and_handler(address addr, address handler) {

      222   if (test_address(addr) == handler) return true;

      223   if (count() < cache_size) {

      224     set_pc_at(count(),addr);

      225     set_handler_at(count(), handler);

      226     increment_count();

      227     return true;

      228   }

      229   return false;

      230 }

      231 

      232 

      233 // private method for handling exception cache

      234 // These methods are private, and used to manipulate the exception cache

      235 // directly.

      236 ExceptionCache* nmethod::exception_cache_entry_for_exception(Handle exception) {

      237   ExceptionCache* ec = exception_cache();

      238   while (ec != NULL) {

      239     if (ec->match_exception_with_space(exception)) {

      240       return ec;

      241     }

      242     ec = ec->next();

      243   }

      244   return NULL;

      245 }

      246 

      247 

      248 //-----------------------------------------------------------------------------

      249 

      250 

      251 // Helper used by both find_pc_desc methods.

      252 static inline bool match_desc(PcDesc* pc, int pc_offset, bool approximate) {

      253   NOT_PRODUCT(++nmethod_stats.pc_desc_tests);

      254   if (!approximate)

      255     return pc->pc_offset() == pc_offset;

      256   else

      257     return (pc-1)->pc_offset() < pc_offset && pc_offset <= pc->pc_offset();

      258 }

      259 

      260 void PcDescCache::reset_to(PcDesc* initial_pc_desc) {

      261   if (initial_pc_desc == NULL) {

      262     _last_pc_desc = NULL;  // native method

      263     return;

      264   }

      265   NOT_PRODUCT(++nmethod_stats.pc_desc_resets);

      266   // reset the cache by filling it with benign (non-null) values

      267   assert(initial_pc_desc->pc_offset() < 0, "must be sentinel");

      268   _last_pc_desc = initial_pc_desc + 1;  // first valid one is after sentinel

      269   for (int i = 0; i < cache_size; i++)

      270     _pc_descs[i] = initial_pc_desc;

      271 }

      272 

      273 PcDesc* PcDescCache::find_pc_desc(int pc_offset, bool approximate) {

      274   NOT_PRODUCT(++nmethod_stats.pc_desc_queries);

      275   NOT_PRODUCT(if (approximate)  ++nmethod_stats.pc_desc_approx);

      276 

      277   // In order to prevent race conditions do not load cache elements

      278   // repeatedly, but use a local copy:

      279   PcDesc* res;

      280 

      281   // Step one:  Check the most recently returned value.

      282   res = _last_pc_desc;

      283   if (res == NULL)  return NULL;  // native method; no PcDescs at all

      284   if (match_desc(res, pc_offset, approximate)) {

      285     NOT_PRODUCT(++nmethod_stats.pc_desc_repeats);

      286     return res;

      287   }

      288 

      289   // Step two:  Check the LRU cache.

      290   for (int i = 0; i < cache_size; i++) {

      291     res = _pc_descs[i];

      292     if (res->pc_offset() < 0)  break;  // optimization: skip empty cache

      293     if (match_desc(res, pc_offset, approximate)) {

      294       NOT_PRODUCT(++nmethod_stats.pc_desc_hits);

      295       _last_pc_desc = res;  // record this cache hit in case of repeat

      296       return res;

      297     }

      298   }

      299 

      300   // Report failure.

      301   return NULL;

      302 }

      303 

      304 void PcDescCache::add_pc_desc(PcDesc* pc_desc) {

      305   NOT_PRODUCT(++nmethod_stats.pc_desc_adds);

      306   // Update the LRU cache by shifting pc_desc forward:

      307   for (int i = 0; i < cache_size; i++)  {

      308     PcDesc* next = _pc_descs[i];

      309     _pc_descs[i] = pc_desc;

      310     pc_desc = next;

      311   }

      312   // Note:  Do not update _last_pc_desc.  It fronts for the LRU cache.

      313 }

      314 

      315 // adjust pcs_size so that it is a multiple of both oopSize and

      316 // sizeof(PcDesc) (assumes that if sizeof(PcDesc) is not a multiple

      317 // of oopSize, then 2*sizeof(PcDesc) is)

      318 static int  adjust_pcs_size(int pcs_size) {

      319   int nsize = round_to(pcs_size,   oopSize);

      320   if ((nsize % sizeof(PcDesc)) != 0) {

      321     nsize = pcs_size + sizeof(PcDesc);

      322   }

      323   assert((nsize %  oopSize) == 0, "correct alignment");

      324   return nsize;

      325 }

      326 

      327 //-----------------------------------------------------------------------------

      328 

      329 

      330 void nmethod::add_exception_cache_entry(ExceptionCache* new_entry) {

      331   assert(ExceptionCache_lock->owned_by_self(),"Must hold the ExceptionCache_lock");

      332   assert(new_entry != NULL,"Must be non null");

      333   assert(new_entry->next() == NULL, "Must be null");

      334 

      335   if (exception_cache() != NULL) {

      336     new_entry->set_next(exception_cache());

      337   }

      338   set_exception_cache(new_entry);

      339 }

      340 

      341 void nmethod::remove_from_exception_cache(ExceptionCache* ec) {

      342   ExceptionCache* prev = NULL;

      343   ExceptionCache* curr = exception_cache();

      344   assert(curr != NULL, "nothing to remove");

      345   // find the previous and next entry of ec

      346   while (curr != ec) {

      347     prev = curr;

      348     curr = curr->next();

      349     assert(curr != NULL, "ExceptionCache not found");

      350   }

      351   // now: curr == ec

      352   ExceptionCache* next = curr->next();

      353   if (prev == NULL) {

      354     set_exception_cache(next);

      355   } else {

      356     prev->set_next(next);

      357   }

      358   delete curr;

      359 }

      360 

      361 

      362 // public method for accessing the exception cache

      363 // These are the public access methods.

      364 address nmethod::handler_for_exception_and_pc(Handle exception, address pc) {

      365   // We never grab a lock to read the exception cache, so we may

      366   // have false negatives. This is okay, as it can only happen during

      367   // the first few exception lookups for a given nmethod.

      368   ExceptionCache* ec = exception_cache();

      369   while (ec != NULL) {

      370     address ret_val;

      371     if ((ret_val = ec->match(exception,pc)) != NULL) {

      372       return ret_val;

      373     }

      374     ec = ec->next();

      375   }

      376   return NULL;

      377 }

      378 

      379 

      380 void nmethod::add_handler_for_exception_and_pc(Handle exception, address pc, address handler) {

      381   // There are potential race conditions during exception cache updates, so we

      382   // must own the ExceptionCache_lock before doing ANY modifications. Because

      383   // we don't lock during reads, it is possible to have several threads attempt

      384   // to update the cache with the same data. We need to check for already inserted

      385   // copies of the current data before adding it.

      386 

      387   MutexLocker ml(ExceptionCache_lock);

      388   ExceptionCache* target_entry = exception_cache_entry_for_exception(exception);

      389 

      390   if (target_entry == NULL || !target_entry->add_address_and_handler(pc,handler)) {

      391     target_entry = new ExceptionCache(exception,pc,handler);

      392     add_exception_cache_entry(target_entry);

      393   }

      394 }

      395 

      396 

      397 //-------------end of code for ExceptionCache--------------

      398 

      399 

      400 void nmFlags::clear() {

      401   assert(sizeof(nmFlags) == sizeof(int), "using more than one word for nmFlags");

      402   *(jint*)this = 0;

      403 }

      404 

      405 int nmethod::total_size() const {

      406   return

      407     code_size()          +

      408     stub_size()          +

      409     consts_size()        +

      410     scopes_data_size()   +

      411     scopes_pcs_size()    +

      412     handler_table_size() +

      413     nul_chk_table_size();

      414 }

      415 

      416 const char* nmethod::compile_kind() const {

      417   if (is_osr_method())     return "osr";

      418   if (method() != NULL && is_native_method())  return "c2n";

      419   return NULL;

      420 }

      421 

      422 // %%% This variable is no longer used?

      423 int nmethod::_zombie_instruction_size = NativeJump::instruction_size;

      424 

      425 

      426 nmethod* nmethod::new_native_nmethod(methodHandle method,

      427   CodeBuffer *code_buffer,

      428   int vep_offset,

      429   int frame_complete,

      430   int frame_size,

      431   ByteSize basic_lock_owner_sp_offset,

      432   ByteSize basic_lock_sp_offset,

      433   OopMapSet* oop_maps) {

      434   // create nmethod

      435   nmethod* nm = NULL;

      436   {

      437     MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

      438     int native_nmethod_size = allocation_size(code_buffer, sizeof(nmethod));

      439     CodeOffsets offsets;

      440     offsets.set_value(CodeOffsets::Verified_Entry, vep_offset);

      441     offsets.set_value(CodeOffsets::Frame_Complete, frame_complete);

      442     nm = new (native_nmethod_size)

      443       nmethod(method(), native_nmethod_size, &offsets,

      444               code_buffer, frame_size,

      445               basic_lock_owner_sp_offset, basic_lock_sp_offset,

      446               oop_maps);

      447     NOT_PRODUCT(if (nm != NULL)  nmethod_stats.note_native_nmethod(nm));

      448     if (PrintAssembly && nm != NULL)

      449       Disassembler::decode(nm);

      450   }

      451   // verify nmethod

      452   debug_only(if (nm) nm->verify();) // might block

      453 

      454   if (nm != NULL) {

      455     nm->log_new_nmethod();

      456   }

      457 

      458   return nm;

      459 }

      460 

      461 #ifdef HAVE_DTRACE_H

      462 nmethod* nmethod::new_dtrace_nmethod(methodHandle method,

      463                                      CodeBuffer *code_buffer,

      464                                      int vep_offset,

      465                                      int trap_offset,

      466                                      int frame_complete,

      467                                      int frame_size) {

      468   // create nmethod

      469   nmethod* nm = NULL;

      470   {

      471     MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

      472     int nmethod_size = allocation_size(code_buffer, sizeof(nmethod));

      473     CodeOffsets offsets;

      474     offsets.set_value(CodeOffsets::Verified_Entry, vep_offset);

      475     offsets.set_value(CodeOffsets::Dtrace_trap, trap_offset);

      476     offsets.set_value(CodeOffsets::Frame_Complete, frame_complete);

      477 

      478     nm = new (nmethod_size) nmethod(method(), nmethod_size, &offsets, code_buffer, frame_size);

      479 

      480     NOT_PRODUCT(if (nm != NULL)  nmethod_stats.note_nmethod(nm));

      481     if (PrintAssembly && nm != NULL)

      482       Disassembler::decode(nm);

      483   }

      484   // verify nmethod

      485   debug_only(if (nm) nm->verify();) // might block

      486 

      487   if (nm != NULL) {

      488     nm->log_new_nmethod();

      489   }

      490 

      491   return nm;

      492 }

      493 

      494 #endif // def HAVE_DTRACE_H

      495 

      496 nmethod* nmethod::new_nmethod(methodHandle method,

      497   int compile_id,

      498   int entry_bci,

      499   CodeOffsets* offsets,

      500   int orig_pc_offset,

      501   DebugInformationRecorder* debug_info,

      502   Dependencies* dependencies,

      503   CodeBuffer* code_buffer, int frame_size,

      504   OopMapSet* oop_maps,

      505   ExceptionHandlerTable* handler_table,

      506   ImplicitExceptionTable* nul_chk_table,

      507   AbstractCompiler* compiler,

      508   int comp_level

      509 )

      510 {

      511   assert(debug_info->oop_recorder() == code_buffer->oop_recorder(), "shared OR");

      512   // create nmethod

      513   nmethod* nm = NULL;

      514   { MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);

      515     int nmethod_size =

      516       allocation_size(code_buffer, sizeof(nmethod))

      517       + adjust_pcs_size(debug_info->pcs_size())

      518       + round_to(dependencies->size_in_bytes() , oopSize)

      519       + round_to(handler_table->size_in_bytes(), oopSize)

      520       + round_to(nul_chk_table->size_in_bytes(), oopSize)

      521       + round_to(debug_info->data_size()       , oopSize);

      522     nm = new (nmethod_size)

      523       nmethod(method(), nmethod_size, compile_id, entry_bci, offsets,

      524               orig_pc_offset, debug_info, dependencies, code_buffer, frame_size,

      525               oop_maps,

      526               handler_table,

      527               nul_chk_table,

      528               compiler,

      529               comp_level);

      530     if (nm != NULL) {

      531       // To make dependency checking during class loading fast, record

      532       // the nmethod dependencies in the classes it is dependent on.

      533       // This allows the dependency checking code to simply walk the

      534       // class hierarchy above the loaded class, checking only nmethods

      535       // which are dependent on those classes.  The slow way is to

      536       // check every nmethod for dependencies which makes it linear in

      537       // the number of methods compiled.  For applications with a lot

      538       // classes the slow way is too slow.

      539       for (Dependencies::DepStream deps(nm); deps.next(); ) {

      540         klassOop klass = deps.context_type();

      541         if (klass == NULL)  continue;  // ignore things like evol_method

      542 

      543         // record this nmethod as dependent on this klass

      544         instanceKlass::cast(klass)->add_dependent_nmethod(nm);

      545       }

      546     }

      547     NOT_PRODUCT(if (nm != NULL)  nmethod_stats.note_nmethod(nm));

      548     if (PrintAssembly && nm != NULL)

      549       Disassembler::decode(nm);

      550   }

      551 

      552   // verify nmethod

      553   debug_only(if (nm) nm->verify();) // might block

      554 

      555   if (nm != NULL) {

      556     nm->log_new_nmethod();

      557   }

      558 

      559   // done

      560   return nm;

      561 }

      562 

      563 

      564 // For native wrappers

      565 nmethod::nmethod(

      566   methodOop method,

      567   int nmethod_size,

      568   CodeOffsets* offsets,

      569   CodeBuffer* code_buffer,

      570   int frame_size,

      571   ByteSize basic_lock_owner_sp_offset,

      572   ByteSize basic_lock_sp_offset,

      573   OopMapSet* oop_maps )

      574   : CodeBlob("native nmethod", code_buffer, sizeof(nmethod),

      575              nmethod_size, offsets->value(CodeOffsets::Frame_Complete), frame_size, oop_maps),

      576   _compiled_synchronized_native_basic_lock_owner_sp_offset(basic_lock_owner_sp_offset),

      577   _compiled_synchronized_native_basic_lock_sp_offset(basic_lock_sp_offset)

      578 {

      579   {

      580     debug_only(No_Safepoint_Verifier nsv;)

      581     assert_locked_or_safepoint(CodeCache_lock);

      582 

      583     NOT_PRODUCT(_has_debug_info = false);

      584     _oops_do_mark_link       = NULL;

      585     _method                  = method;

      586     _entry_bci               = InvocationEntryBci;

      587     _osr_link                = NULL;

      588     _scavenge_root_link      = NULL;

      589     _scavenge_root_state     = 0;

      590     _saved_nmethod_link      = NULL;

      591     _compiler                = NULL;

      592     // We have no exception handler or deopt handler make the

      593     // values something that will never match a pc like the nmethod vtable entry

      594     _exception_offset        = 0;

      595     _deoptimize_offset       = 0;

      596     _deoptimize_mh_offset    = 0;

      597     _orig_pc_offset          = 0;

      598 #ifdef HAVE_DTRACE_H

      599     _trap_offset             = 0;

      600 #endif // def HAVE_DTRACE_H

      601     _stub_offset             = data_offset();

      602     _consts_offset           = data_offset();

      603     _scopes_data_offset      = data_offset();

      604     _scopes_pcs_offset       = _scopes_data_offset;

      605     _dependencies_offset     = _scopes_pcs_offset;

      606     _handler_table_offset    = _dependencies_offset;

      607     _nul_chk_table_offset    = _handler_table_offset;

      608     _nmethod_end_offset      = _nul_chk_table_offset;

      609     _compile_id              = 0;  // default

      610     _comp_level              = CompLevel_none;

      611     _entry_point             = instructions_begin();

      612     _verified_entry_point    = instructions_begin() + offsets->value(CodeOffsets::Verified_Entry);

      613     _osr_entry_point         = NULL;

      614     _exception_cache         = NULL;

      615     _pc_desc_cache.reset_to(NULL);

      616 

      617     flags.clear();

      618     flags.state              = alive;

      619     _markedForDeoptimization = 0;

      620 

      621     _lock_count = 0;

      622     _stack_traversal_mark    = 0;

      623 

      624     code_buffer->copy_oops_to(this);

      625     debug_only(verify_scavenge_root_oops());

      626     CodeCache::commit(this);

      627     VTune::create_nmethod(this);

      628   }

      629 

      630   if (PrintNativeNMethods || PrintDebugInfo || PrintRelocations || PrintDependencies) {

      631     ttyLocker ttyl;  // keep the following output all in one block

      632     // This output goes directly to the tty, not the compiler log.

      633     // To enable tools to match it up with the compilation activity,

      634     // be sure to tag this tty output with the compile ID.

      635     if (xtty != NULL) {

      636       xtty->begin_head("print_native_nmethod");

      637       xtty->method(_method);

      638       xtty->stamp();

      639       xtty->end_head(" address='" INTPTR_FORMAT "'", (intptr_t) this);

      640     }

      641     // print the header part first

      642     print();

      643     // then print the requested information

      644     if (PrintNativeNMethods) {

      645       print_code();

      646       oop_maps->print();

      647     }

      648     if (PrintRelocations) {

      649       print_relocations();

      650     }

      651     if (xtty != NULL) {

      652       xtty->tail("print_native_nmethod");

      653     }

      654   }

      655   Events::log("Create nmethod " INTPTR_FORMAT, this);

      656 }

      657 

      658 // For dtrace wrappers

      659 #ifdef HAVE_DTRACE_H

      660 nmethod::nmethod(

      661   methodOop method,

      662   int nmethod_size,

      663   CodeOffsets* offsets,

      664   CodeBuffer* code_buffer,

      665   int frame_size)

      666   : CodeBlob("dtrace nmethod", code_buffer, sizeof(nmethod),

      667              nmethod_size, offsets->value(CodeOffsets::Frame_Complete), frame_size, NULL),

      668   _compiled_synchronized_native_basic_lock_owner_sp_offset(in_ByteSize(-1)),

      669   _compiled_synchronized_native_basic_lock_sp_offset(in_ByteSize(-1))

      670 {

      671   {

      672     debug_only(No_Safepoint_Verifier nsv;)

      673     assert_locked_or_safepoint(CodeCache_lock);

      674 

      675     NOT_PRODUCT(_has_debug_info = false);

      676     _oops_do_mark_link       = NULL;

      677     _method                  = method;

      678     _entry_bci               = InvocationEntryBci;

      679     _osr_link                = NULL;

      680     _scavenge_root_link      = NULL;

      681     _scavenge_root_state     = 0;

      682     _compiler                = NULL;

      683     // We have no exception handler or deopt handler make the

      684     // values something that will never match a pc like the nmethod vtable entry

      685     _exception_offset        = 0;

      686     _deoptimize_offset       = 0;

      687     _deoptimize_mh_offset    = 0;

      688     _unwind_handler_offset   = -1;

      689     _trap_offset             = offsets->value(CodeOffsets::Dtrace_trap);

      690     _orig_pc_offset          = 0;

      691     _stub_offset             = data_offset();

      692     _consts_offset           = data_offset();

      693     _scopes_data_offset      = data_offset();

      694     _scopes_pcs_offset       = _scopes_data_offset;

      695     _dependencies_offset     = _scopes_pcs_offset;

      696     _handler_table_offset    = _dependencies_offset;

      697     _nul_chk_table_offset    = _handler_table_offset;

      698     _nmethod_end_offset      = _nul_chk_table_offset;

      699     _compile_id              = 0;  // default

      700     _comp_level              = CompLevel_none;

      701     _entry_point             = instructions_begin();

      702     _verified_entry_point    = instructions_begin() + offsets->value(CodeOffsets::Verified_Entry);

      703     _osr_entry_point         = NULL;

      704     _exception_cache         = NULL;

      705     _pc_desc_cache.reset_to(NULL);

      706 

      707     flags.clear();

      708     flags.state              = alive;

      709     _markedForDeoptimization = 0;

      710 

      711     _lock_count = 0;

      712     _stack_traversal_mark    = 0;

      713 

      714     code_buffer->copy_oops_to(this);

      715     debug_only(verify_scavenge_root_oops());

      716     CodeCache::commit(this);

      717     VTune::create_nmethod(this);

      718   }

      719 

      720   if (PrintNMethods || PrintDebugInfo || PrintRelocations || PrintDependencies) {

      721     ttyLocker ttyl;  // keep the following output all in one block

      722     // This output goes directly to the tty, not the compiler log.

      723     // To enable tools to match it up with the compilation activity,

      724     // be sure to tag this tty output with the compile ID.

      725     if (xtty != NULL) {

      726       xtty->begin_head("print_dtrace_nmethod");

      727       xtty->method(_method);

      728       xtty->stamp();

      729       xtty->end_head(" address='" INTPTR_FORMAT "'", (intptr_t) this);

      730     }

      731     // print the header part first

      732     print();

      733     // then print the requested information

      734     if (PrintNMethods) {

      735       print_code();

      736     }

      737     if (PrintRelocations) {

      738       print_relocations();

      739     }

      740     if (xtty != NULL) {

      741       xtty->tail("print_dtrace_nmethod");

      742     }

      743   }

      744   Events::log("Create nmethod " INTPTR_FORMAT, this);

      745 }

      746 #endif // def HAVE_DTRACE_H

      747 

      748 void* nmethod::operator new(size_t size, int nmethod_size) {

      749   // Always leave some room in the CodeCache for I2C/C2I adapters

      750   if (CodeCache::unallocated_capacity() < CodeCacheMinimumFreeSpace) return NULL;

      751   return CodeCache::allocate(nmethod_size);

      752 }

      753 

      754 

      755 nmethod::nmethod(

      756   methodOop method,

      757   int nmethod_size,

      758   int compile_id,

      759   int entry_bci,

      760   CodeOffsets* offsets,

      761   int orig_pc_offset,

      762   DebugInformationRecorder* debug_info,

      763   Dependencies* dependencies,

      764   CodeBuffer *code_buffer,

      765   int frame_size,

      766   OopMapSet* oop_maps,

      767   ExceptionHandlerTable* handler_table,

      768   ImplicitExceptionTable* nul_chk_table,

      769   AbstractCompiler* compiler,

      770   int comp_level

      771   )

      772   : CodeBlob("nmethod", code_buffer, sizeof(nmethod),

      773              nmethod_size, offsets->value(CodeOffsets::Frame_Complete), frame_size, oop_maps),

      774   _compiled_synchronized_native_basic_lock_owner_sp_offset(in_ByteSize(-1)),

      775   _compiled_synchronized_native_basic_lock_sp_offset(in_ByteSize(-1))

      776 {

      777   assert(debug_info->oop_recorder() == code_buffer->oop_recorder(), "shared OR");

      778   {

      779     debug_only(No_Safepoint_Verifier nsv;)

      780     assert_locked_or_safepoint(CodeCache_lock);

      781 

      782     NOT_PRODUCT(_has_debug_info = false);

      783     _oops_do_mark_link       = NULL;

      784     _method                  = method;

      785     _compile_id              = compile_id;

      786     _comp_level              = comp_level;

      787     _entry_bci               = entry_bci;

      788     _osr_link                = NULL;

      789     _scavenge_root_link      = NULL;

      790     _scavenge_root_state     = 0;

      791     _compiler                = compiler;

      792     _orig_pc_offset          = orig_pc_offset;

      793 #ifdef HAVE_DTRACE_H

      794     _trap_offset             = 0;

      795 #endif // def HAVE_DTRACE_H

      796     _stub_offset             = instructions_offset() + code_buffer->total_offset_of(code_buffer->stubs()->start());

      797 

      798     // Exception handler and deopt handler are in the stub section

      799     _exception_offset        = _stub_offset + offsets->value(CodeOffsets::Exceptions);

      800     _deoptimize_offset       = _stub_offset + offsets->value(CodeOffsets::Deopt);

      801     _deoptimize_mh_offset    = _stub_offset + offsets->value(CodeOffsets::DeoptMH);

      802     if (offsets->value(CodeOffsets::UnwindHandler) != -1) {

      803       _unwind_handler_offset   = instructions_offset() + offsets->value(CodeOffsets::UnwindHandler);

      804     } else {

      805       _unwind_handler_offset   = -1;

      806     }

      807     _consts_offset           = instructions_offset() + code_buffer->total_offset_of(code_buffer->consts()->start());

      808     _scopes_data_offset      = data_offset();

      809     _scopes_pcs_offset       = _scopes_data_offset   + round_to(debug_info->data_size         (), oopSize);

      810     _dependencies_offset     = _scopes_pcs_offset    + adjust_pcs_size(debug_info->pcs_size());

      811     _handler_table_offset    = _dependencies_offset  + round_to(dependencies->size_in_bytes (), oopSize);

      812     _nul_chk_table_offset    = _handler_table_offset + round_to(handler_table->size_in_bytes(), oopSize);

      813     _nmethod_end_offset      = _nul_chk_table_offset + round_to(nul_chk_table->size_in_bytes(), oopSize);

      814 

      815     _entry_point             = instructions_begin();

      816     _verified_entry_point    = instructions_begin() + offsets->value(CodeOffsets::Verified_Entry);

      817     _osr_entry_point         = instructions_begin() + offsets->value(CodeOffsets::OSR_Entry);

      818     _exception_cache         = NULL;

      819     _pc_desc_cache.reset_to(scopes_pcs_begin());

      820 

      821     flags.clear();

      822     flags.state              = alive;

      823     _markedForDeoptimization = 0;

      824 

      825     _unload_reported         = false;           // jvmti state

      826 

      827     _lock_count = 0;

      828     _stack_traversal_mark    = 0;

      829 

      830     // Copy contents of ScopeDescRecorder to nmethod

      831     code_buffer->copy_oops_to(this);

      832     debug_info->copy_to(this);

      833     dependencies->copy_to(this);

      834     if (ScavengeRootsInCode && detect_scavenge_root_oops()) {

      835       CodeCache::add_scavenge_root_nmethod(this);

      836     }

      837     debug_only(verify_scavenge_root_oops());

      838 

      839     CodeCache::commit(this);

      840 

      841     VTune::create_nmethod(this);

      842 

      843     // Copy contents of ExceptionHandlerTable to nmethod

      844     handler_table->copy_to(this);

      845     nul_chk_table->copy_to(this);

      846 

      847     // we use the information of entry points to find out if a method is

      848     // static or non static

      849     assert(compiler->is_c2() ||

      850            _method->is_static() == (entry_point() == _verified_entry_point),

      851            " entry points must be same for static methods and vice versa");

      852   }

      853 

      854   bool printnmethods = PrintNMethods

      855     || CompilerOracle::should_print(_method)

      856     || CompilerOracle::has_option_string(_method, "PrintNMethods");

      857   if (printnmethods || PrintDebugInfo || PrintRelocations || PrintDependencies || PrintExceptionHandlers) {

      858     print_nmethod(printnmethods);

      859   }

      860 

      861   // Note: Do not verify in here as the CodeCache_lock is

      862   //       taken which would conflict with the CompiledIC_lock

      863   //       which taken during the verification of call sites.

      864   //       (was bug - gri 10/25/99)

      865 

      866   Events::log("Create nmethod " INTPTR_FORMAT, this);

      867 }

      868 

      869 

      870 // Print a short set of xml attributes to identify this nmethod.  The

      871 // output should be embedded in some other element.

      872 void nmethod::log_identity(xmlStream* log) const {

      873   log->print(" compile_id='%d'", compile_id());

      874   const char* nm_kind = compile_kind();

      875   if (nm_kind != NULL)  log->print(" compile_kind='%s'", nm_kind);

      876   if (compiler() != NULL) {

      877     log->print(" compiler='%s'", compiler()->name());

      878   }

      879 #ifdef TIERED

      880   log->print(" level='%d'", comp_level());

      881 #endif // TIERED

      882 }

      883 

      884 

      885 #define LOG_OFFSET(log, name)                    \

      886   if ((intptr_t)name##_end() - (intptr_t)name##_begin()) \

      887     log->print(" " XSTR(name) "_offset='%d'"    , \

      888                (intptr_t)name##_begin() - (intptr_t)this)

      889 

      890 

      891 void nmethod::log_new_nmethod() const {

      892   if (LogCompilation && xtty != NULL) {

      893     ttyLocker ttyl;

      894     HandleMark hm;

      895     xtty->begin_elem("nmethod");

      896     log_identity(xtty);

      897     xtty->print(" entry='" INTPTR_FORMAT "' size='%d'",

      898                 instructions_begin(), size());

      899     xtty->print(" address='" INTPTR_FORMAT "'", (intptr_t) this);

      900 

      901     LOG_OFFSET(xtty, relocation);

      902     LOG_OFFSET(xtty, code);

      903     LOG_OFFSET(xtty, stub);

      904     LOG_OFFSET(xtty, consts);

      905     LOG_OFFSET(xtty, scopes_data);

      906     LOG_OFFSET(xtty, scopes_pcs);

      907     LOG_OFFSET(xtty, dependencies);

      908     LOG_OFFSET(xtty, handler_table);

      909     LOG_OFFSET(xtty, nul_chk_table);

      910     LOG_OFFSET(xtty, oops);

      911 

      912     xtty->method(method());

      913     xtty->stamp();

      914     xtty->end_elem();

      915   }

      916 }

      917 

      918 #undef LOG_OFFSET

      919 

      920 

      921 // Print out more verbose output usually for a newly created nmethod.

      922 void nmethod::print_on(outputStream* st, const char* title) const {

      923   if (st != NULL) {

      924     ttyLocker ttyl;

      925     // Print a little tag line that looks like +PrintCompilation output:

      926     int tlen = (int) strlen(title);

      927     bool do_nl = false;

      928     if (tlen > 0 && title[tlen-1] == '\n') { tlen--; do_nl = true; }

      929     st->print("%3d%c  %.*s",

      930               compile_id(),

      931               is_osr_method() ? '%' :

      932               method() != NULL &&

      933               is_native_method() ? 'n' : ' ',

      934               tlen, title);

      935 #ifdef TIERED

      936     st->print(" (%d) ", comp_level());

      937 #endif // TIERED

      938     if (WizardMode) st->print(" (" INTPTR_FORMAT ")", this);

      939     if (Universe::heap()->is_gc_active() && method() != NULL) {

      940       st->print("(method)");

      941     } else if (method() != NULL) {

      942         method()->print_short_name(st);

      943       if (is_osr_method())

      944         st->print(" @ %d", osr_entry_bci());

      945       if (method()->code_size() > 0)

      946         st->print(" (%d bytes)", method()->code_size());

      947     }

      948 

      949     if (do_nl)  st->cr();

      950   }

      951 }

      952 

      953 

      954 void nmethod::print_nmethod(bool printmethod) {

      955   ttyLocker ttyl;  // keep the following output all in one block

      956   if (xtty != NULL) {

      957     xtty->begin_head("print_nmethod");

      958     xtty->stamp();

      959     xtty->end_head();

      960   }

      961   // print the header part first

      962   print();

      963   // then print the requested information

      964   if (printmethod) {

      965     print_code();

      966     print_pcs();

      967     oop_maps()->print();

      968   }

      969   if (PrintDebugInfo) {

      970     print_scopes();

      971   }

      972   if (PrintRelocations) {

      973     print_relocations();

      974   }

      975   if (PrintDependencies) {

      976     print_dependencies();

      977   }

      978   if (PrintExceptionHandlers) {

      979     print_handler_table();

      980     print_nul_chk_table();

      981   }

      982   if (xtty != NULL) {

      983     xtty->tail("print_nmethod");

      984   }

      985 }

      986 

      987 

      988 void nmethod::set_version(int v) {

      989   flags.version = v;

      990 }

      991 

      992 

      993 ScopeDesc* nmethod::scope_desc_at(address pc) {

      994   PcDesc* pd = pc_desc_at(pc);

      995   guarantee(pd != NULL, "scope must be present");

      996   return new ScopeDesc(this, pd->scope_decode_offset(),

      997                        pd->obj_decode_offset(), pd->should_reexecute(),

      998                        pd->return_oop());

      999 }

     1000 

     1001 

     1002 void nmethod::clear_inline_caches() {

     1003   assert(SafepointSynchronize::is_at_safepoint(), "cleaning of IC's only allowed at safepoint");

     1004   if (is_zombie()) {

     1005     return;

     1006   }

     1007 

     1008   RelocIterator iter(this);

     1009   while (iter.next()) {

     1010     iter.reloc()->clear_inline_cache();

     1011   }

     1012 }

     1013 

     1014 

     1015 void nmethod::cleanup_inline_caches() {

     1016 

     1017   assert(SafepointSynchronize::is_at_safepoint() &&

     1018         !CompiledIC_lock->is_locked() &&

     1019         !Patching_lock->is_locked(), "no threads must be updating the inline caches by them selfs");

     1020 

     1021   // If the method is not entrant or zombie then a JMP is plastered over the

     1022   // first few bytes.  If an oop in the old code was there, that oop

     1023   // should not get GC'd.  Skip the first few bytes of oops on

     1024   // not-entrant methods.

     1025   address low_boundary = verified_entry_point();

     1026   if (!is_in_use()) {

     1027     low_boundary += NativeJump::instruction_size;

     1028     // %%% Note:  On SPARC we patch only a 4-byte trap, not a full NativeJump.

     1029     // This means that the low_boundary is going to be a little too high.

     1030     // This shouldn't matter, since oops of non-entrant methods are never used.

     1031     // In fact, why are we bothering to look at oops in a non-entrant method??

     1032   }

     1033 

     1034   // Find all calls in an nmethod, and clear the ones that points to zombie methods

     1035   ResourceMark rm;

     1036   RelocIterator iter(this, low_boundary);

     1037   while(iter.next()) {

     1038     switch(iter.type()) {

     1039       case relocInfo::virtual_call_type:

     1040       case relocInfo::opt_virtual_call_type: {

     1041         CompiledIC *ic = CompiledIC_at(iter.reloc());

     1042         // Ok, to lookup references to zombies here

     1043         CodeBlob *cb = CodeCache::find_blob_unsafe(ic->ic_destination());

     1044         if( cb != NULL && cb->is_nmethod() ) {

     1045           nmethod* nm = (nmethod*)cb;

     1046           // Clean inline caches pointing to both zombie and not_entrant methods

     1047           if (!nm->is_in_use() || (nm->method()->code() != nm)) ic->set_to_clean();

     1048         }

     1049         break;

     1050       }

     1051       case relocInfo::static_call_type: {

     1052         CompiledStaticCall *csc = compiledStaticCall_at(iter.reloc());

     1053         CodeBlob *cb = CodeCache::find_blob_unsafe(csc->destination());

     1054         if( cb != NULL && cb->is_nmethod() ) {

     1055           nmethod* nm = (nmethod*)cb;

     1056           // Clean inline caches pointing to both zombie and not_entrant methods

     1057           if (!nm->is_in_use() || (nm->method()->code() != nm)) csc->set_to_clean();

     1058         }

     1059         break;

     1060       }

     1061     }

     1062   }

     1063 }

     1064 

     1065 // This is a private interface with the sweeper.

     1066 void nmethod::mark_as_seen_on_stack() {

     1067   assert(is_not_entrant(), "must be a non-entrant method");

     1068   set_stack_traversal_mark(NMethodSweeper::traversal_count());

     1069 }

     1070 

     1071 // Tell if a non-entrant method can be converted to a zombie (i.e., there is no activations on the stack)

     1072 bool nmethod::can_not_entrant_be_converted() {

     1073   assert(is_not_entrant(), "must be a non-entrant method");

     1074   assert(SafepointSynchronize::is_at_safepoint(), "must be called during a safepoint");

     1075 

     1076   // Since the nmethod sweeper only does partial sweep the sweeper's traversal

     1077   // count can be greater than the stack traversal count before it hits the

     1078   // nmethod for the second time.

     1079   return stack_traversal_mark()+1 < NMethodSweeper::traversal_count();

     1080 }

     1081 

     1082 void nmethod::inc_decompile_count() {

     1083   // Could be gated by ProfileTraps, but do not bother...

     1084   methodOop m = method();

     1085   if (m == NULL)  return;

     1086   methodDataOop mdo = m->method_data();

     1087   if (mdo == NULL)  return;

     1088   // There is a benign race here.  See comments in methodDataOop.hpp.

     1089   mdo->inc_decompile_count();

     1090 }

     1091 

     1092 void nmethod::make_unloaded(BoolObjectClosure* is_alive, oop cause) {

     1093 

     1094   post_compiled_method_unload();

     1095 

     1096   // Since this nmethod is being unloaded, make sure that dependencies

     1097   // recorded in instanceKlasses get flushed and pass non-NULL closure to

     1098   // indicate that this work is being done during a GC.

     1099   assert(Universe::heap()->is_gc_active(), "should only be called during gc");

     1100   assert(is_alive != NULL, "Should be non-NULL");

     1101   // A non-NULL is_alive closure indicates that this is being called during GC.

     1102   flush_dependencies(is_alive);

     1103 

     1104   // Break cycle between nmethod & method

     1105   if (TraceClassUnloading && WizardMode) {

     1106     tty->print_cr("[Class unloading: Making nmethod " INTPTR_FORMAT

     1107                   " unloadable], methodOop(" INTPTR_FORMAT

     1108                   "), cause(" INTPTR_FORMAT ")",

     1109                   this, (address)_method, (address)cause);

     1110     if (!Universe::heap()->is_gc_active())

     1111       cause->klass()->print();

     1112   }

     1113   // Unlink the osr method, so we do not look this up again

     1114   if (is_osr_method()) {

     1115     invalidate_osr_method();

     1116   }

     1117   // If _method is already NULL the methodOop is about to be unloaded,

     1118   // so we don't have to break the cycle. Note that it is possible to

     1119   // have the methodOop live here, in case we unload the nmethod because

     1120   // it is pointing to some oop (other than the methodOop) being unloaded.

     1121   if (_method != NULL) {

     1122     // OSR methods point to the methodOop, but the methodOop does not

     1123     // point back!

     1124     if (_method->code() == this) {

     1125       _method->clear_code(); // Break a cycle

     1126     }

     1127     _method = NULL;            // Clear the method of this dead nmethod

     1128   }

     1129   // Make the class unloaded - i.e., change state and notify sweeper

     1130   check_safepoint();

     1131   if (is_in_use()) {

     1132     // Transitioning directly from live to unloaded -- so

     1133     // we need to force a cache clean-up; remember this

     1134     // for later on.

     1135     CodeCache::set_needs_cache_clean(true);

     1136   }

     1137   flags.state = unloaded;

     1138 

     1139   // Log the unloading.

     1140   log_state_change();

     1141 

     1142   // The methodOop is gone at this point

     1143   assert(_method == NULL, "Tautology");

     1144 

     1145   set_osr_link(NULL);

     1146   //set_scavenge_root_link(NULL); // done by prune_scavenge_root_nmethods

     1147   NMethodSweeper::notify(this);

     1148 }

     1149 

     1150 void nmethod::invalidate_osr_method() {

     1151   assert(_entry_bci != InvocationEntryBci, "wrong kind of nmethod");

     1152   // Remove from list of active nmethods

     1153   if (method() != NULL)

     1154     instanceKlass::cast(method()->method_holder())->remove_osr_nmethod(this);

     1155   // Set entry as invalid

     1156   _entry_bci = InvalidOSREntryBci;

     1157 }

     1158 

     1159 void nmethod::log_state_change() const {

     1160   if (LogCompilation) {

     1161     if (xtty != NULL) {

     1162       ttyLocker ttyl;  // keep the following output all in one block

     1163       if (flags.state == unloaded) {

     1164         xtty->begin_elem("make_unloaded thread='" UINTX_FORMAT "'",

     1165                          os::current_thread_id());

     1166       } else {

     1167         xtty->begin_elem("make_not_entrant thread='" UINTX_FORMAT "'%s",

     1168                          os::current_thread_id(),

     1169                          (flags.state == zombie ? " zombie='1'" : ""));

     1170       }

     1171       log_identity(xtty);

     1172       xtty->stamp();

     1173       xtty->end_elem();

     1174     }

     1175   }

     1176   if (PrintCompilation && flags.state != unloaded) {

     1177     print_on(tty, flags.state == zombie ? "made zombie " : "made not entrant ");

     1178     tty->cr();

     1179   }

     1180 }

     1181 

     1182 // Common functionality for both make_not_entrant and make_zombie

     1183 bool nmethod::make_not_entrant_or_zombie(unsigned int state) {

     1184   assert(state == zombie || state == not_entrant, "must be zombie or not_entrant");

     1185 

     1186   bool was_alive = false;

     1187 

     1188   // Make sure the nmethod is not flushed in case of a safepoint in code below.

     1189   nmethodLocker nml(this);

     1190 

     1191   {

     1192     // If the method is already zombie there is nothing to do

     1193     if (is_zombie()) {

     1194       return false;

     1195     }

     1196 

     1197     // invalidate osr nmethod before acquiring the patching lock since

     1198     // they both acquire leaf locks and we don't want a deadlock.

     1199     // This logic is equivalent to the logic below for patching the

     1200     // verified entry point of regular methods.

     1201     if (is_osr_method()) {

     1202       // this effectively makes the osr nmethod not entrant

     1203       invalidate_osr_method();

     1204     }

     1205 

     1206     // Enter critical section.  Does not block for safepoint.

     1207     MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);

     1208 

     1209     if (flags.state == state) {

     1210       // another thread already performed this transition so nothing

     1211       // to do, but return false to indicate this.

     1212       return false;

     1213     }

     1214 

     1215     // The caller can be calling the method statically or through an inline

     1216     // cache call.

     1217     if (!is_osr_method() && !is_not_entrant()) {

     1218       NativeJump::patch_verified_entry(entry_point(), verified_entry_point(),

     1219                   SharedRuntime::get_handle_wrong_method_stub());

     1220       assert (NativeJump::instruction_size == nmethod::_zombie_instruction_size, "");

     1221     }

     1222 

     1223     // When the nmethod becomes zombie it is no longer alive so the

     1224     // dependencies must be flushed.  nmethods in the not_entrant

     1225     // state will be flushed later when the transition to zombie

     1226     // happens or they get unloaded.

     1227     if (state == zombie) {

     1228       assert(SafepointSynchronize::is_at_safepoint(), "must be done at safepoint");

     1229       flush_dependencies(NULL);

     1230     } else {

     1231       assert(state == not_entrant, "other cases may need to be handled differently");

     1232     }

     1233 

     1234     was_alive = is_in_use(); // Read state under lock

     1235 

     1236     // Change state

     1237     flags.state = state;

     1238 

     1239     // Log the transition once

     1240     log_state_change();

     1241 

     1242   } // leave critical region under Patching_lock

     1243 

     1244   if (state == not_entrant) {

     1245     Events::log("Make nmethod not entrant " INTPTR_FORMAT, this);

     1246   } else {

     1247     Events::log("Make nmethod zombie " INTPTR_FORMAT, this);

     1248   }

     1249 

     1250   if (TraceCreateZombies) {

     1251     tty->print_cr("nmethod <" INTPTR_FORMAT "> code made %s", this, (state == not_entrant) ? "not entrant" : "zombie");

     1252   }

     1253 

     1254   // Make sweeper aware that there is a zombie method that needs to be removed

     1255   NMethodSweeper::notify(this);

     1256 

     1257   // not_entrant only stuff

     1258   if (state == not_entrant) {

     1259     mark_as_seen_on_stack();

     1260   }

     1261 

     1262   if (was_alive) {

     1263     // It's a true state change, so mark the method as decompiled.

     1264     // Do it only for transition from alive.

     1265     inc_decompile_count();

     1266   }

     1267 

     1268   // zombie only - if a JVMTI agent has enabled the CompiledMethodUnload event

     1269   // and it hasn't already been reported for this nmethod then report it now.

     1270   // (the event may have been reported earilier if the GC marked it for unloading).

     1271   if (state == zombie) {

     1272 

     1273     DTRACE_METHOD_UNLOAD_PROBE(method());

     1274 

     1275     if (JvmtiExport::should_post_compiled_method_unload() &&

     1276         !unload_reported()) {

     1277       assert(method() != NULL, "checking");

     1278       {

     1279         HandleMark hm;

     1280         JvmtiExport::post_compiled_method_unload_at_safepoint(

     1281             method()->jmethod_id(), code_begin());

     1282       }

     1283       set_unload_reported();

     1284     }

     1285   }

     1286 

     1287 

     1288   // Zombie only stuff

     1289   if (state == zombie) {

     1290     VTune::delete_nmethod(this);

     1291   }

     1292 

     1293   // Check whether method got unloaded at a safepoint before this,

     1294   // if so we can skip the flushing steps below

     1295   if (method() == NULL) return true;

     1296 

     1297   // Remove nmethod from method.

     1298   // We need to check if both the _code and _from_compiled_code_entry_point

     1299   // refer to this nmethod because there is a race in setting these two fields

     1300   // in methodOop as seen in bugid 4947125.

     1301   // If the vep() points to the zombie nmethod, the memory for the nmethod

     1302   // could be flushed and the compiler and vtable stubs could still call

     1303   // through it.

     1304   if (method()->code() == this ||

     1305       method()->from_compiled_entry() == verified_entry_point()) {

     1306     HandleMark hm;

     1307     method()->clear_code();

     1308   }

     1309 

     1310   return true;

     1311 }

     1312 

     1313 

     1314 #ifndef PRODUCT

     1315 void nmethod::check_safepoint() {

     1316   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");

     1317 }

     1318 #endif

     1319 

     1320 

     1321 void nmethod::flush() {

     1322   // Note that there are no valid oops in the nmethod anymore.

     1323   assert(is_zombie() || (is_osr_method() && is_unloaded()), "must be a zombie method");

     1324   assert(is_marked_for_reclamation() || (is_osr_method() && is_unloaded()), "must be marked for reclamation");

     1325 

     1326   assert (!is_locked_by_vm(), "locked methods shouldn't be flushed");

     1327   check_safepoint();

     1328 

     1329   // completely deallocate this method

     1330   EventMark m("flushing nmethod " INTPTR_FORMAT " %s", this, "");

     1331   if (PrintMethodFlushing) {

     1332     tty->print_cr("*flushing nmethod %3d/" INTPTR_FORMAT ". Live blobs:" UINT32_FORMAT "/Free CodeCache:" SIZE_FORMAT "Kb",

     1333         _compile_id, this, CodeCache::nof_blobs(), CodeCache::unallocated_capacity()/1024);

     1334   }

     1335 

     1336   // We need to deallocate any ExceptionCache data.

     1337   // Note that we do not need to grab the nmethod lock for this, it

     1338   // better be thread safe if we're disposing of it!

     1339   ExceptionCache* ec = exception_cache();

     1340   set_exception_cache(NULL);

     1341   while(ec != NULL) {

     1342     ExceptionCache* next = ec->next();

     1343     delete ec;

     1344     ec = next;

     1345   }

     1346 

     1347   if (on_scavenge_root_list()) {

     1348     CodeCache::drop_scavenge_root_nmethod(this);

     1349   }

     1350 

     1351   if (is_speculatively_disconnected()) {

     1352     CodeCache::remove_saved_code(this);

     1353   }

     1354 

     1355   ((CodeBlob*)(this))->flush();

     1356 

     1357   CodeCache::free(this);

     1358 }

     1359 

     1360 

     1361 //

     1362 // Notify all classes this nmethod is dependent on that it is no

     1363 // longer dependent. This should only be called in two situations.

     1364 // First, when a nmethod transitions to a zombie all dependents need

     1365 // to be clear.  Since zombification happens at a safepoint there's no

     1366 // synchronization issues.  The second place is a little more tricky.

     1367 // During phase 1 of mark sweep class unloading may happen and as a

     1368 // result some nmethods may get unloaded.  In this case the flushing

     1369 // of dependencies must happen during phase 1 since after GC any

     1370 // dependencies in the unloaded nmethod won't be updated, so

     1371 // traversing the dependency information in unsafe.  In that case this

     1372 // function is called with a non-NULL argument and this function only

     1373 // notifies instanceKlasses that are reachable

     1374 

     1375 void nmethod::flush_dependencies(BoolObjectClosure* is_alive) {

     1376   assert(SafepointSynchronize::is_at_safepoint(), "must be done at safepoint");

     1377   assert(Universe::heap()->is_gc_active() == (is_alive != NULL),

     1378   "is_alive is non-NULL if and only if we are called during GC");

     1379   if (!has_flushed_dependencies()) {

     1380     set_has_flushed_dependencies();

     1381     for (Dependencies::DepStream deps(this); deps.next(); ) {

     1382       klassOop klass = deps.context_type();

     1383       if (klass == NULL)  continue;  // ignore things like evol_method

     1384 

     1385       // During GC the is_alive closure is non-NULL, and is used to

     1386       // determine liveness of dependees that need to be updated.

     1387       if (is_alive == NULL || is_alive->do_object_b(klass)) {

     1388         instanceKlass::cast(klass)->remove_dependent_nmethod(this);

     1389       }

     1390     }

     1391   }

     1392 }

     1393 

     1394 

     1395 // If this oop is not live, the nmethod can be unloaded.

     1396 bool nmethod::can_unload(BoolObjectClosure* is_alive,

     1397                          OopClosure* keep_alive,

     1398                          oop* root, bool unloading_occurred) {

     1399   assert(root != NULL, "just checking");

     1400   oop obj = *root;

     1401   if (obj == NULL || is_alive->do_object_b(obj)) {

     1402       return false;

     1403   }

     1404   if (obj->is_compiledICHolder()) {

     1405     compiledICHolderOop cichk_oop = compiledICHolderOop(obj);

     1406     if (is_alive->do_object_b(

     1407           cichk_oop->holder_method()->method_holder()) &&

     1408         is_alive->do_object_b(cichk_oop->holder_klass())) {

     1409       // The oop should be kept alive

     1410       keep_alive->do_oop(root);

     1411       return false;

     1412     }

     1413   }

     1414   // If ScavengeRootsInCode is true, an nmethod might be unloaded

     1415   // simply because one of its constant oops has gone dead.

     1416   // No actual classes need to be unloaded in order for this to occur.

     1417   assert(unloading_occurred || ScavengeRootsInCode, "Inconsistency in unloading");

     1418   make_unloaded(is_alive, obj);

     1419   return true;

     1420 }

     1421 

     1422 // ------------------------------------------------------------------

     1423 // post_compiled_method_load_event

     1424 // new method for install_code() path

     1425 // Transfer information from compilation to jvmti

     1426 void nmethod::post_compiled_method_load_event() {

     1427 

     1428   methodOop moop = method();

     1429   HS_DTRACE_PROBE8(hotspot, compiled__method__load,

     1430       moop->klass_name()->bytes(),

     1431       moop->klass_name()->utf8_length(),

     1432       moop->name()->bytes(),

     1433       moop->name()->utf8_length(),

     1434       moop->signature()->bytes(),

     1435       moop->signature()->utf8_length(),

     1436       code_begin(), code_size());

     1437 

     1438   if (JvmtiExport::should_post_compiled_method_load()) {

     1439     JvmtiExport::post_compiled_method_load(this);

     1440   }

     1441 }

     1442 

     1443 void nmethod::post_compiled_method_unload() {

     1444   assert(_method != NULL && !is_unloaded(), "just checking");

     1445   DTRACE_METHOD_UNLOAD_PROBE(method());

     1446 

     1447   // If a JVMTI agent has enabled the CompiledMethodUnload event then

     1448   // post the event. Sometime later this nmethod will be made a zombie by

     1449   // the sweeper but the methodOop will not be valid at that point.

     1450   if (JvmtiExport::should_post_compiled_method_unload()) {

     1451     assert(!unload_reported(), "already unloaded");

     1452     HandleMark hm;

     1453     JvmtiExport::post_compiled_method_unload_at_safepoint(

     1454                       method()->jmethod_id(), code_begin());

     1455   }

     1456 

     1457   // The JVMTI CompiledMethodUnload event can be enabled or disabled at

     1458   // any time. As the nmethod is being unloaded now we mark it has

     1459   // having the unload event reported - this will ensure that we don't

     1460   // attempt to report the event in the unlikely scenario where the

     1461   // event is enabled at the time the nmethod is made a zombie.

     1462   set_unload_reported();

     1463 }

     1464 

     1465 // This is called at the end of the strong tracing/marking phase of a

     1466 // GC to unload an nmethod if it contains otherwise unreachable

     1467 // oops.

     1468 

     1469 void nmethod::do_unloading(BoolObjectClosure* is_alive,

     1470                            OopClosure* keep_alive, bool unloading_occurred) {

     1471   // Make sure the oop's ready to receive visitors

     1472   assert(!is_zombie() && !is_unloaded(),

     1473          "should not call follow on zombie or unloaded nmethod");

     1474 

     1475   // If the method is not entrant then a JMP is plastered over the

     1476   // first few bytes.  If an oop in the old code was there, that oop

     1477   // should not get GC'd.  Skip the first few bytes of oops on

     1478   // not-entrant methods.

     1479   address low_boundary = verified_entry_point();

     1480   if (is_not_entrant()) {

     1481     low_boundary += NativeJump::instruction_size;

     1482     // %%% Note:  On SPARC we patch only a 4-byte trap, not a full NativeJump.

     1483     // (See comment above.)

     1484   }

     1485 

     1486   // The RedefineClasses() API can cause the class unloading invariant

     1487   // to no longer be true. See jvmtiExport.hpp for details.

     1488   // Also, leave a debugging breadcrumb in local flag.

     1489   bool a_class_was_redefined = JvmtiExport::has_redefined_a_class();

     1490   if (a_class_was_redefined) {

     1491     // This set of the unloading_occurred flag is done before the

     1492     // call to post_compiled_method_unload() so that the unloading

     1493     // of this nmethod is reported.

     1494     unloading_occurred = true;

     1495   }

     1496 

     1497   // Follow methodOop

     1498   if (can_unload(is_alive, keep_alive, (oop*)&_method, unloading_occurred)) {

     1499     return;

     1500   }

     1501 

     1502   // Exception cache

     1503   ExceptionCache* ec = exception_cache();

     1504   while (ec != NULL) {

     1505     oop* ex_addr = (oop*)ec->exception_type_addr();

     1506     oop ex = *ex_addr;

     1507     ExceptionCache* next_ec = ec->next();

     1508     if (ex != NULL && !is_alive->do_object_b(ex)) {

     1509       assert(!ex->is_compiledICHolder(), "Possible error here");

     1510       remove_from_exception_cache(ec);

     1511     }

     1512     ec = next_ec;

     1513   }

     1514 

     1515   // If class unloading occurred we first iterate over all inline caches and

     1516   // clear ICs where the cached oop is referring to an unloaded klass or method.

     1517   // The remaining live cached oops will be traversed in the relocInfo::oop_type

     1518   // iteration below.

     1519   if (unloading_occurred) {

     1520     RelocIterator iter(this, low_boundary);

     1521     while(iter.next()) {

     1522       if (iter.type() == relocInfo::virtual_call_type) {

     1523         CompiledIC *ic = CompiledIC_at(iter.reloc());

     1524         oop ic_oop = ic->cached_oop();

     1525         if (ic_oop != NULL && !is_alive->do_object_b(ic_oop)) {

     1526           // The only exception is compiledICHolder oops which may

     1527           // yet be marked below. (We check this further below).

     1528           if (ic_oop->is_compiledICHolder()) {

     1529             compiledICHolderOop cichk_oop = compiledICHolderOop(ic_oop);

     1530             if (is_alive->do_object_b(

     1531                   cichk_oop->holder_method()->method_holder()) &&

     1532                 is_alive->do_object_b(cichk_oop->holder_klass())) {

     1533               continue;

     1534             }

     1535           }

     1536           ic->set_to_clean();

     1537           assert(ic->cached_oop() == NULL,

     1538                  "cached oop in IC should be cleared");

     1539         }

     1540       }

     1541     }

     1542   }

     1543 

     1544   // Compiled code

     1545   RelocIterator iter(this, low_boundary);

     1546   while (iter.next()) {

     1547     if (iter.type() == relocInfo::oop_type) {

     1548       oop_Relocation* r = iter.oop_reloc();

     1549       // In this loop, we must only traverse those oops directly embedded in

     1550       // the code.  Other oops (oop_index>0) are seen as part of scopes_oops.

     1551       assert(1 == (r->oop_is_immediate()) +

     1552                   (r->oop_addr() >= oops_begin() && r->oop_addr() < oops_end()),

     1553              "oop must be found in exactly one place");

     1554       if (r->oop_is_immediate() && r->oop_value() != NULL) {

     1555         if (can_unload(is_alive, keep_alive, r->oop_addr(), unloading_occurred)) {

     1556           return;

     1557         }

     1558       }

     1559     }

     1560   }

     1561 

     1562 

     1563   // Scopes

     1564   for (oop* p = oops_begin(); p < oops_end(); p++) {

     1565     if (*p == Universe::non_oop_word())  continue;  // skip non-oops

     1566     if (can_unload(is_alive, keep_alive, p, unloading_occurred)) {

     1567       return;

     1568     }

     1569   }

     1570 

     1571 #ifndef PRODUCT

     1572   // This nmethod was not unloaded; check below that all CompiledICs

     1573   // refer to marked oops.

     1574   {

     1575     RelocIterator iter(this, low_boundary);

     1576     while (iter.next()) {

     1577       if (iter.type() == relocInfo::virtual_call_type) {

     1578          CompiledIC *ic = CompiledIC_at(iter.reloc());

     1579          oop ic_oop = ic->cached_oop();

     1580          assert(ic_oop == NULL || is_alive->do_object_b(ic_oop),

     1581                 "Found unmarked ic_oop in reachable nmethod");

     1582        }

     1583     }

     1584   }

     1585 #endif // !PRODUCT

     1586 }

     1587 

     1588 // This method is called twice during GC -- once while

     1589 // tracing the "active" nmethods on thread stacks during

     1590 // the (strong) marking phase, and then again when walking

     1591 // the code cache contents during the weak roots processing

     1592 // phase. The two uses are distinguished by means of the

     1593 // 'do_strong_roots_only' flag, which is true in the first

     1594 // case. We want to walk the weak roots in the nmethod

     1595 // only in the second case. The weak roots in the nmethod

     1596 // are the oops in the ExceptionCache and the InlineCache

     1597 // oops.

     1598 void nmethod::oops_do(OopClosure* f, bool do_strong_roots_only) {

     1599   // make sure the oops ready to receive visitors

     1600   assert(!is_zombie() && !is_unloaded(),

     1601          "should not call follow on zombie or unloaded nmethod");

     1602 

     1603   // If the method is not entrant or zombie then a JMP is plastered over the

     1604   // first few bytes.  If an oop in the old code was there, that oop

     1605   // should not get GC'd.  Skip the first few bytes of oops on

     1606   // not-entrant methods.

     1607   address low_boundary = verified_entry_point();

     1608   if (is_not_entrant()) {

     1609     low_boundary += NativeJump::instruction_size;

     1610     // %%% Note:  On SPARC we patch only a 4-byte trap, not a full NativeJump.

     1611     // (See comment above.)

     1612   }

     1613 

     1614   // Compiled code

     1615   f->do_oop((oop*) &_method);

     1616   if (!do_strong_roots_only) {

     1617     // weak roots processing phase -- update ExceptionCache oops

     1618     ExceptionCache* ec = exception_cache();

     1619     while(ec != NULL) {

     1620       f->do_oop((oop*)ec->exception_type_addr());

     1621       ec = ec->next();

     1622     }

     1623   } // Else strong roots phase -- skip oops in ExceptionCache

     1624 

     1625   RelocIterator iter(this, low_boundary);

     1626 

     1627   while (iter.next()) {

     1628     if (iter.type() == relocInfo::oop_type ) {

     1629       oop_Relocation* r = iter.oop_reloc();

     1630       // In this loop, we must only follow those oops directly embedded in

     1631       // the code.  Other oops (oop_index>0) are seen as part of scopes_oops.

     1632       assert(1 == (r->oop_is_immediate()) +

     1633                    (r->oop_addr() >= oops_begin() && r->oop_addr() < oops_end()),

     1634              "oop must be found in exactly one place");

     1635       if (r->oop_is_immediate() && r->oop_value() != NULL) {

     1636         f->do_oop(r->oop_addr());

     1637       }

     1638     }

     1639   }

     1640 

     1641   // Scopes

     1642   // This includes oop constants not inlined in the code stream.

     1643   for (oop* p = oops_begin(); p < oops_end(); p++) {

     1644     if (*p == Universe::non_oop_word())  continue;  // skip non-oops

     1645     f->do_oop(p);

     1646   }

     1647 }

     1648 

     1649 #define NMETHOD_SENTINEL ((nmethod*)badAddress)

     1650 

     1651 nmethod* volatile nmethod::_oops_do_mark_nmethods;

     1652 

     1653 // An nmethod is "marked" if its _mark_link is set non-null.

     1654 // Even if it is the end of the linked list, it will have a non-null link value,

     1655 // as long as it is on the list.

     1656 // This code must be MP safe, because it is used from parallel GC passes.

     1657 bool nmethod::test_set_oops_do_mark() {

     1658   assert(nmethod::oops_do_marking_is_active(), "oops_do_marking_prologue must be called");

     1659   nmethod* observed_mark_link = _oops_do_mark_link;

     1660   if (observed_mark_link == NULL) {

     1661     // Claim this nmethod for this thread to mark.

     1662     observed_mark_link = (nmethod*)

     1663       Atomic::cmpxchg_ptr(NMETHOD_SENTINEL, &_oops_do_mark_link, NULL);

     1664     if (observed_mark_link == NULL) {

     1665 

     1666       // Atomically append this nmethod (now claimed) to the head of the list:

     1667       nmethod* observed_mark_nmethods = _oops_do_mark_nmethods;

     1668       for (;;) {

     1669         nmethod* required_mark_nmethods = observed_mark_nmethods;

     1670         _oops_do_mark_link = required_mark_nmethods;

     1671         observed_mark_nmethods = (nmethod*)

     1672           Atomic::cmpxchg_ptr(this, &_oops_do_mark_nmethods, required_mark_nmethods);

     1673         if (observed_mark_nmethods == required_mark_nmethods)

     1674           break;

     1675       }

     1676       // Mark was clear when we first saw this guy.

     1677       NOT_PRODUCT(if (TraceScavenge)  print_on(tty, "oops_do, mark\n"));

     1678       return false;

     1679     }

     1680   }

     1681   // On fall through, another racing thread marked this nmethod before we did.

     1682   return true;

     1683 }

     1684 

     1685 void nmethod::oops_do_marking_prologue() {

     1686   NOT_PRODUCT(if (TraceScavenge)  tty->print_cr("[oops_do_marking_prologue"));

     1687   assert(_oops_do_mark_nmethods == NULL, "must not call oops_do_marking_prologue twice in a row");

     1688   // We use cmpxchg_ptr instead of regular assignment here because the user

     1689   // may fork a bunch of threads, and we need them all to see the same state.

     1690   void* observed = Atomic::cmpxchg_ptr(NMETHOD_SENTINEL, &_oops_do_mark_nmethods, NULL);

     1691   guarantee(observed == NULL, "no races in this sequential code");

     1692 }

     1693 

     1694 void nmethod::oops_do_marking_epilogue() {

     1695   assert(_oops_do_mark_nmethods != NULL, "must not call oops_do_marking_epilogue twice in a row");

     1696   nmethod* cur = _oops_do_mark_nmethods;

     1697   while (cur != NMETHOD_SENTINEL) {

     1698     assert(cur != NULL, "not NULL-terminated");

     1699     nmethod* next = cur->_oops_do_mark_link;

     1700     cur->_oops_do_mark_link = NULL;

     1701     NOT_PRODUCT(if (TraceScavenge)  cur->print_on(tty, "oops_do, unmark\n"));

     1702     cur = next;

     1703   }

     1704   void* required = _oops_do_mark_nmethods;

     1705   void* observed = Atomic::cmpxchg_ptr(NULL, &_oops_do_mark_nmethods, required);

     1706   guarantee(observed == required, "no races in this sequential code");

     1707   NOT_PRODUCT(if (TraceScavenge)  tty->print_cr("oops_do_marking_epilogue]"));

     1708 }

     1709 

     1710 class DetectScavengeRoot: public OopClosure {

     1711   bool     _detected_scavenge_root;

     1712 public:

     1713   DetectScavengeRoot() : _detected_scavenge_root(false)

     1714   { NOT_PRODUCT(_print_nm = NULL); }

     1715   bool detected_scavenge_root() { return _detected_scavenge_root; }

     1716   virtual void do_oop(oop* p) {

     1717     if ((*p) != NULL && (*p)->is_scavengable()) {

     1718       NOT_PRODUCT(maybe_print(p));

     1719       _detected_scavenge_root = true;

     1720     }

     1721   }

     1722   virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); }

     1723 

     1724 #ifndef PRODUCT

     1725   nmethod* _print_nm;

     1726   void maybe_print(oop* p) {

     1727     if (_print_nm == NULL)  return;

     1728     if (!_detected_scavenge_root)  _print_nm->print_on(tty, "new scavenge root");

     1729     tty->print_cr(""PTR_FORMAT"[offset=%d] detected non-perm oop "PTR_FORMAT" (found at "PTR_FORMAT")",

     1730                   _print_nm, (int)((intptr_t)p - (intptr_t)_print_nm),

     1731                   (intptr_t)(*p), (intptr_t)p);

     1732     (*p)->print();

     1733   }

     1734 #endif //PRODUCT

     1735 };

     1736 

     1737 bool nmethod::detect_scavenge_root_oops() {

     1738   DetectScavengeRoot detect_scavenge_root;

     1739   NOT_PRODUCT(if (TraceScavenge)  detect_scavenge_root._print_nm = this);

     1740   oops_do(&detect_scavenge_root);

     1741   return detect_scavenge_root.detected_scavenge_root();

     1742 }

     1743 

     1744 // Method that knows how to preserve outgoing arguments at call. This method must be

     1745 // called with a frame corresponding to a Java invoke

     1746 void nmethod::preserve_callee_argument_oops(frame fr, const RegisterMap *reg_map, OopClosure* f) {

     1747   if (!method()->is_native()) {

     1748     SimpleScopeDesc ssd(this, fr.pc());

     1749     Bytecode_invoke* call = Bytecode_invoke_at(ssd.method(), ssd.bci());

     1750     bool has_receiver = call->has_receiver();

     1751     symbolOop signature = call->signature();

     1752     fr.oops_compiled_arguments_do(signature, has_receiver, reg_map, f);

     1753   }

     1754 }

     1755 

     1756 

     1757 oop nmethod::embeddedOop_at(u_char* p) {

     1758   RelocIterator iter(this, p, p + oopSize);

     1759   while (iter.next())

     1760     if (iter.type() == relocInfo::oop_type) {

     1761       return iter.oop_reloc()->oop_value();

     1762     }

     1763   return NULL;

     1764 }

     1765 

     1766 

     1767 inline bool includes(void* p, void* from, void* to) {

     1768   return from <= p && p < to;

     1769 }

     1770 

     1771 

     1772 void nmethod::copy_scopes_pcs(PcDesc* pcs, int count) {

     1773   assert(count >= 2, "must be sentinel values, at least");

     1774 

     1775 #ifdef ASSERT

     1776   // must be sorted and unique; we do a binary search in find_pc_desc()

     1777   int prev_offset = pcs[0].pc_offset();

     1778   assert(prev_offset == PcDesc::lower_offset_limit,

     1779          "must start with a sentinel");

     1780   for (int i = 1; i < count; i++) {

     1781     int this_offset = pcs[i].pc_offset();

     1782     assert(this_offset > prev_offset, "offsets must be sorted");

     1783     prev_offset = this_offset;

     1784   }

     1785   assert(prev_offset == PcDesc::upper_offset_limit,

     1786          "must end with a sentinel");

     1787 #endif //ASSERT

     1788 

     1789   // Search for MethodHandle invokes and tag the nmethod.

     1790   for (int i = 0; i < count; i++) {

     1791     if (pcs[i].is_method_handle_invoke()) {

     1792       set_has_method_handle_invokes(true);

     1793       break;

     1794     }

     1795   }

     1796 

     1797   int size = count * sizeof(PcDesc);

     1798   assert(scopes_pcs_size() >= size, "oob");

     1799   memcpy(scopes_pcs_begin(), pcs, size);

     1800 

     1801   // Adjust the final sentinel downward.

     1802   PcDesc* last_pc = &scopes_pcs_begin()[count-1];

     1803   assert(last_pc->pc_offset() == PcDesc::upper_offset_limit, "sanity");

     1804   last_pc->set_pc_offset(instructions_size() + 1);

     1805   for (; last_pc + 1 < scopes_pcs_end(); last_pc += 1) {

     1806     // Fill any rounding gaps with copies of the last record.

     1807     last_pc[1] = last_pc[0];

     1808   }

     1809   // The following assert could fail if sizeof(PcDesc) is not

     1810   // an integral multiple of oopSize (the rounding term).

     1811   // If it fails, change the logic to always allocate a multiple

     1812   // of sizeof(PcDesc), and fill unused words with copies of *last_pc.

     1813   assert(last_pc + 1 == scopes_pcs_end(), "must match exactly");

     1814 }

     1815 

     1816 void nmethod::copy_scopes_data(u_char* buffer, int size) {

     1817   assert(scopes_data_size() >= size, "oob");

     1818   memcpy(scopes_data_begin(), buffer, size);

     1819 }

     1820 

     1821 

     1822 #ifdef ASSERT

     1823 static PcDesc* linear_search(nmethod* nm, int pc_offset, bool approximate) {

     1824   PcDesc* lower = nm->scopes_pcs_begin();

     1825   PcDesc* upper = nm->scopes_pcs_end();

     1826   lower += 1; // exclude initial sentinel

     1827   PcDesc* res = NULL;

     1828   for (PcDesc* p = lower; p < upper; p++) {

     1829     NOT_PRODUCT(--nmethod_stats.pc_desc_tests);  // don't count this call to match_desc

     1830     if (match_desc(p, pc_offset, approximate)) {

     1831       if (res == NULL)

     1832         res = p;

     1833       else

     1834         res = (PcDesc*) badAddress;

     1835     }

     1836   }

     1837   return res;

     1838 }

     1839 #endif

     1840 

     1841 

     1842 // Finds a PcDesc with real-pc equal to "pc"

     1843 PcDesc* nmethod::find_pc_desc_internal(address pc, bool approximate) {

     1844   address base_address = instructions_begin();

     1845   if ((pc < base_address) ||

     1846       (pc - base_address) >= (ptrdiff_t) PcDesc::upper_offset_limit) {

     1847     return NULL;  // PC is wildly out of range

     1848   }

     1849   int pc_offset = (int) (pc - base_address);

     1850 

     1851   // Check the PcDesc cache if it contains the desired PcDesc

     1852   // (This as an almost 100% hit rate.)

     1853   PcDesc* res = _pc_desc_cache.find_pc_desc(pc_offset, approximate);

     1854   if (res != NULL) {

     1855     assert(res == linear_search(this, pc_offset, approximate), "cache ok");

     1856     return res;

     1857   }

     1858 

     1859   // Fallback algorithm: quasi-linear search for the PcDesc

     1860   // Find the last pc_offset less than the given offset.

     1861   // The successor must be the required match, if there is a match at all.

     1862   // (Use a fixed radix to avoid expensive affine pointer arithmetic.)

     1863   PcDesc* lower = scopes_pcs_begin();

     1864   PcDesc* upper = scopes_pcs_end();

     1865   upper -= 1; // exclude final sentinel

     1866   if (lower >= upper)  return NULL;  // native method; no PcDescs at all

     1867 

     1868 #define assert_LU_OK \

     1869   /* invariant on lower..upper during the following search: */ \

     1870   assert(lower->pc_offset() <  pc_offset, "sanity"); \

     1871   assert(upper->pc_offset() >= pc_offset, "sanity")

     1872   assert_LU_OK;

     1873 

     1874   // Use the last successful return as a split point.

     1875   PcDesc* mid = _pc_desc_cache.last_pc_desc();

     1876   NOT_PRODUCT(++nmethod_stats.pc_desc_searches);

     1877   if (mid->pc_offset() < pc_offset) {

     1878     lower = mid;

     1879   } else {

     1880     upper = mid;

     1881   }

     1882 

     1883   // Take giant steps at first (4096, then 256, then 16, then 1)

     1884   const int LOG2_RADIX = 4 /*smaller steps in debug mode:*/ debug_only(-1);

     1885   const int RADIX = (1 << LOG2_RADIX);

     1886   for (int step = (1 << (LOG2_RADIX*3)); step > 1; step >>= LOG2_RADIX) {

     1887     while ((mid = lower + step) < upper) {

     1888       assert_LU_OK;

     1889       NOT_PRODUCT(++nmethod_stats.pc_desc_searches);

     1890       if (mid->pc_offset() < pc_offset) {

     1891         lower = mid;

     1892       } else {

     1893         upper = mid;

     1894         break;

     1895       }

     1896     }

     1897     assert_LU_OK;

     1898   }

     1899 

     1900   // Sneak up on the value with a linear search of length ~16.

     1901   while (true) {

     1902     assert_LU_OK;

     1903     mid = lower + 1;

     1904     NOT_PRODUCT(++nmethod_stats.pc_desc_searches);

     1905     if (mid->pc_offset() < pc_offset) {

     1906       lower = mid;

     1907     } else {

     1908       upper = mid;

     1909       break;

     1910     }

     1911   }

     1912 #undef assert_LU_OK

     1913 

     1914   if (match_desc(upper, pc_offset, approximate)) {

     1915     assert(upper == linear_search(this, pc_offset, approximate), "search ok");

     1916     _pc_desc_cache.add_pc_desc(upper);

     1917     return upper;

     1918   } else {

     1919     assert(NULL == linear_search(this, pc_offset, approximate), "search ok");

     1920     return NULL;

     1921   }

     1922 }

     1923 

     1924 

     1925 bool nmethod::check_all_dependencies() {

     1926   bool found_check = false;

     1927   // wholesale check of all dependencies

     1928   for (Dependencies::DepStream deps(this); deps.next(); ) {

     1929     if (deps.check_dependency() != NULL) {

     1930       found_check = true;

     1931       NOT_DEBUG(break);

     1932     }

     1933   }

     1934   return found_check;  // tell caller if we found anything

     1935 }

     1936 

     1937 bool nmethod::check_dependency_on(DepChange& changes) {

     1938   // What has happened:

     1939   // 1) a new class dependee has been added

     1940   // 2) dependee and all its super classes have been marked

     1941   bool found_check = false;  // set true if we are upset

     1942   for (Dependencies::DepStream deps(this); deps.next(); ) {

     1943     // Evaluate only relevant dependencies.

     1944     if (deps.spot_check_dependency_at(changes) != NULL) {

     1945       found_check = true;

     1946       NOT_DEBUG(break);

     1947     }

     1948   }

     1949   return found_check;

     1950 }

     1951 

     1952 bool nmethod::is_evol_dependent_on(klassOop dependee) {

     1953   instanceKlass *dependee_ik = instanceKlass::cast(dependee);

     1954   objArrayOop dependee_methods = dependee_ik->methods();

     1955   for (Dependencies::DepStream deps(this); deps.next(); ) {

     1956     if (deps.type() == Dependencies::evol_method) {

     1957       methodOop method = deps.method_argument(0);

     1958       for (int j = 0; j < dependee_methods->length(); j++) {

     1959         if ((methodOop) dependee_methods->obj_at(j) == method) {

     1960           // RC_TRACE macro has an embedded ResourceMark

     1961           RC_TRACE(0x01000000,

     1962             ("Found evol dependency of nmethod %s.%s(%s) compile_id=%d on method %s.%s(%s)",

     1963             _method->method_holder()->klass_part()->external_name(),

     1964             _method->name()->as_C_string(),

     1965             _method->signature()->as_C_string(), compile_id(),

     1966             method->method_holder()->klass_part()->external_name(),

     1967             method->name()->as_C_string(),

     1968             method->signature()->as_C_string()));

     1969           if (TraceDependencies || LogCompilation)

     1970             deps.log_dependency(dependee);

     1971           return true;

     1972         }

     1973       }

     1974     }

     1975   }

     1976   return false;

     1977 }

     1978 

     1979 // Called from mark_for_deoptimization, when dependee is invalidated.

     1980 bool nmethod::is_dependent_on_method(methodOop dependee) {

     1981   for (Dependencies::DepStream deps(this); deps.next(); ) {

     1982     if (deps.type() != Dependencies::evol_method)

     1983       continue;

     1984     methodOop method = deps.method_argument(0);

     1985     if (method == dependee) return true;

     1986   }

     1987   return false;

     1988 }

     1989 

     1990 

     1991 bool nmethod::is_patchable_at(address instr_addr) {

     1992   assert (code_contains(instr_addr), "wrong nmethod used");

     1993   if (is_zombie()) {

     1994     // a zombie may never be patched

     1995     return false;

     1996   }

     1997   return true;

     1998 }

     1999 

     2000 

     2001 address nmethod::continuation_for_implicit_exception(address pc) {

     2002   // Exception happened outside inline-cache check code => we are inside

     2003   // an active nmethod => use cpc to determine a return address

     2004   int exception_offset = pc - instructions_begin();

     2005   int cont_offset = ImplicitExceptionTable(this).at( exception_offset );

     2006 #ifdef ASSERT

     2007   if (cont_offset == 0) {

     2008     Thread* thread = ThreadLocalStorage::get_thread_slow();

     2009     ResetNoHandleMark rnm; // Might be called from LEAF/QUICK ENTRY

     2010     HandleMark hm(thread);

     2011     ResourceMark rm(thread);

     2012     CodeBlob* cb = CodeCache::find_blob(pc);

     2013     assert(cb != NULL && cb == this, "");

     2014     tty->print_cr("implicit exception happened at " INTPTR_FORMAT, pc);

     2015     print();

     2016     method()->print_codes();

     2017     print_code();

     2018     print_pcs();

     2019   }

     2020 #endif

     2021   if (cont_offset == 0) {

     2022     // Let the normal error handling report the exception

     2023     return NULL;

     2024   }

     2025   return instructions_begin() + cont_offset;

     2026 }

     2027 

     2028 

     2029 

     2030 void nmethod_init() {

     2031   // make sure you didn't forget to adjust the filler fields

     2032   assert(sizeof(nmFlags) <= 4,           "nmFlags occupies more than a word");

     2033   assert(sizeof(nmethod) % oopSize == 0, "nmethod size must be multiple of a word");

     2034 }

     2035 

     2036 

     2037 //-------------------------------------------------------------------------------------------

     2038 

     2039 

     2040 // QQQ might we make this work from a frame??

     2041 nmethodLocker::nmethodLocker(address pc) {

     2042   CodeBlob* cb = CodeCache::find_blob(pc);

     2043   guarantee(cb != NULL && cb->is_nmethod(), "bad pc for a nmethod found");

     2044   _nm = (nmethod*)cb;

     2045   lock_nmethod(_nm);

     2046 }

     2047 

     2048 void nmethodLocker::lock_nmethod(nmethod* nm) {

     2049   if (nm == NULL)  return;

     2050   Atomic::inc(&nm->_lock_count);

     2051   guarantee(!nm->is_zombie(), "cannot lock a zombie method");

     2052 }

     2053 

     2054 void nmethodLocker::unlock_nmethod(nmethod* nm) {

     2055   if (nm == NULL)  return;

     2056   Atomic::dec(&nm->_lock_count);

     2057   guarantee(nm->_lock_count >= 0, "unmatched nmethod lock/unlock");

     2058 }

     2059 

     2060 

     2061 // -----------------------------------------------------------------------------

     2062 // nmethod::get_deopt_original_pc

     2063 //

     2064 // Return the original PC for the given PC if:

     2065 // (a) the given PC belongs to a nmethod and

     2066 // (b) it is a deopt PC

     2067 address nmethod::get_deopt_original_pc(const frame* fr) {

     2068   if (fr->cb() == NULL)  return NULL;

     2069 

     2070   nmethod* nm = fr->cb()->as_nmethod_or_null();

     2071   if (nm != NULL && nm->is_deopt_pc(fr->pc()))

     2072     return nm->get_original_pc(fr);

     2073 

     2074   return NULL;

     2075 }

     2076 

     2077 

     2078 // -----------------------------------------------------------------------------

     2079 // MethodHandle

     2080 

     2081 bool nmethod::is_method_handle_return(address return_pc) {

     2082   if (!has_method_handle_invokes())  return false;

     2083   PcDesc* pd = pc_desc_at(return_pc);

     2084   if (pd == NULL)

     2085     return false;

     2086   return pd->is_method_handle_invoke();

     2087 }

     2088 

     2089 

     2090 // -----------------------------------------------------------------------------

     2091 // Verification

     2092 

     2093 class VerifyOopsClosure: public OopClosure {

     2094   nmethod* _nm;

     2095   bool     _ok;

     2096 public:

     2097   VerifyOopsClosure(nmethod* nm) : _nm(nm), _ok(true) { }

     2098   bool ok() { return _ok; }

     2099   virtual void do_oop(oop* p) {

     2100     if ((*p) == NULL || (*p)->is_oop())  return;

     2101     if (_ok) {

     2102       _nm->print_nmethod(true);

     2103       _ok = false;

     2104     }

     2105     tty->print_cr("*** non-oop "PTR_FORMAT" found at "PTR_FORMAT" (offset %d)",

     2106                   (intptr_t)(*p), (intptr_t)p, (int)((intptr_t)p - (intptr_t)_nm));

     2107   }

     2108   virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); }

     2109 };

     2110 

     2111 void nmethod::verify() {

     2112 

     2113   // Hmm. OSR methods can be deopted but not marked as zombie or not_entrant

     2114   // seems odd.

     2115 

     2116   if( is_zombie() || is_not_entrant() )

     2117     return;

     2118 

     2119   // Make sure all the entry points are correctly aligned for patching.

     2120   NativeJump::check_verified_entry_alignment(entry_point(), verified_entry_point());

     2121 

     2122   assert(method()->is_oop(), "must be valid");

     2123 

     2124   ResourceMark rm;

     2125 

     2126   if (!CodeCache::contains(this)) {

     2127     fatal(err_msg("nmethod at " INTPTR_FORMAT " not in zone", this));

     2128   }

     2129 

     2130   if(is_native_method() )

     2131     return;

     2132 

     2133   nmethod* nm = CodeCache::find_nmethod(verified_entry_point());

     2134   if (nm != this) {

     2135     fatal(err_msg("findNMethod did not find this nmethod (" INTPTR_FORMAT ")",

     2136                   this));

     2137   }

     2138 

     2139   for (PcDesc* p = scopes_pcs_begin(); p < scopes_pcs_end(); p++) {

     2140     if (! p->verify(this)) {

     2141       tty->print_cr("\t\tin nmethod at " INTPTR_FORMAT " (pcs)", this);

     2142     }

     2143   }

     2144 

     2145   VerifyOopsClosure voc(this);

     2146   oops_do(&voc);

     2147   assert(voc.ok(), "embedded oops must be OK");

     2148   verify_scavenge_root_oops();

     2149 

     2150   verify_scopes();

     2151 }

     2152 

     2153 

     2154 void nmethod::verify_interrupt_point(address call_site) {

     2155   // This code does not work in release mode since

     2156   // owns_lock only is available in debug mode.

     2157   CompiledIC* ic = NULL;

     2158   Thread *cur = Thread::current();

     2159   if (CompiledIC_lock->owner() == cur ||

     2160       ((cur->is_VM_thread() || cur->is_ConcurrentGC_thread()) &&

     2161        SafepointSynchronize::is_at_safepoint())) {

     2162     ic = CompiledIC_at(call_site);

     2163     CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());

     2164   } else {

     2165     MutexLocker ml_verify (CompiledIC_lock);

     2166     ic = CompiledIC_at(call_site);

     2167   }

     2168   PcDesc* pd = pc_desc_at(ic->end_of_call());

     2169   assert(pd != NULL, "PcDesc must exist");

     2170   for (ScopeDesc* sd = new ScopeDesc(this, pd->scope_decode_offset(),

     2171                                      pd->obj_decode_offset(), pd->should_reexecute(),

     2172                                      pd->return_oop());

     2173        !sd->is_top(); sd = sd->sender()) {

     2174     sd->verify();

     2175   }

     2176 }

     2177 

     2178 void nmethod::verify_scopes() {

     2179   if( !method() ) return;       // Runtime stubs have no scope

     2180   if (method()->is_native()) return; // Ignore stub methods.

     2181   // iterate through all interrupt point

     2182   // and verify the debug information is valid.

     2183   RelocIterator iter((nmethod*)this);

     2184   while (iter.next()) {

     2185     address stub = NULL;

     2186     switch (iter.type()) {

     2187       case relocInfo::virtual_call_type:

     2188         verify_interrupt_point(iter.addr());

     2189         break;

     2190       case relocInfo::opt_virtual_call_type:

     2191         stub = iter.opt_virtual_call_reloc()->static_stub();

     2192         verify_interrupt_point(iter.addr());

     2193         break;

     2194       case relocInfo::static_call_type:

     2195         stub = iter.static_call_reloc()->static_stub();

     2196         //verify_interrupt_point(iter.addr());

     2197         break;

     2198       case relocInfo::runtime_call_type:

     2199         address destination = iter.reloc()->value();

     2200         // Right now there is no way to find out which entries support

     2201         // an interrupt point.  It would be nice if we had this

     2202         // information in a table.

     2203         break;

     2204     }

     2205     assert(stub == NULL || stub_contains(stub), "static call stub outside stub section");

     2206   }

     2207 }

     2208 

     2209 

     2210 // -----------------------------------------------------------------------------

     2211 // Non-product code

     2212 #ifndef PRODUCT

     2213 

     2214 class DebugScavengeRoot: public OopClosure {

     2215   nmethod* _nm;

     2216   bool     _ok;

     2217 public:

     2218   DebugScavengeRoot(nmethod* nm) : _nm(nm), _ok(true) { }

     2219   bool ok() { return _ok; }

     2220   virtual void do_oop(oop* p) {

     2221     if ((*p) == NULL || !(*p)->is_scavengable())  return;

     2222     if (_ok) {

     2223       _nm->print_nmethod(true);

     2224       _ok = false;

     2225     }

     2226     tty->print_cr("*** non-perm oop "PTR_FORMAT" found at "PTR_FORMAT" (offset %d)",

     2227                   (intptr_t)(*p), (intptr_t)p, (int)((intptr_t)p - (intptr_t)_nm));

     2228     (*p)->print();

     2229   }

     2230   virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); }

     2231 };

     2232 

     2233 void nmethod::verify_scavenge_root_oops() {

     2234   if (!on_scavenge_root_list()) {

     2235     // Actually look inside, to verify the claim that it's clean.

     2236     DebugScavengeRoot debug_scavenge_root(this);

     2237     oops_do(&debug_scavenge_root);

     2238     if (!debug_scavenge_root.ok())

     2239       fatal("found an unadvertised bad non-perm oop in the code cache");

     2240   }

     2241   assert(scavenge_root_not_marked(), "");

     2242 }

     2243 

     2244 #endif // PRODUCT

     2245 

     2246 // Printing operations

     2247 

     2248 void nmethod::print() const {

     2249   ResourceMark rm;

     2250   ttyLocker ttyl;   // keep the following output all in one block

     2251 

     2252   tty->print("Compiled ");

     2253 

     2254   if (is_compiled_by_c1()) {

     2255     tty->print("(c1) ");

     2256   } else if (is_compiled_by_c2()) {

     2257     tty->print("(c2) ");

     2258   } else {

     2259     tty->print("(nm) ");

     2260   }

     2261 

     2262   print_on(tty, "nmethod");

     2263   tty->cr();

     2264   if (WizardMode) {

     2265     tty->print("((nmethod*) "INTPTR_FORMAT ") ", this);

     2266     tty->print(" for method " INTPTR_FORMAT , (address)method());

     2267     tty->print(" { ");

     2268     if (version())        tty->print("v%d ", version());

     2269     if (level())          tty->print("l%d ", level());

     2270     if (is_in_use())      tty->print("in_use ");

     2271     if (is_not_entrant()) tty->print("not_entrant ");

     2272     if (is_zombie())      tty->print("zombie ");

     2273     if (is_unloaded())    tty->print("unloaded ");

     2274     if (on_scavenge_root_list())  tty->print("scavenge_root ");

     2275     tty->print_cr("}:");

     2276   }

     2277   if (size              () > 0) tty->print_cr(" total in heap  [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d",

     2278                                               (address)this,

     2279                                               (address)this + size(),

     2280                                               size());

     2281   if (relocation_size   () > 0) tty->print_cr(" relocation     [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d",

     2282                                               relocation_begin(),

     2283                                               relocation_end(),

     2284                                               relocation_size());

     2285   if (code_size         () > 0) tty->print_cr(" main code      [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d",

     2286                                               code_begin(),

     2287                                               code_end(),

     2288                                               code_size());

     2289   if (stub_size         () > 0) tty->print_cr(" stub code      [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d",

     2290                                               stub_begin(),

     2291                                               stub_end(),

     2292                                               stub_size());

     2293   if (consts_size       () > 0) tty->print_cr(" constants      [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d",

     2294                                               consts_begin(),

     2295                                               consts_end(),

     2296                                               consts_size());

     2297   if (scopes_data_size  () > 0) tty->print_cr(" scopes data    [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d",

     2298                                               scopes_data_begin(),

     2299                                               scopes_data_end(),

     2300                                               scopes_data_size());

     2301   if (scopes_pcs_size   () > 0) tty->print_cr(" scopes pcs     [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d",

     2302                                               scopes_pcs_begin(),

     2303                                               scopes_pcs_end(),

     2304                                               scopes_pcs_size());

     2305   if (dependencies_size () > 0) tty->print_cr(" dependencies   [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d",

     2306                                               dependencies_begin(),

     2307                                               dependencies_end(),

     2308                                               dependencies_size());

     2309   if (handler_table_size() > 0) tty->print_cr(" handler table  [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d",

     2310                                               handler_table_begin(),

     2311                                               handler_table_end(),

     2312                                               handler_table_size());

     2313   if (nul_chk_table_size() > 0) tty->print_cr(" nul chk table  [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d",

     2314                                               nul_chk_table_begin(),

     2315                                               nul_chk_table_end(),

     2316                                               nul_chk_table_size());

     2317   if (oops_size         () > 0) tty->print_cr(" oops           [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d",

     2318                                               oops_begin(),

     2319                                               oops_end(),

     2320                                               oops_size());

     2321 }

     2322 

     2323 void nmethod::print_code() {

     2324   HandleMark hm;

     2325   ResourceMark m;

     2326   Disassembler::decode(this);

     2327 }

     2328 

     2329 

     2330 #ifndef PRODUCT

     2331 

     2332 void nmethod::print_scopes() {

     2333   // Find the first pc desc for all scopes in the code and print it.

     2334   ResourceMark rm;

     2335   for (PcDesc* p = scopes_pcs_begin(); p < scopes_pcs_end(); p++) {

     2336     if (p->scope_decode_offset() == DebugInformationRecorder::serialized_null)

     2337       continue;

     2338 

     2339     ScopeDesc* sd = scope_desc_at(p->real_pc(this));

     2340     sd->print_on(tty, p);

     2341   }

     2342 }

     2343 

     2344 void nmethod::print_dependencies() {

     2345   ResourceMark rm;

     2346   ttyLocker ttyl;   // keep the following output all in one block

     2347   tty->print_cr("Dependencies:");

     2348   for (Dependencies::DepStream deps(this); deps.next(); ) {

     2349     deps.print_dependency();

     2350     klassOop ctxk = deps.context_type();

     2351     if (ctxk != NULL) {

     2352       Klass* k = Klass::cast(ctxk);

     2353       if (k->oop_is_instance() && ((instanceKlass*)k)->is_dependent_nmethod(this)) {

     2354         tty->print_cr("   [nmethod<=klass]%s", k->external_name());

     2355       }

     2356     }

     2357     deps.log_dependency();  // put it into the xml log also

     2358   }

     2359 }

     2360 

     2361 

     2362 void nmethod::print_relocations() {

     2363   ResourceMark m;       // in case methods get printed via the debugger

     2364   tty->print_cr("relocations:");

     2365   RelocIterator iter(this);

     2366   iter.print();

     2367   if (UseRelocIndex) {

     2368     jint* index_end   = (jint*)relocation_end() - 1;

     2369     jint  index_size  = *index_end;

     2370     jint* index_start = (jint*)( (address)index_end - index_size );

     2371     tty->print_cr("    index @" INTPTR_FORMAT ": index_size=%d", index_start, index_size);

     2372     if (index_size > 0) {

     2373       jint* ip;

     2374       for (ip = index_start; ip+2 <= index_end; ip += 2)

     2375         tty->print_cr("  (%d %d) addr=" INTPTR_FORMAT " @" INTPTR_FORMAT,

     2376                       ip[0],

     2377                       ip[1],

     2378                       header_end()+ip[0],

     2379                       relocation_begin()-1+ip[1]);

     2380       for (; ip < index_end; ip++)

     2381         tty->print_cr("  (%d ?)", ip[0]);

     2382       tty->print_cr("          @" INTPTR_FORMAT ": index_size=%d", ip, *ip++);

     2383       tty->print_cr("reloc_end @" INTPTR_FORMAT ":", ip);

     2384     }

     2385   }

     2386 }

     2387 

     2388 

     2389 void nmethod::print_pcs() {

     2390   ResourceMark m;       // in case methods get printed via debugger

     2391   tty->print_cr("pc-bytecode offsets:");

     2392   for (PcDesc* p = scopes_pcs_begin(); p < scopes_pcs_end(); p++) {

     2393     p->print(this);

     2394   }

     2395 }

     2396 

     2397 #endif // PRODUCT

     2398 

     2399 const char* nmethod::reloc_string_for(u_char* begin, u_char* end) {

     2400   RelocIterator iter(this, begin, end);

     2401   bool have_one = false;

     2402   while (iter.next()) {

     2403     have_one = true;

     2404     switch (iter.type()) {

     2405         case relocInfo::none:                  return "no_reloc";

     2406         case relocInfo::oop_type: {

     2407           stringStream st;

     2408           oop_Relocation* r = iter.oop_reloc();

     2409           oop obj = r->oop_value();

     2410           st.print("oop(");

     2411           if (obj == NULL) st.print("NULL");

     2412           else obj->print_value_on(&st);

     2413           st.print(")");

     2414           return st.as_string();

     2415         }

     2416         case relocInfo::virtual_call_type:     return "virtual_call";

     2417         case relocInfo::opt_virtual_call_type: return "optimized virtual_call";

     2418         case relocInfo::static_call_type:      return "static_call";

     2419         case relocInfo::static_stub_type:      return "static_stub";

     2420         case relocInfo::runtime_call_type:     return "runtime_call";

     2421         case relocInfo::external_word_type:    return "external_word";

     2422         case relocInfo::internal_word_type:    return "internal_word";

     2423         case relocInfo::section_word_type:     return "section_word";

     2424         case relocInfo::poll_type:             return "poll";

     2425         case relocInfo::poll_return_type:      return "poll_return";

     2426         case relocInfo::type_mask:             return "type_bit_mask";

     2427     }

     2428   }

     2429   return have_one ? "other" : NULL;

     2430 }

     2431 

     2432 // Return a the last scope in (begin..end]

     2433 ScopeDesc* nmethod::scope_desc_in(address begin, address end) {

     2434   PcDesc* p = pc_desc_near(begin+1);

     2435   if (p != NULL && p->real_pc(this) <= end) {

     2436     return new ScopeDesc(this, p->scope_decode_offset(),

     2437                          p->obj_decode_offset(), p->should_reexecute(),

     2438                          p->return_oop());

     2439   }

     2440   return NULL;

     2441 }

     2442 

     2443 void nmethod::print_nmethod_labels(outputStream* stream, address block_begin) {

     2444   if (block_begin == entry_point())             stream->print_cr("[Entry Point]");

     2445   if (block_begin == verified_entry_point())    stream->print_cr("[Verified Entry Point]");

     2446   if (block_begin == exception_begin())         stream->print_cr("[Exception Handler]");

     2447   if (block_begin == stub_begin())              stream->print_cr("[Stub Code]");

     2448   if (block_begin == deopt_handler_begin())     stream->print_cr("[Deopt Handler Code]");

     2449   if (block_begin == deopt_mh_handler_begin())  stream->print_cr("[Deopt MH Handler Code]");

     2450   if (block_begin == consts_begin())            stream->print_cr("[Constants]");

     2451   if (block_begin == entry_point()) {

     2452     methodHandle m = method();

     2453     if (m.not_null()) {

     2454       stream->print("  # ");

     2455       m->print_value_on(stream);

     2456       stream->cr();

     2457     }

     2458     if (m.not_null() && !is_osr_method()) {

     2459       ResourceMark rm;

     2460       int sizeargs = m->size_of_parameters();

     2461       BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, sizeargs);

     2462       VMRegPair* regs   = NEW_RESOURCE_ARRAY(VMRegPair, sizeargs);

     2463       {

     2464         int sig_index = 0;

     2465         if (!m->is_static())

     2466           sig_bt[sig_index++] = T_OBJECT; // 'this'

     2467         for (SignatureStream ss(m->signature()); !ss.at_return_type(); ss.next()) {

     2468           BasicType t = ss.type();

     2469           sig_bt[sig_index++] = t;

     2470           if (type2size[t] == 2) {

     2471             sig_bt[sig_index++] = T_VOID;

     2472           } else {

     2473             assert(type2size[t] == 1, "size is 1 or 2");

     2474           }

     2475         }

     2476         assert(sig_index == sizeargs, "");

     2477       }

     2478       const char* spname = "sp"; // make arch-specific?

     2479       intptr_t out_preserve = SharedRuntime::java_calling_convention(sig_bt, regs, sizeargs, false);

     2480       int stack_slot_offset = this->frame_size() * wordSize;

     2481       int tab1 = 14, tab2 = 24;

     2482       int sig_index = 0;

     2483       int arg_index = (m->is_static() ? 0 : -1);

     2484       bool did_old_sp = false;

     2485       for (SignatureStream ss(m->signature()); !ss.at_return_type(); ) {

     2486         bool at_this = (arg_index == -1);

     2487         bool at_old_sp = false;

     2488         BasicType t = (at_this ? T_OBJECT : ss.type());

     2489         assert(t == sig_bt[sig_index], "sigs in sync");

     2490         if (at_this)

     2491           stream->print("  # this: ");

     2492         else

     2493           stream->print("  # parm%d: ", arg_index);

     2494         stream->move_to(tab1);

     2495         VMReg fst = regs[sig_index].first();

     2496         VMReg snd = regs[sig_index].second();

     2497         if (fst->is_reg()) {

     2498           stream->print("%s", fst->name());

     2499           if (snd->is_valid())  {

     2500             stream->print(":%s", snd->name());

     2501           }

     2502         } else if (fst->is_stack()) {

     2503           int offset = fst->reg2stack() * VMRegImpl::stack_slot_size + stack_slot_offset;

     2504           if (offset == stack_slot_offset)  at_old_sp = true;

     2505           stream->print("[%s+0x%x]", spname, offset);

     2506         } else {

     2507           stream->print("reg%d:%d??", (int)(intptr_t)fst, (int)(intptr_t)snd);

     2508         }

     2509         stream->print(" ");

     2510         stream->move_to(tab2);

     2511         stream->print("= ");

     2512         if (at_this) {

     2513           m->method_holder()->print_value_on(stream);

     2514         } else {

     2515           bool did_name = false;

     2516           if (!at_this && ss.is_object()) {

     2517             symbolOop name = ss.as_symbol_or_null();

     2518             if (name != NULL) {

     2519               name->print_value_on(stream);

     2520               did_name = true;

     2521             }

     2522           }

     2523           if (!did_name)

     2524             stream->print("%s", type2name(t));

     2525         }

     2526         if (at_old_sp) {

     2527           stream->print("  (%s of caller)", spname);

     2528           did_old_sp = true;

     2529         }

     2530         stream->cr();

     2531         sig_index += type2size[t];

     2532         arg_index += 1;

     2533         if (!at_this)  ss.next();

     2534       }

     2535       if (!did_old_sp) {

     2536         stream->print("  # ");

     2537         stream->move_to(tab1);

     2538         stream->print("[%s+0x%x]", spname, stack_slot_offset);

     2539         stream->print("  (%s of caller)", spname);

     2540         stream->cr();

     2541       }

     2542     }

     2543   }

     2544 }

     2545 

     2546 void nmethod::print_code_comment_on(outputStream* st, int column, u_char* begin, u_char* end) {

     2547   // First, find an oopmap in (begin, end].

     2548   // We use the odd half-closed interval so that oop maps and scope descs

     2549   // which are tied to the byte after a call are printed with the call itself.

     2550   address base = instructions_begin();

     2551   OopMapSet* oms = oop_maps();

     2552   if (oms != NULL) {

     2553     for (int i = 0, imax = oms->size(); i < imax; i++) {

     2554       OopMap* om = oms->at(i);

     2555       address pc = base + om->offset();

     2556       if (pc > begin) {

     2557         if (pc <= end) {

     2558           st->move_to(column);

     2559           st->print("; ");

     2560           om->print_on(st);

     2561         }

     2562         break;

     2563       }

     2564     }

     2565   }

     2566 

     2567   // Print any debug info present at this pc.

     2568   ScopeDesc* sd  = scope_desc_in(begin, end);

     2569   if (sd != NULL) {

     2570     st->move_to(column);

     2571     if (sd->bci() == SynchronizationEntryBCI) {

     2572       st->print(";*synchronization entry");

     2573     } else {

     2574       if (sd->method().is_null()) {

     2575         st->print("method is NULL");

     2576       } else if (sd->method()->is_native()) {

     2577         st->print("method is native");

     2578       } else {

     2579         address bcp  = sd->method()->bcp_from(sd->bci());

     2580         Bytecodes::Code bc = Bytecodes::java_code_at(bcp);

     2581         st->print(";*%s", Bytecodes::name(bc));

     2582         switch (bc) {

     2583         case Bytecodes::_invokevirtual:

     2584         case Bytecodes::_invokespecial:

     2585         case Bytecodes::_invokestatic:

     2586         case Bytecodes::_invokeinterface:

     2587           {

     2588             Bytecode_invoke* invoke = Bytecode_invoke_at(sd->method(), sd->bci());

     2589             st->print(" ");

     2590             if (invoke->name() != NULL)

     2591               invoke->name()->print_symbol_on(st);

     2592             else

     2593               st->print("<UNKNOWN>");

     2594             break;

     2595           }

     2596         case Bytecodes::_getfield:

     2597         case Bytecodes::_putfield:

     2598         case Bytecodes::_getstatic:

     2599         case Bytecodes::_putstatic:

     2600           {

     2601             methodHandle sdm = sd->method();

     2602             Bytecode_field* field = Bytecode_field_at(sdm(), sdm->bcp_from(sd->bci()));

     2603             constantPoolOop sdmc = sdm->constants();

     2604             symbolOop name = sdmc->name_ref_at(field->index());

     2605             st->print(" ");

     2606             if (name != NULL)

     2607               name->print_symbol_on(st);

     2608             else

     2609               st->print("<UNKNOWN>");

     2610           }

     2611         }

     2612       }

     2613     }

     2614 

     2615     // Print all scopes

     2616     for (;sd != NULL; sd = sd->sender()) {

     2617       st->move_to(column);

     2618       st->print("; -");

     2619       if (sd->method().is_null()) {

     2620         st->print("method is NULL");

     2621       } else {

     2622         sd->method()->print_short_name(st);

     2623       }

     2624       int lineno = sd->method()->line_number_from_bci(sd->bci());

     2625       if (lineno != -1) {

     2626         st->print("@%d (line %d)", sd->bci(), lineno);

     2627       } else {

     2628         st->print("@%d", sd->bci());

     2629       }

     2630       st->cr();

     2631     }

     2632   }

     2633 

     2634   // Print relocation information

     2635   const char* str = reloc_string_for(begin, end);

     2636   if (str != NULL) {

     2637     if (sd != NULL) st->cr();

     2638     st->move_to(column);

     2639     st->print(";   {%s}", str);

     2640   }

     2641   int cont_offset = ImplicitExceptionTable(this).at(begin - instructions_begin());

     2642   if (cont_offset != 0) {

     2643     st->move_to(column);

     2644     st->print("; implicit exception: dispatches to " INTPTR_FORMAT, instructions_begin() + cont_offset);

     2645   }

     2646 

     2647 }

     2648 

     2649 #ifndef PRODUCT

     2650 

     2651 void nmethod::print_value_on(outputStream* st) const {

     2652   print_on(st, "nmethod");