nmethod.cpp revision 1483:1a5913bf5e19
1121468Ssimokawa/* 2121468Ssimokawa * Copyright 1997-2010 Sun Microsystems, Inc. All Rights Reserved. 3121468Ssimokawa * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4121468Ssimokawa * 5121468Ssimokawa * This code is free software; you can redistribute it and/or modify it 6121468Ssimokawa * under the terms of the GNU General Public License version 2 only, as 7121468Ssimokawa * published by the Free Software Foundation. 8121468Ssimokawa * 9121468Ssimokawa * This code is distributed in the hope that it will be useful, but WITHOUT 10121468Ssimokawa * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11121468Ssimokawa * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12121468Ssimokawa * version 2 for more details (a copy is included in the LICENSE file that 13121468Ssimokawa * accompanied this code). 14121468Ssimokawa * 15121468Ssimokawa * You should have received a copy of the GNU General Public License version 16121468Ssimokawa * 2 along with this work; if not, write to the Free Software Foundation, 17121468Ssimokawa * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18121468Ssimokawa * 19121468Ssimokawa * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 20121468Ssimokawa * CA 95054 USA or visit www.sun.com if you need additional information or 21121468Ssimokawa * have any questions. 22121468Ssimokawa * 23121468Ssimokawa */ 24121468Ssimokawa 25121468Ssimokawa# include "incls/_precompiled.incl" 26121468Ssimokawa# include "incls/_nmethod.cpp.incl" 27121468Ssimokawa 28121468Ssimokawa#ifdef DTRACE_ENABLED 29121468Ssimokawa 30121468Ssimokawa// Only bother with this argument setup if dtrace is available 31121468Ssimokawa 32121468SsimokawaHS_DTRACE_PROBE_DECL8(hotspot, compiled__method__load, 33121468Ssimokawa const char*, int, const char*, int, const char*, int, void*, size_t); 34121468Ssimokawa 35121468SsimokawaHS_DTRACE_PROBE_DECL6(hotspot, compiled__method__unload, 36121468Ssimokawa char*, int, char*, int, char*, int); 37121468Ssimokawa 38121468Ssimokawa#define DTRACE_METHOD_UNLOAD_PROBE(method) \ 39121468Ssimokawa { \ 40121468Ssimokawa methodOop m = (method); \ 41194187Sed if (m != NULL) { \ 42121468Ssimokawa symbolOop klass_name = m->klass_name(); \ 43121468Ssimokawa symbolOop name = m->name(); \ 44194187Sed symbolOop signature = m->signature(); \ 45233195Sdim HS_DTRACE_PROBE6(hotspot, compiled__method__unload, \ 46121468Ssimokawa klass_name->bytes(), klass_name->utf8_length(), \ 47121468Ssimokawa name->bytes(), name->utf8_length(), \ 48121468Ssimokawa signature->bytes(), signature->utf8_length()); \ 49121468Ssimokawa } \ 50121468Ssimokawa } 51121468Ssimokawa 52121468Ssimokawa#else // ndef DTRACE_ENABLED 53121468Ssimokawa 54121468Ssimokawa#define DTRACE_METHOD_UNLOAD_PROBE(method) 55121468Ssimokawa 56129760Sbrooks#endif 57121468Ssimokawa 58121468Ssimokawabool nmethod::is_compiled_by_c1() const { 59121468Ssimokawa if (compiler() == NULL || method() == NULL) return false; // can happen during debug printing 60121468Ssimokawa if (is_native_method()) return false; 61121468Ssimokawa return compiler()->is_c1(); 62121468Ssimokawa} 63121468Ssimokawabool nmethod::is_compiled_by_c2() const { 64121468Ssimokawa if (compiler() == NULL || method() == NULL) return false; // can happen during debug printing 65121468Ssimokawa if (is_native_method()) return false; 66121468Ssimokawa return compiler()->is_c2(); 67121468Ssimokawa} 68121468Ssimokawa 69121468Ssimokawa 70126038Ssimokawa 71126038Ssimokawa//--------------------------------------------------------------------------------- 72121468Ssimokawa// NMethod statistics 73121468Ssimokawa// They are printed under various flags, including: 74121468Ssimokawa// PrintC1Statistics, PrintOptoStatistics, LogVMOutput, and LogCompilation. 75121468Ssimokawa// (In the latter two cases, they like other stats are printed to the log only.) 76121468Ssimokawa 77121468Ssimokawa#ifndef PRODUCT 78121468Ssimokawa// These variables are put into one block to reduce relocations 79121468Ssimokawa// and make it simpler to print from the debugger. 80121468Ssimokawastatic 81121468Ssimokawastruct nmethod_stats_struct { 82121468Ssimokawa int nmethod_count; 83126038Ssimokawa int total_size; 84170775Ssimokawa int relocation_size; 85121468Ssimokawa int code_size; 86170775Ssimokawa int stub_size; 87170775Ssimokawa int consts_size; 88121468Ssimokawa int scopes_data_size; 89121468Ssimokawa int scopes_pcs_size; 90121468Ssimokawa int dependencies_size; 91121468Ssimokawa int handler_table_size; 92121468Ssimokawa int nul_chk_table_size; 93121468Ssimokawa int oops_size; 94170422Ssimokawa 95121468Ssimokawa void note_nmethod(nmethod* nm) { 96121468Ssimokawa nmethod_count += 1; 97121468Ssimokawa total_size += nm->size(); 98121468Ssimokawa relocation_size += nm->relocation_size(); 99121468Ssimokawa code_size += nm->code_size(); 100121468Ssimokawa stub_size += nm->stub_size(); 101121468Ssimokawa consts_size += nm->consts_size(); 102121468Ssimokawa oops_size += nm->oops_size(); 103121468Ssimokawa scopes_data_size += nm->scopes_data_size(); 104121468Ssimokawa scopes_pcs_size += nm->scopes_pcs_size(); 105121468Ssimokawa dependencies_size += nm->dependencies_size(); 106121468Ssimokawa handler_table_size += nm->handler_table_size(); 107121468Ssimokawa nul_chk_table_size += nm->nul_chk_table_size(); 108121468Ssimokawa } 109121468Ssimokawa void print_nmethod_stats() { 110170775Ssimokawa if (nmethod_count == 0) return; 111121468Ssimokawa tty->print_cr("Statistics for %d bytecoded nmethods:", nmethod_count); 112121468Ssimokawa if (total_size != 0) tty->print_cr(" total in heap = %d", total_size); 113121468Ssimokawa if (relocation_size != 0) tty->print_cr(" relocation = %d", relocation_size); 114121468Ssimokawa if (code_size != 0) tty->print_cr(" main code = %d", code_size); 115121468Ssimokawa if (stub_size != 0) tty->print_cr(" stub code = %d", stub_size); 116121468Ssimokawa if (consts_size != 0) tty->print_cr(" constants = %d", consts_size); 117121468Ssimokawa if (oops_size != 0) tty->print_cr(" oops = %d", oops_size); 118121468Ssimokawa if (scopes_data_size != 0) tty->print_cr(" scopes data = %d", scopes_data_size); 119121468Ssimokawa if (scopes_pcs_size != 0) tty->print_cr(" scopes pcs = %d", scopes_pcs_size); 120121468Ssimokawa if (dependencies_size != 0) tty->print_cr(" dependencies = %d", dependencies_size); 121121468Ssimokawa if (handler_table_size != 0) tty->print_cr(" handler table = %d", handler_table_size); 122121468Ssimokawa if (nul_chk_table_size != 0) tty->print_cr(" nul chk table = %d", nul_chk_table_size); 123121468Ssimokawa } 124170422Ssimokawa 125170775Ssimokawa int native_nmethod_count; 126121468Ssimokawa int native_total_size; 127121468Ssimokawa int native_relocation_size; 128170775Ssimokawa int native_code_size; 129170775Ssimokawa int native_oops_size; 130121468Ssimokawa void note_native_nmethod(nmethod* nm) { 131121468Ssimokawa native_nmethod_count += 1; 132121468Ssimokawa native_total_size += nm->size(); 133121468Ssimokawa native_relocation_size += nm->relocation_size(); 134121468Ssimokawa native_code_size += nm->code_size(); 135121468Ssimokawa native_oops_size += nm->oops_size(); 136121468Ssimokawa } 137121468Ssimokawa void print_native_nmethod_stats() { 138121468Ssimokawa if (native_nmethod_count == 0) return; 139121468Ssimokawa tty->print_cr("Statistics for %d native nmethods:", native_nmethod_count); 140121468Ssimokawa if (native_total_size != 0) tty->print_cr(" N. total size = %d", native_total_size); 141121468Ssimokawa if (native_relocation_size != 0) tty->print_cr(" N. relocation = %d", native_relocation_size); 142121468Ssimokawa if (native_code_size != 0) tty->print_cr(" N. main code = %d", native_code_size); 143121468Ssimokawa if (native_oops_size != 0) tty->print_cr(" N. oops = %d", native_oops_size); 144121468Ssimokawa } 145121468Ssimokawa 146121468Ssimokawa int pc_desc_resets; // number of resets (= number of caches) 147121468Ssimokawa int pc_desc_queries; // queries to nmethod::find_pc_desc 148121468Ssimokawa int pc_desc_approx; // number of those which have approximate true 149121468Ssimokawa int pc_desc_repeats; // number of _last_pc_desc hits 150121468Ssimokawa int pc_desc_hits; // number of LRU cache hits 151121468Ssimokawa int pc_desc_tests; // total number of PcDesc examinations 152121468Ssimokawa int pc_desc_searches; // total number of quasi-binary search steps 153121468Ssimokawa int pc_desc_adds; // number of LUR cache insertions 154121468Ssimokawa 155121468Ssimokawa void print_pc_stats() { 156121468Ssimokawa tty->print_cr("PcDesc Statistics: %d queries, %.2f comparisons per query", 157121468Ssimokawa pc_desc_queries, 158170775Ssimokawa (double)(pc_desc_tests + pc_desc_searches) 159170422Ssimokawa / pc_desc_queries); 160170775Ssimokawa tty->print_cr(" caches=%d queries=%d/%d, hits=%d+%d, tests=%d+%d, adds=%d", 161170422Ssimokawa pc_desc_resets, 162170422Ssimokawa pc_desc_queries, pc_desc_approx, 163170422Ssimokawa pc_desc_repeats, pc_desc_hits, 164233195Sdim pc_desc_tests, pc_desc_searches, pc_desc_adds); 165233195Sdim } 166233195Sdim} nmethod_stats; 167170775Ssimokawa#endif //PRODUCT 168170775Ssimokawa 169170775Ssimokawa//--------------------------------------------------------------------------------- 170170422Ssimokawa 171170422Ssimokawa 172170422Ssimokawa// The _unwind_handler is a special marker address, which says that 173170422Ssimokawa// for given exception oop and address, the frame should be removed 174170775Ssimokawa// as the tuple cannot be caught in the nmethod 175170422Ssimokawaaddress ExceptionCache::_unwind_handler = (address) -1; 176170775Ssimokawa 177170775Ssimokawa 178170775SsimokawaExceptionCache::ExceptionCache(Handle exception, address pc, address handler) { 179170422Ssimokawa assert(pc != NULL, "Must be non null"); 180170422Ssimokawa assert(exception.not_null(), "Must be non null"); 181170422Ssimokawa assert(handler != NULL, "Must be non null"); 182170422Ssimokawa 183170422Ssimokawa _count = 0; 184170422Ssimokawa _exception_type = exception->klass(); 185170422Ssimokawa _next = NULL; 186170422Ssimokawa 187170422Ssimokawa add_address_and_handler(pc,handler); 188170422Ssimokawa} 189170422Ssimokawa 190170775Ssimokawa 191170775Ssimokawaaddress ExceptionCache::match(Handle exception, address pc) { 192170775Ssimokawa assert(pc != NULL,"Must be non null"); 193170775Ssimokawa assert(exception.not_null(),"Must be non null"); 194170775Ssimokawa if (exception->klass() == exception_type()) { 195170775Ssimokawa return (test_address(pc)); 196170775Ssimokawa } 197170775Ssimokawa 198170775Ssimokawa return NULL; 199170775Ssimokawa} 200170775Ssimokawa 201170775Ssimokawa 202170775Ssimokawabool ExceptionCache::match_exception_with_space(Handle exception) { 203170775Ssimokawa assert(exception.not_null(),"Must be non null"); 204170775Ssimokawa if (exception->klass() == exception_type() && count() < cache_size) { 205170775Ssimokawa return true; 206170775Ssimokawa } 207170775Ssimokawa return false; 208170775Ssimokawa} 209170775Ssimokawa 210170775Ssimokawa 211170775Ssimokawaaddress ExceptionCache::test_address(address addr) { 212170775Ssimokawa for (int i=0; i<count(); i++) { 213170775Ssimokawa if (pc_at(i) == addr) { 214170775Ssimokawa return handler_at(i); 215170775Ssimokawa } 216170775Ssimokawa } 217170775Ssimokawa return NULL; 218170775Ssimokawa} 219170775Ssimokawa 220170775Ssimokawa 221170775Ssimokawabool ExceptionCache::add_address_and_handler(address addr, address handler) { 222170775Ssimokawa if (test_address(addr) == handler) return true; 223170775Ssimokawa if (count() < cache_size) { 224170775Ssimokawa set_pc_at(count(),addr); 225170775Ssimokawa set_handler_at(count(), handler); 226170775Ssimokawa increment_count(); 227170775Ssimokawa return true; 228170775Ssimokawa } 229170775Ssimokawa return false; 230170775Ssimokawa} 231170775Ssimokawa 232170775Ssimokawa 233170775Ssimokawa// private method for handling exception cache 234170775Ssimokawa// These methods are private, and used to manipulate the exception cache 235170775Ssimokawa// directly. 236170775SsimokawaExceptionCache* nmethod::exception_cache_entry_for_exception(Handle exception) { 237170775Ssimokawa ExceptionCache* ec = exception_cache(); 238170775Ssimokawa while (ec != NULL) { 239170775Ssimokawa if (ec->match_exception_with_space(exception)) { 240170775Ssimokawa return ec; 241170775Ssimokawa } 242170775Ssimokawa ec = ec->next(); 243170775Ssimokawa } 244170775Ssimokawa return NULL; 245170775Ssimokawa} 246170775Ssimokawa 247170775Ssimokawa 248170775Ssimokawa//----------------------------------------------------------------------------- 249170775Ssimokawa 250121468Ssimokawa 251121468Ssimokawa// Helper used by both find_pc_desc methods. 252121468Ssimokawastatic inline bool match_desc(PcDesc* pc, int pc_offset, bool approximate) { 253170775Ssimokawa NOT_PRODUCT(++nmethod_stats.pc_desc_tests); 254121468Ssimokawa if (!approximate) 255121468Ssimokawa return pc->pc_offset() == pc_offset; 256121468Ssimokawa else 257121468Ssimokawa return (pc-1)->pc_offset() < pc_offset && pc_offset <= pc->pc_offset(); 258121468Ssimokawa} 259121468Ssimokawa 260122224Ssimokawavoid PcDescCache::reset_to(PcDesc* initial_pc_desc) { 261121468Ssimokawa if (initial_pc_desc == NULL) { 262122224Ssimokawa _last_pc_desc = NULL; // native method 263170775Ssimokawa return; 264121468Ssimokawa } 265121468Ssimokawa NOT_PRODUCT(++nmethod_stats.pc_desc_resets); 266121468Ssimokawa // reset the cache by filling it with benign (non-null) values 267121468Ssimokawa assert(initial_pc_desc->pc_offset() < 0, "must be sentinel"); 268121468Ssimokawa _last_pc_desc = initial_pc_desc + 1; // first valid one is after sentinel 269121468Ssimokawa for (int i = 0; i < cache_size; i++) 270121468Ssimokawa _pc_descs[i] = initial_pc_desc; 271121468Ssimokawa} 272121468Ssimokawa 273170422SsimokawaPcDesc* PcDescCache::find_pc_desc(int pc_offset, bool approximate) { 274121468Ssimokawa NOT_PRODUCT(++nmethod_stats.pc_desc_queries); 275121468Ssimokawa NOT_PRODUCT(if (approximate) ++nmethod_stats.pc_desc_approx); 276121468Ssimokawa 277121468Ssimokawa // In order to prevent race conditions do not load cache elements 278121468Ssimokawa // repeatedly, but use a local copy: 279121468Ssimokawa PcDesc* res; 280121468Ssimokawa 281121468Ssimokawa // Step one: Check the most recently returned value. 282121468Ssimokawa res = _last_pc_desc; 283170433Ssimokawa if (res == NULL) return NULL; // native method; no PcDescs at all 284121468Ssimokawa if (match_desc(res, pc_offset, approximate)) { 285121468Ssimokawa NOT_PRODUCT(++nmethod_stats.pc_desc_repeats); 286121468Ssimokawa return res; 287121468Ssimokawa } 288121468Ssimokawa 289121468Ssimokawa // Step two: Check the LRU cache. 290121468Ssimokawa for (int i = 0; i < cache_size; i++) { 291121468Ssimokawa res = _pc_descs[i]; 292121468Ssimokawa if (res->pc_offset() < 0) break; // optimization: skip empty cache 293121468Ssimokawa if (match_desc(res, pc_offset, approximate)) { 294121468Ssimokawa NOT_PRODUCT(++nmethod_stats.pc_desc_hits); 295121468Ssimokawa _last_pc_desc = res; // record this cache hit in case of repeat 296121468Ssimokawa return res; 297121468Ssimokawa } 298121468Ssimokawa } 299121468Ssimokawa 300170422Ssimokawa // Report failure. 301170422Ssimokawa return NULL; 302121468Ssimokawa} 303170422Ssimokawa 304170422Ssimokawavoid PcDescCache::add_pc_desc(PcDesc* pc_desc) { 305121468Ssimokawa NOT_PRODUCT(++nmethod_stats.pc_desc_adds); 306170422Ssimokawa // Update the LRU cache by shifting pc_desc forward: 307170422Ssimokawa for (int i = 0; i < cache_size; i++) { 308170422Ssimokawa PcDesc* next = _pc_descs[i]; 309170422Ssimokawa _pc_descs[i] = pc_desc; 310170422Ssimokawa pc_desc = next; 311170422Ssimokawa } 312121468Ssimokawa // Note: Do not update _last_pc_desc. It fronts for the LRU cache. 313170422Ssimokawa} 314170422Ssimokawa 315170422Ssimokawa// adjust pcs_size so that it is a multiple of both oopSize and 316170422Ssimokawa// sizeof(PcDesc) (assumes that if sizeof(PcDesc) is not a multiple 317170422Ssimokawa// of oopSize, then 2*sizeof(PcDesc) is) 318121468Ssimokawastatic int adjust_pcs_size(int pcs_size) { 319121468Ssimokawa int nsize = round_to(pcs_size, oopSize); 320121468Ssimokawa if ((nsize % sizeof(PcDesc)) != 0) { 321121468Ssimokawa nsize = pcs_size + sizeof(PcDesc); 322121468Ssimokawa } 323121468Ssimokawa assert((nsize % oopSize) == 0, "correct alignment"); 324121468Ssimokawa return nsize; 325121468Ssimokawa} 326170422Ssimokawa 327170422Ssimokawa//----------------------------------------------------------------------------- 328170422Ssimokawa 329121468Ssimokawa 330121468Ssimokawavoid nmethod::add_exception_cache_entry(ExceptionCache* new_entry) { 331121468Ssimokawa assert(ExceptionCache_lock->owned_by_self(),"Must hold the ExceptionCache_lock"); 332121468Ssimokawa assert(new_entry != NULL,"Must be non null"); 333121468Ssimokawa assert(new_entry->next() == NULL, "Must be null"); 334121468Ssimokawa 335121468Ssimokawa if (exception_cache() != NULL) { 336121468Ssimokawa new_entry->set_next(exception_cache()); 337121468Ssimokawa } 338121468Ssimokawa set_exception_cache(new_entry); 339121468Ssimokawa} 340121468Ssimokawa 341121468Ssimokawavoid nmethod::remove_from_exception_cache(ExceptionCache* ec) { 342121468Ssimokawa ExceptionCache* prev = NULL; 343121468Ssimokawa ExceptionCache* curr = exception_cache(); 344121468Ssimokawa assert(curr != NULL, "nothing to remove"); 345121468Ssimokawa // find the previous and next entry of ec 346121468Ssimokawa while (curr != ec) { 347121468Ssimokawa prev = curr; 348121468Ssimokawa curr = curr->next(); 349121468Ssimokawa assert(curr != NULL, "ExceptionCache not found"); 350121468Ssimokawa } 351121468Ssimokawa // now: curr == ec 352121468Ssimokawa ExceptionCache* next = curr->next(); 353121468Ssimokawa if (prev == NULL) { 354121468Ssimokawa set_exception_cache(next); 355121468Ssimokawa } else { 356121468Ssimokawa prev->set_next(next); 357121468Ssimokawa } 358121468Ssimokawa delete curr; 359121468Ssimokawa} 360121468Ssimokawa 361121468Ssimokawa 362121468Ssimokawa// public method for accessing the exception cache 363121468Ssimokawa// These are the public access methods. 364121468Ssimokawaaddress nmethod::handler_for_exception_and_pc(Handle exception, address pc) { 365121468Ssimokawa // We never grab a lock to read the exception cache, so we may 366121468Ssimokawa // have false negatives. This is okay, as it can only happen during 367121468Ssimokawa // the first few exception lookups for a given nmethod. 368121468Ssimokawa ExceptionCache* ec = exception_cache(); 369121468Ssimokawa while (ec != NULL) { 370121468Ssimokawa address ret_val; 371121468Ssimokawa if ((ret_val = ec->match(exception,pc)) != NULL) { 372121468Ssimokawa return ret_val; 373121468Ssimokawa } 374121468Ssimokawa ec = ec->next(); 375121468Ssimokawa } 376121468Ssimokawa return NULL; 377121468Ssimokawa} 378121468Ssimokawa 379121468Ssimokawa 380121468Ssimokawavoid nmethod::add_handler_for_exception_and_pc(Handle exception, address pc, address handler) { 381121468Ssimokawa // There are potential race conditions during exception cache updates, so we 382121468Ssimokawa // must own the ExceptionCache_lock before doing ANY modifications. Because 383121468Ssimokawa // we don't lock during reads, it is possible to have several threads attempt 384121468Ssimokawa // to update the cache with the same data. We need to check for already inserted 385121468Ssimokawa // copies of the current data before adding it. 386121468Ssimokawa 387121468Ssimokawa MutexLocker ml(ExceptionCache_lock); 388121468Ssimokawa ExceptionCache* target_entry = exception_cache_entry_for_exception(exception); 389121468Ssimokawa 390121468Ssimokawa if (target_entry == NULL || !target_entry->add_address_and_handler(pc,handler)) { 391121468Ssimokawa target_entry = new ExceptionCache(exception,pc,handler); 392121468Ssimokawa add_exception_cache_entry(target_entry); 393121468Ssimokawa } 394121468Ssimokawa} 395121468Ssimokawa 396121468Ssimokawa 397121468Ssimokawa//-------------end of code for ExceptionCache-------------- 398121468Ssimokawa 399121468Ssimokawa 400121468Ssimokawavoid nmFlags::clear() { 401121468Ssimokawa assert(sizeof(nmFlags) == sizeof(int), "using more than one word for nmFlags"); 402121468Ssimokawa *(jint*)this = 0; 403121468Ssimokawa} 404121468Ssimokawa 405121468Ssimokawaint nmethod::total_size() const { 406121468Ssimokawa return 407121468Ssimokawa code_size() + 408121468Ssimokawa stub_size() + 409121468Ssimokawa consts_size() + 410121468Ssimokawa scopes_data_size() + 411121468Ssimokawa scopes_pcs_size() + 412121468Ssimokawa handler_table_size() + 413121468Ssimokawa nul_chk_table_size(); 414121468Ssimokawa} 415121468Ssimokawa 416121468Ssimokawaconst char* nmethod::compile_kind() const { 417121468Ssimokawa if (is_osr_method()) return "osr"; 418121468Ssimokawa if (method() != NULL && is_native_method()) return "c2n"; 419121468Ssimokawa return NULL; 420121468Ssimokawa} 421121468Ssimokawa 422121468Ssimokawa// %%% This variable is no longer used? 423121468Ssimokawaint nmethod::_zombie_instruction_size = NativeJump::instruction_size; 424121468Ssimokawa 425121468Ssimokawa 426121468Ssimokawanmethod* nmethod::new_native_nmethod(methodHandle method, 427121468Ssimokawa CodeBuffer *code_buffer, 428121468Ssimokawa int vep_offset, 429121468Ssimokawa int frame_complete, 430121468Ssimokawa int frame_size, 431121468Ssimokawa ByteSize basic_lock_owner_sp_offset, 432121468Ssimokawa ByteSize basic_lock_sp_offset, 433121468Ssimokawa OopMapSet* oop_maps) { 434121468Ssimokawa // create nmethod 435121468Ssimokawa nmethod* nm = NULL; 436121468Ssimokawa { 437121468Ssimokawa MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 438121468Ssimokawa int native_nmethod_size = allocation_size(code_buffer, sizeof(nmethod)); 439121468Ssimokawa CodeOffsets offsets; 440121468Ssimokawa offsets.set_value(CodeOffsets::Verified_Entry, vep_offset); 441121468Ssimokawa offsets.set_value(CodeOffsets::Frame_Complete, frame_complete); 442121468Ssimokawa nm = new (native_nmethod_size) 443121468Ssimokawa nmethod(method(), native_nmethod_size, &offsets, 444121468Ssimokawa code_buffer, frame_size, 445121468Ssimokawa basic_lock_owner_sp_offset, basic_lock_sp_offset, 446121468Ssimokawa oop_maps); 447121468Ssimokawa NOT_PRODUCT(if (nm != NULL) nmethod_stats.note_native_nmethod(nm)); 448135821Ssimokawa if (PrintAssembly && nm != NULL) 449121468Ssimokawa Disassembler::decode(nm); 450121468Ssimokawa } 451121468Ssimokawa // verify nmethod 452121468Ssimokawa debug_only(if (nm) nm->verify();) // might block 453121468Ssimokawa 454121468Ssimokawa if (nm != NULL) { 455121468Ssimokawa nm->log_new_nmethod(); 456121468Ssimokawa } 457121468Ssimokawa 458121468Ssimokawa return nm; 459121468Ssimokawa} 460121468Ssimokawa 461121468Ssimokawa#ifdef HAVE_DTRACE_H 462135821Ssimokawanmethod* nmethod::new_dtrace_nmethod(methodHandle method, 463135821Ssimokawa CodeBuffer *code_buffer, 464135821Ssimokawa int vep_offset, 465135821Ssimokawa int trap_offset, 466121468Ssimokawa int frame_complete, 467121468Ssimokawa int frame_size) { 468121468Ssimokawa // create nmethod 469121468Ssimokawa nmethod* nm = NULL; 470121468Ssimokawa { 471121468Ssimokawa MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 472121468Ssimokawa int nmethod_size = allocation_size(code_buffer, sizeof(nmethod)); 473121468Ssimokawa CodeOffsets offsets; 474121468Ssimokawa offsets.set_value(CodeOffsets::Verified_Entry, vep_offset); 475121468Ssimokawa offsets.set_value(CodeOffsets::Dtrace_trap, trap_offset); 476121468Ssimokawa offsets.set_value(CodeOffsets::Frame_Complete, frame_complete); 477121468Ssimokawa 478121468Ssimokawa nm = new (nmethod_size) nmethod(method(), nmethod_size, &offsets, code_buffer, frame_size); 479121468Ssimokawa 480121468Ssimokawa NOT_PRODUCT(if (nm != NULL) nmethod_stats.note_nmethod(nm)); 481121468Ssimokawa if (PrintAssembly && nm != NULL) 482121468Ssimokawa Disassembler::decode(nm); 483121468Ssimokawa } 484121468Ssimokawa // verify nmethod 485121468Ssimokawa debug_only(if (nm) nm->verify();) // might block 486121468Ssimokawa 487121468Ssimokawa if (nm != NULL) { 488121468Ssimokawa nm->log_new_nmethod(); 489121468Ssimokawa } 490121468Ssimokawa 491121468Ssimokawa return nm; 492121468Ssimokawa} 493121468Ssimokawa 494121468Ssimokawa#endif // def HAVE_DTRACE_H 495121468Ssimokawa 496121468Ssimokawanmethod* nmethod::new_nmethod(methodHandle method, 497121468Ssimokawa int compile_id, 498121468Ssimokawa int entry_bci, 499121468Ssimokawa CodeOffsets* offsets, 500121468Ssimokawa int orig_pc_offset, 501121468Ssimokawa DebugInformationRecorder* debug_info, 502121468Ssimokawa Dependencies* dependencies, 503121468Ssimokawa CodeBuffer* code_buffer, int frame_size, 504121468Ssimokawa OopMapSet* oop_maps, 505121468Ssimokawa ExceptionHandlerTable* handler_table, 506121468Ssimokawa ImplicitExceptionTable* nul_chk_table, 507121468Ssimokawa AbstractCompiler* compiler, 508121468Ssimokawa int comp_level 509121468Ssimokawa) 510121468Ssimokawa{ 511121468Ssimokawa assert(debug_info->oop_recorder() == code_buffer->oop_recorder(), "shared OR"); 512121468Ssimokawa // create nmethod 513121468Ssimokawa nmethod* nm = NULL; 514121468Ssimokawa { MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 515121468Ssimokawa int nmethod_size = 516121468Ssimokawa allocation_size(code_buffer, sizeof(nmethod)) 517121468Ssimokawa + adjust_pcs_size(debug_info->pcs_size()) 518121468Ssimokawa + round_to(dependencies->size_in_bytes() , oopSize) 519121468Ssimokawa + round_to(handler_table->size_in_bytes(), oopSize) 520121468Ssimokawa + round_to(nul_chk_table->size_in_bytes(), oopSize) 521121468Ssimokawa + round_to(debug_info->data_size() , oopSize); 522121468Ssimokawa nm = new (nmethod_size) 523121468Ssimokawa nmethod(method(), nmethod_size, compile_id, entry_bci, offsets, 524121468Ssimokawa orig_pc_offset, debug_info, dependencies, code_buffer, frame_size, 525121468Ssimokawa oop_maps, 526121468Ssimokawa handler_table, 527121468Ssimokawa nul_chk_table, 528121468Ssimokawa compiler, 529121468Ssimokawa comp_level); 530170775Ssimokawa if (nm != NULL) { 531121468Ssimokawa // To make dependency checking during class loading fast, record 532121468Ssimokawa // the nmethod dependencies in the classes it is dependent on. 533121468Ssimokawa // This allows the dependency checking code to simply walk the 534121468Ssimokawa // class hierarchy above the loaded class, checking only nmethods 535121468Ssimokawa // which are dependent on those classes. The slow way is to 536121468Ssimokawa // check every nmethod for dependencies which makes it linear in 537121468Ssimokawa // the number of methods compiled. For applications with a lot 538121468Ssimokawa // classes the slow way is too slow. 539121468Ssimokawa for (Dependencies::DepStream deps(nm); deps.next(); ) { 540121468Ssimokawa klassOop klass = deps.context_type(); 541121468Ssimokawa if (klass == NULL) continue; // ignore things like evol_method 542121468Ssimokawa 543121468Ssimokawa // record this nmethod as dependent on this klass 544121468Ssimokawa instanceKlass::cast(klass)->add_dependent_nmethod(nm); 545121468Ssimokawa } 546121468Ssimokawa } 547121468Ssimokawa NOT_PRODUCT(if (nm != NULL) nmethod_stats.note_nmethod(nm)); 548121468Ssimokawa if (PrintAssembly && nm != NULL) 549121468Ssimokawa Disassembler::decode(nm); 550121468Ssimokawa } 551121468Ssimokawa 552121468Ssimokawa // verify nmethod 553121468Ssimokawa debug_only(if (nm) nm->verify();) // might block 554121468Ssimokawa 555121468Ssimokawa if (nm != NULL) { 556121468Ssimokawa nm->log_new_nmethod(); 557121468Ssimokawa } 558121468Ssimokawa 559121468Ssimokawa // done 560121468Ssimokawa return nm; 561121468Ssimokawa} 562121468Ssimokawa 563121468Ssimokawa 564121468Ssimokawa// For native wrappers 565121468Ssimokawanmethod::nmethod( 566121468Ssimokawa methodOop method, 567121468Ssimokawa int nmethod_size, 568121468Ssimokawa CodeOffsets* offsets, 569121468Ssimokawa CodeBuffer* code_buffer, 570121468Ssimokawa int frame_size, 571121468Ssimokawa ByteSize basic_lock_owner_sp_offset, 572121468Ssimokawa ByteSize basic_lock_sp_offset, 573121468Ssimokawa OopMapSet* oop_maps ) 574121468Ssimokawa : CodeBlob("native nmethod", code_buffer, sizeof(nmethod), 575121468Ssimokawa nmethod_size, offsets->value(CodeOffsets::Frame_Complete), frame_size, oop_maps), 576121468Ssimokawa _compiled_synchronized_native_basic_lock_owner_sp_offset(basic_lock_owner_sp_offset), 577121468Ssimokawa _compiled_synchronized_native_basic_lock_sp_offset(basic_lock_sp_offset) 578121468Ssimokawa{ 579121468Ssimokawa { 580121468Ssimokawa debug_only(No_Safepoint_Verifier nsv;) 581121468Ssimokawa assert_locked_or_safepoint(CodeCache_lock); 582121468Ssimokawa 583121468Ssimokawa NOT_PRODUCT(_has_debug_info = false); 584121468Ssimokawa _oops_do_mark_link = NULL; 585121468Ssimokawa _method = method; 586121468Ssimokawa _entry_bci = InvocationEntryBci; 587121468Ssimokawa _osr_link = NULL; 588121468Ssimokawa _scavenge_root_link = NULL; 589121468Ssimokawa _scavenge_root_state = 0; 590121468Ssimokawa _saved_nmethod_link = NULL; 591121468Ssimokawa _compiler = NULL; 592121468Ssimokawa // We have no exception handler or deopt handler make the 593121468Ssimokawa // values something that will never match a pc like the nmethod vtable entry 594121468Ssimokawa _exception_offset = 0; 595121468Ssimokawa _deoptimize_offset = 0; 596121468Ssimokawa _deoptimize_mh_offset = 0; 597121468Ssimokawa _orig_pc_offset = 0; 598121468Ssimokawa#ifdef HAVE_DTRACE_H 599121468Ssimokawa _trap_offset = 0; 600121468Ssimokawa#endif // def HAVE_DTRACE_H 601121468Ssimokawa _stub_offset = data_offset(); 602121468Ssimokawa _consts_offset = data_offset(); 603121468Ssimokawa _oops_offset = data_offset(); 604121468Ssimokawa _scopes_data_offset = _oops_offset + round_to(code_buffer->total_oop_size(), oopSize); 605121468Ssimokawa _scopes_pcs_offset = _scopes_data_offset; 606121468Ssimokawa _dependencies_offset = _scopes_pcs_offset; 607121468Ssimokawa _handler_table_offset = _dependencies_offset; 608121468Ssimokawa _nul_chk_table_offset = _handler_table_offset; 609121468Ssimokawa _nmethod_end_offset = _nul_chk_table_offset; 610121468Ssimokawa _compile_id = 0; // default 611170775Ssimokawa _comp_level = CompLevel_none; 612121468Ssimokawa _entry_point = instructions_begin(); 613121468Ssimokawa _verified_entry_point = instructions_begin() + offsets->value(CodeOffsets::Verified_Entry); 614121468Ssimokawa _osr_entry_point = NULL; 615121468Ssimokawa _exception_cache = NULL; 616121468Ssimokawa _pc_desc_cache.reset_to(NULL); 617121468Ssimokawa 618170775Ssimokawa flags.clear(); 619121468Ssimokawa flags.state = alive; 620121468Ssimokawa _markedForDeoptimization = 0; 621121468Ssimokawa 622121468Ssimokawa _lock_count = 0; 623121468Ssimokawa _stack_traversal_mark = 0; 624121468Ssimokawa 625121468Ssimokawa code_buffer->copy_oops_to(this); 626121468Ssimokawa debug_only(verify_scavenge_root_oops()); 627121468Ssimokawa CodeCache::commit(this); 628121468Ssimokawa VTune::create_nmethod(this); 629121468Ssimokawa } 630121468Ssimokawa 631121468Ssimokawa if (PrintNativeNMethods || PrintDebugInfo || PrintRelocations || PrintDependencies) { 632121468Ssimokawa ttyLocker ttyl; // keep the following output all in one block 633121468Ssimokawa // This output goes directly to the tty, not the compiler log. 634170775Ssimokawa // To enable tools to match it up with the compilation activity, 635121468Ssimokawa // be sure to tag this tty output with the compile ID. 636121468Ssimokawa if (xtty != NULL) { 637121468Ssimokawa xtty->begin_head("print_native_nmethod"); 638121468Ssimokawa xtty->method(_method); 639121468Ssimokawa xtty->stamp(); 640121468Ssimokawa xtty->end_head(" address='" INTPTR_FORMAT "'", (intptr_t) this); 641121468Ssimokawa } 642121468Ssimokawa // print the header part first 643121468Ssimokawa print(); 644121468Ssimokawa // then print the requested information 645121468Ssimokawa if (PrintNativeNMethods) { 646121468Ssimokawa print_code(); 647121468Ssimokawa oop_maps->print(); 648170422Ssimokawa } 649170422Ssimokawa if (PrintRelocations) { 650170422Ssimokawa print_relocations(); 651121468Ssimokawa } 652121468Ssimokawa if (xtty != NULL) { 653121468Ssimokawa xtty->tail("print_native_nmethod"); 654121468Ssimokawa } 655121468Ssimokawa } 656121468Ssimokawa Events::log("Create nmethod " INTPTR_FORMAT, this); 657121468Ssimokawa} 658121468Ssimokawa 659121468Ssimokawa// For dtrace wrappers 660121468Ssimokawa#ifdef HAVE_DTRACE_H 661121468Ssimokawanmethod::nmethod( 662121468Ssimokawa methodOop method, 663121468Ssimokawa int nmethod_size, 664121468Ssimokawa CodeOffsets* offsets, 665121468Ssimokawa CodeBuffer* code_buffer, 666121468Ssimokawa int frame_size) 667121468Ssimokawa : CodeBlob("dtrace nmethod", code_buffer, sizeof(nmethod), 668121468Ssimokawa nmethod_size, offsets->value(CodeOffsets::Frame_Complete), frame_size, NULL), 669121468Ssimokawa _compiled_synchronized_native_basic_lock_owner_sp_offset(in_ByteSize(-1)), 670121468Ssimokawa _compiled_synchronized_native_basic_lock_sp_offset(in_ByteSize(-1)) 671121468Ssimokawa{ 672121468Ssimokawa { 673121468Ssimokawa debug_only(No_Safepoint_Verifier nsv;) 674121468Ssimokawa assert_locked_or_safepoint(CodeCache_lock); 675121468Ssimokawa 676121468Ssimokawa NOT_PRODUCT(_has_debug_info = false); 677121468Ssimokawa _oops_do_mark_link = NULL; 678121468Ssimokawa _method = method; 679121468Ssimokawa _entry_bci = InvocationEntryBci; 680121468Ssimokawa _osr_link = NULL; 681121468Ssimokawa _scavenge_root_link = NULL; 682121468Ssimokawa _scavenge_root_state = 0; 683121468Ssimokawa _compiler = NULL; 684121468Ssimokawa // We have no exception handler or deopt handler make the 685121468Ssimokawa // values something that will never match a pc like the nmethod vtable entry 686121468Ssimokawa _exception_offset = 0; 687121468Ssimokawa _deoptimize_offset = 0; 688121468Ssimokawa _deoptimize_mh_offset = 0; 689121468Ssimokawa _unwind_handler_offset = -1; 690121468Ssimokawa _trap_offset = offsets->value(CodeOffsets::Dtrace_trap); 691121468Ssimokawa _orig_pc_offset = 0; 692121468Ssimokawa _stub_offset = data_offset(); 693121468Ssimokawa _consts_offset = data_offset(); 694121468Ssimokawa _oops_offset = data_offset(); 695121468Ssimokawa _scopes_data_offset = _oops_offset + round_to(code_buffer->total_oop_size(), oopSize); 696121468Ssimokawa _scopes_pcs_offset = _scopes_data_offset; 697143415Sstefanf _dependencies_offset = _scopes_pcs_offset; 698143415Sstefanf _handler_table_offset = _dependencies_offset; 699121468Ssimokawa _nul_chk_table_offset = _handler_table_offset; 700121468Ssimokawa _nmethod_end_offset = _nul_chk_table_offset; 701121468Ssimokawa _compile_id = 0; // default 702143415Sstefanf _comp_level = CompLevel_none; 703143415Sstefanf _entry_point = instructions_begin(); 704121468Ssimokawa _verified_entry_point = instructions_begin() + offsets->value(CodeOffsets::Verified_Entry); 705121468Ssimokawa _osr_entry_point = NULL; 706121468Ssimokawa _exception_cache = NULL; 707121468Ssimokawa _pc_desc_cache.reset_to(NULL); 708121468Ssimokawa 709121468Ssimokawa flags.clear(); 710121468Ssimokawa flags.state = alive; 711121468Ssimokawa _markedForDeoptimization = 0; 712121468Ssimokawa 713121468Ssimokawa _lock_count = 0; 714121468Ssimokawa _stack_traversal_mark = 0; 715121468Ssimokawa 716121468Ssimokawa code_buffer->copy_oops_to(this); 717121468Ssimokawa debug_only(verify_scavenge_root_oops()); 718121468Ssimokawa CodeCache::commit(this); 719121468Ssimokawa VTune::create_nmethod(this); 720121468Ssimokawa } 721121468Ssimokawa 722121468Ssimokawa if (PrintNMethods || PrintDebugInfo || PrintRelocations || PrintDependencies) { 723121468Ssimokawa ttyLocker ttyl; // keep the following output all in one block 724121468Ssimokawa // This output goes directly to the tty, not the compiler log. 725121468Ssimokawa // To enable tools to match it up with the compilation activity, 726170146Ssimokawa // be sure to tag this tty output with the compile ID. 727170146Ssimokawa if (xtty != NULL) { 728170146Ssimokawa xtty->begin_head("print_dtrace_nmethod"); 729170146Ssimokawa xtty->method(_method); 730121468Ssimokawa xtty->stamp(); 731170146Ssimokawa xtty->end_head(" address='" INTPTR_FORMAT "'", (intptr_t) this); 732170146Ssimokawa } 733170146Ssimokawa // print the header part first 734170146Ssimokawa print(); 735170146Ssimokawa // then print the requested information 736170146Ssimokawa if (PrintNMethods) { 737121468Ssimokawa print_code(); 738121468Ssimokawa } 739121468Ssimokawa if (PrintRelocations) { 740121468Ssimokawa print_relocations(); 741121468Ssimokawa } 742121468Ssimokawa if (xtty != NULL) { 743121468Ssimokawa xtty->tail("print_dtrace_nmethod"); 744121468Ssimokawa } 745121468Ssimokawa } 746121468Ssimokawa Events::log("Create nmethod " INTPTR_FORMAT, this); 747170422Ssimokawa} 748170775Ssimokawa#endif // def HAVE_DTRACE_H 749121468Ssimokawa 750121468Ssimokawavoid* nmethod::operator new(size_t size, int nmethod_size) { 751170422Ssimokawa // Always leave some room in the CodeCache for I2C/C2I adapters 752121468Ssimokawa if (CodeCache::unallocated_capacity() < CodeCacheMinimumFreeSpace) return NULL; 753121468Ssimokawa return CodeCache::allocate(nmethod_size); 754143416Sstefanf} 755121468Ssimokawa 756121468Ssimokawa 757121468Ssimokawanmethod::nmethod( 758121468Ssimokawa methodOop method, 759121468Ssimokawa int nmethod_size, 760121468Ssimokawa int compile_id, 761121468Ssimokawa int entry_bci, 762121468Ssimokawa CodeOffsets* offsets, 763121468Ssimokawa int orig_pc_offset, 764121468Ssimokawa DebugInformationRecorder* debug_info, 765121468Ssimokawa Dependencies* dependencies, 766121468Ssimokawa CodeBuffer *code_buffer, 767121468Ssimokawa int frame_size, 768121468Ssimokawa OopMapSet* oop_maps, 769121468Ssimokawa ExceptionHandlerTable* handler_table, 770121468Ssimokawa ImplicitExceptionTable* nul_chk_table, 771121468Ssimokawa AbstractCompiler* compiler, 772121468Ssimokawa int comp_level 773121468Ssimokawa ) 774121468Ssimokawa : CodeBlob("nmethod", code_buffer, sizeof(nmethod), 775121468Ssimokawa nmethod_size, offsets->value(CodeOffsets::Frame_Complete), frame_size, oop_maps), 776121468Ssimokawa _compiled_synchronized_native_basic_lock_owner_sp_offset(in_ByteSize(-1)), 777121468Ssimokawa _compiled_synchronized_native_basic_lock_sp_offset(in_ByteSize(-1)) 778170775Ssimokawa{ 779170422Ssimokawa assert(debug_info->oop_recorder() == code_buffer->oop_recorder(), "shared OR"); 780121468Ssimokawa { 781170422Ssimokawa debug_only(No_Safepoint_Verifier nsv;) 782121468Ssimokawa assert_locked_or_safepoint(CodeCache_lock); 783121468Ssimokawa 784121468Ssimokawa NOT_PRODUCT(_has_debug_info = false); 785121468Ssimokawa _oops_do_mark_link = NULL; 786170775Ssimokawa _method = method; 787121468Ssimokawa _compile_id = compile_id; 788121468Ssimokawa _comp_level = comp_level; 789170775Ssimokawa _entry_bci = entry_bci; 790170775Ssimokawa _osr_link = NULL; 791170775Ssimokawa _scavenge_root_link = NULL; 792170775Ssimokawa _scavenge_root_state = 0; 793170775Ssimokawa _compiler = compiler; 794170775Ssimokawa _orig_pc_offset = orig_pc_offset; 795170775Ssimokawa#ifdef HAVE_DTRACE_H 796170775Ssimokawa _trap_offset = 0; 797170422Ssimokawa#endif // def HAVE_DTRACE_H 798170422Ssimokawa _stub_offset = instructions_offset() + code_buffer->total_offset_of(code_buffer->stubs()->start()); 799170775Ssimokawa 800170775Ssimokawa // Exception handler and deopt handler are in the stub section 801170775Ssimokawa _exception_offset = _stub_offset + offsets->value(CodeOffsets::Exceptions); 802170775Ssimokawa _deoptimize_offset = _stub_offset + offsets->value(CodeOffsets::Deopt); 803170775Ssimokawa _deoptimize_mh_offset = _stub_offset + offsets->value(CodeOffsets::DeoptMH); 804170775Ssimokawa if (offsets->value(CodeOffsets::UnwindHandler) != -1) { 805170775Ssimokawa _unwind_handler_offset = instructions_offset() + offsets->value(CodeOffsets::UnwindHandler); 806170422Ssimokawa } else { 807170422Ssimokawa _unwind_handler_offset = -1; 808170422Ssimokawa } 809170422Ssimokawa _consts_offset = instructions_offset() + code_buffer->total_offset_of(code_buffer->consts()->start()); 810170422Ssimokawa _oops_offset = data_offset(); 811170422Ssimokawa _scopes_data_offset = _oops_offset + round_to(code_buffer->total_oop_size (), oopSize); 812170422Ssimokawa _scopes_pcs_offset = _scopes_data_offset + round_to(debug_info->data_size (), oopSize); 813170775Ssimokawa _dependencies_offset = _scopes_pcs_offset + adjust_pcs_size(debug_info->pcs_size()); 814170775Ssimokawa _handler_table_offset = _dependencies_offset + round_to(dependencies->size_in_bytes (), oopSize); 815170775Ssimokawa _nul_chk_table_offset = _handler_table_offset + round_to(handler_table->size_in_bytes(), oopSize); 816170775Ssimokawa _nmethod_end_offset = _nul_chk_table_offset + round_to(nul_chk_table->size_in_bytes(), oopSize); 817170775Ssimokawa 818170422Ssimokawa _entry_point = instructions_begin(); 819121468Ssimokawa _verified_entry_point = instructions_begin() + offsets->value(CodeOffsets::Verified_Entry); 820121468Ssimokawa _osr_entry_point = instructions_begin() + offsets->value(CodeOffsets::OSR_Entry); 821121468Ssimokawa _exception_cache = NULL; 822121468Ssimokawa _pc_desc_cache.reset_to(scopes_pcs_begin()); 823121468Ssimokawa 824170775Ssimokawa flags.clear(); 825121468Ssimokawa flags.state = alive; 826121468Ssimokawa _markedForDeoptimization = 0; 827121468Ssimokawa 828121468Ssimokawa _unload_reported = false; // jvmti state 829121468Ssimokawa 830121468Ssimokawa _lock_count = 0; 831121468Ssimokawa _stack_traversal_mark = 0; 832121468Ssimokawa 833121468Ssimokawa // Copy contents of ScopeDescRecorder to nmethod 834170422Ssimokawa code_buffer->copy_oops_to(this); 835170422Ssimokawa debug_info->copy_to(this); 836170422Ssimokawa dependencies->copy_to(this); 837170422Ssimokawa if (ScavengeRootsInCode && detect_scavenge_root_oops()) { 838170422Ssimokawa CodeCache::add_scavenge_root_nmethod(this); 839121468Ssimokawa } 840121468Ssimokawa debug_only(verify_scavenge_root_oops()); 841121468Ssimokawa 842121468Ssimokawa CodeCache::commit(this); 843121468Ssimokawa 844121468Ssimokawa VTune::create_nmethod(this); 845121468Ssimokawa 846121468Ssimokawa // Copy contents of ExceptionHandlerTable to nmethod 847121468Ssimokawa handler_table->copy_to(this); 848121468Ssimokawa nul_chk_table->copy_to(this); 849121468Ssimokawa 850121468Ssimokawa // we use the information of entry points to find out if a method is 851121468Ssimokawa // static or non static 852121468Ssimokawa assert(compiler->is_c2() || 853121468Ssimokawa _method->is_static() == (entry_point() == _verified_entry_point), 854121468Ssimokawa " entry points must be same for static methods and vice versa"); 855121468Ssimokawa } 856121468Ssimokawa 857121468Ssimokawa bool printnmethods = PrintNMethods 858121468Ssimokawa || CompilerOracle::should_print(_method) 859121468Ssimokawa || CompilerOracle::has_option_string(_method, "PrintNMethods"); 860170775Ssimokawa if (printnmethods || PrintDebugInfo || PrintRelocations || PrintDependencies || PrintExceptionHandlers) { 861170775Ssimokawa print_nmethod(printnmethods); 862121468Ssimokawa } 863121468Ssimokawa 864121468Ssimokawa // Note: Do not verify in here as the CodeCache_lock is 865121468Ssimokawa // taken which would conflict with the CompiledIC_lock 866121468Ssimokawa // which taken during the verification of call sites. 867121468Ssimokawa // (was bug - gri 10/25/99) 868121468Ssimokawa 869121468Ssimokawa Events::log("Create nmethod " INTPTR_FORMAT, this); 870121468Ssimokawa} 871121468Ssimokawa 872121468Ssimokawa 873121468Ssimokawa// Print a short set of xml attributes to identify this nmethod. The 874121468Ssimokawa// output should be embedded in some other element. 875121468Ssimokawavoid nmethod::log_identity(xmlStream* log) const { 876121468Ssimokawa log->print(" compile_id='%d'", compile_id()); 877121468Ssimokawa const char* nm_kind = compile_kind(); 878121468Ssimokawa if (nm_kind != NULL) log->print(" compile_kind='%s'", nm_kind); 879121468Ssimokawa if (compiler() != NULL) { 880121468Ssimokawa log->print(" compiler='%s'", compiler()->name()); 881121468Ssimokawa } 882121468Ssimokawa#ifdef TIERED 883121468Ssimokawa log->print(" level='%d'", comp_level()); 884121468Ssimokawa#endif // TIERED 885121468Ssimokawa} 886121468Ssimokawa 887121468Ssimokawa 888121468Ssimokawa#define LOG_OFFSET(log, name) \ 889121468Ssimokawa if ((intptr_t)name##_end() - (intptr_t)name##_begin()) \ 890121468Ssimokawa log->print(" " XSTR(name) "_offset='%d'" , \ 891121468Ssimokawa (intptr_t)name##_begin() - (intptr_t)this) 892121468Ssimokawa 893121468Ssimokawa 894121468Ssimokawavoid nmethod::log_new_nmethod() const { 895121468Ssimokawa if (LogCompilation && xtty != NULL) { 896121468Ssimokawa ttyLocker ttyl; 897121468Ssimokawa HandleMark hm; 898121468Ssimokawa xtty->begin_elem("nmethod"); 899121468Ssimokawa log_identity(xtty); 900121468Ssimokawa xtty->print(" entry='" INTPTR_FORMAT "' size='%d'", 901121468Ssimokawa instructions_begin(), size()); 902121468Ssimokawa xtty->print(" address='" INTPTR_FORMAT "'", (intptr_t) this); 903121468Ssimokawa 904121468Ssimokawa LOG_OFFSET(xtty, relocation); 905121468Ssimokawa LOG_OFFSET(xtty, code); 906121468Ssimokawa LOG_OFFSET(xtty, stub); 907121468Ssimokawa LOG_OFFSET(xtty, consts); 908121468Ssimokawa LOG_OFFSET(xtty, scopes_data); 909121468Ssimokawa LOG_OFFSET(xtty, scopes_pcs); 910121468Ssimokawa LOG_OFFSET(xtty, dependencies); 911121468Ssimokawa LOG_OFFSET(xtty, handler_table); 912121468Ssimokawa LOG_OFFSET(xtty, nul_chk_table); 913121468Ssimokawa LOG_OFFSET(xtty, oops); 914121468Ssimokawa 915121468Ssimokawa xtty->method(method()); 916121468Ssimokawa xtty->stamp(); 917121468Ssimokawa xtty->end_elem(); 918121468Ssimokawa } 919121468Ssimokawa} 920121468Ssimokawa 921121468Ssimokawa#undef LOG_OFFSET 922121468Ssimokawa 923121468Ssimokawa 924121468Ssimokawa// Print out more verbose output usually for a newly created nmethod. 925121468Ssimokawavoid nmethod::print_on(outputStream* st, const char* title) const { 926170399Ssimokawa if (st != NULL) { 927170399Ssimokawa ttyLocker ttyl; 928121468Ssimokawa // Print a little tag line that looks like +PrintCompilation output: 929121468Ssimokawa int tlen = (int) strlen(title); 930121468Ssimokawa bool do_nl = false; 931121468Ssimokawa if (tlen > 0 && title[tlen-1] == '\n') { tlen--; do_nl = true; } 932121468Ssimokawa st->print("%3d%c %.*s", 933121468Ssimokawa compile_id(), 934121468Ssimokawa is_osr_method() ? '%' : 935121468Ssimokawa method() != NULL && 936121468Ssimokawa is_native_method() ? 'n' : ' ', 937121468Ssimokawa tlen, title); 938121468Ssimokawa#ifdef TIERED 939170399Ssimokawa st->print(" (%d) ", comp_level()); 940170399Ssimokawa#endif // TIERED 941170399Ssimokawa if (WizardMode) st->print(" (" INTPTR_FORMAT ")", this); 942170399Ssimokawa if (Universe::heap()->is_gc_active() && method() != NULL) { 943170399Ssimokawa st->print("(method)"); 944121468Ssimokawa } else if (method() != NULL) { 945121468Ssimokawa method()->print_short_name(st); 946170399Ssimokawa if (is_osr_method()) 947170399Ssimokawa st->print(" @ %d", osr_entry_bci()); 948170399Ssimokawa if (method()->code_size() > 0) 949170399Ssimokawa st->print(" (%d bytes)", method()->code_size()); 950170399Ssimokawa } 951170399Ssimokawa 952170399Ssimokawa if (do_nl) st->cr(); 953170399Ssimokawa } 954170399Ssimokawa} 955121468Ssimokawa 956170399Ssimokawa 957170399Ssimokawavoid nmethod::print_nmethod(bool printmethod) { 958170399Ssimokawa ttyLocker ttyl; // keep the following output all in one block 959170399Ssimokawa if (xtty != NULL) { 960170399Ssimokawa xtty->begin_head("print_nmethod"); 961126038Ssimokawa xtty->stamp(); 962170399Ssimokawa xtty->end_head(); 963121468Ssimokawa } 964121468Ssimokawa // print the header part first 965121468Ssimokawa print(); 966121468Ssimokawa // then print the requested information 967121468Ssimokawa if (printmethod) { 968121468Ssimokawa print_code(); 969121468Ssimokawa print_pcs(); 970121468Ssimokawa oop_maps()->print(); 971121468Ssimokawa } 972121468Ssimokawa if (PrintDebugInfo) { 973121468Ssimokawa print_scopes(); 974121468Ssimokawa } 975121468Ssimokawa if (PrintRelocations) { 976121468Ssimokawa print_relocations(); 977121468Ssimokawa } 978121468Ssimokawa if (PrintDependencies) { 979121468Ssimokawa print_dependencies(); 980121468Ssimokawa } 981121468Ssimokawa if (PrintExceptionHandlers) { 982121468Ssimokawa print_handler_table(); 983121468Ssimokawa print_nul_chk_table(); 984121468Ssimokawa } 985121468Ssimokawa if (xtty != NULL) { 986121468Ssimokawa xtty->tail("print_nmethod"); 987121468Ssimokawa } 988121468Ssimokawa} 989121468Ssimokawa 990121468Ssimokawa 991121468Ssimokawavoid nmethod::set_version(int v) { 992121468Ssimokawa flags.version = v; 993121468Ssimokawa} 994121468Ssimokawa 995121468Ssimokawa 996121468Ssimokawa// Promote one word from an assembly-time handle to a live embedded oop. 997121468Ssimokawainline void nmethod::initialize_immediate_oop(oop* dest, jobject handle) { 998121468Ssimokawa if (handle == NULL || 999121468Ssimokawa // As a special case, IC oops are initialized to 1 or -1. 1000129760Sbrooks handle == (jobject) Universe::non_oop_word()) { 1001121468Ssimokawa (*dest) = (oop) handle; 1002121468Ssimokawa } else { 1003126038Ssimokawa (*dest) = JNIHandles::resolve_non_null(handle); 1004121468Ssimokawa } 1005121468Ssimokawa} 1006121468Ssimokawa 1007121468Ssimokawa 1008121468Ssimokawavoid nmethod::copy_oops(GrowableArray<jobject>* array) { 1009121468Ssimokawa //assert(oops_size() == 0, "do this handshake just once, please"); 1010143416Sstefanf int length = array->length(); 1011121468Ssimokawa assert((address)(oops_begin() + length) <= data_end(), "oops big enough"); 1012121468Ssimokawa oop* dest = oops_begin(); 1013121468Ssimokawa for (int index = 0 ; index < length; index++) { 1014171397Ssimokawa initialize_immediate_oop(&dest[index], array->at(index)); 1015171397Ssimokawa } 1016171397Ssimokawa 1017170775Ssimokawa // Now we can fix up all the oops in the code. We need to do this 1018121468Ssimokawa // in the code because the assembler uses jobjects as placeholders. 1019121468Ssimokawa // The code and relocations have already been initialized by the 1020121468Ssimokawa // CodeBlob constructor, so it is valid even at this early point to 1021121468Ssimokawa // iterate over relocations and patch the code. 1022121468Ssimokawa fix_oop_relocations(NULL, NULL, /*initialize_immediates=*/ true); 1023121468Ssimokawa} 1024121468Ssimokawa 1025121468Ssimokawa 1026170775Ssimokawabool nmethod::is_at_poll_return(address pc) { 1027171397Ssimokawa RelocIterator iter(this, pc, pc+1); 1028170775Ssimokawa while (iter.next()) { 1029121468Ssimokawa if (iter.type() == relocInfo::poll_return_type) 1030121468Ssimokawa return true; 1031121468Ssimokawa } 1032121468Ssimokawa return false; 1033121468Ssimokawa} 1034121468Ssimokawa 1035121468Ssimokawa 1036121468Ssimokawabool nmethod::is_at_poll_or_poll_return(address pc) { 1037121468Ssimokawa RelocIterator iter(this, pc, pc+1); 1038129760Sbrooks while (iter.next()) { 1039129760Sbrooks relocInfo::relocType t = iter.type(); 1040129760Sbrooks if (t == relocInfo::poll_return_type || t == relocInfo::poll_type) 1041129760Sbrooks return true; 1042129760Sbrooks } 1043121468Ssimokawa return false; 1044121468Ssimokawa} 1045121468Ssimokawa 1046121468Ssimokawa 1047121468Ssimokawavoid nmethod::fix_oop_relocations(address begin, address end, bool initialize_immediates) { 1048121468Ssimokawa // re-patch all oop-bearing instructions, just in case some oops moved 1049121468Ssimokawa RelocIterator iter(this, begin, end); 1050121468Ssimokawa while (iter.next()) { 1051121468Ssimokawa if (iter.type() == relocInfo::oop_type) { 1052121468Ssimokawa oop_Relocation* reloc = iter.oop_reloc(); 1053121468Ssimokawa if (initialize_immediates && reloc->oop_is_immediate()) { 1054121468Ssimokawa oop* dest = reloc->oop_addr(); 1055121468Ssimokawa initialize_immediate_oop(dest, (jobject) *dest); 1056121468Ssimokawa } 1057121468Ssimokawa // Refresh the oop-related bits of this instruction. 1058121468Ssimokawa reloc->fix_oop_relocation(); 1059121468Ssimokawa } 1060121468Ssimokawa 1061121468Ssimokawa // There must not be any interfering patches or breakpoints. 1062121468Ssimokawa assert(!(iter.type() == relocInfo::breakpoint_type 1063121468Ssimokawa && iter.breakpoint_reloc()->active()), 1064121468Ssimokawa "no active breakpoint"); 1065121468Ssimokawa } 1066121468Ssimokawa} 1067121468Ssimokawa 1068121468Ssimokawa 1069121468SsimokawaScopeDesc* nmethod::scope_desc_at(address pc) { 1070121468Ssimokawa PcDesc* pd = pc_desc_at(pc); 1071121468Ssimokawa guarantee(pd != NULL, "scope must be present"); 1072121468Ssimokawa return new ScopeDesc(this, pd->scope_decode_offset(), 1073121468Ssimokawa pd->obj_decode_offset(), pd->should_reexecute(), 1074121468Ssimokawa pd->return_oop()); 1075121468Ssimokawa} 1076121468Ssimokawa 1077121468Ssimokawa 1078121468Ssimokawavoid nmethod::clear_inline_caches() { 1079121468Ssimokawa assert(SafepointSynchronize::is_at_safepoint(), "cleaning of IC's only allowed at safepoint"); 1080121468Ssimokawa if (is_zombie()) { 1081121468Ssimokawa return; 1082121468Ssimokawa } 1083121468Ssimokawa 1084121468Ssimokawa RelocIterator iter(this); 1085121468Ssimokawa while (iter.next()) { 1086121468Ssimokawa iter.reloc()->clear_inline_cache(); 1087121468Ssimokawa } 1088121468Ssimokawa} 1089121468Ssimokawa 1090121468Ssimokawa 1091121468Ssimokawavoid nmethod::cleanup_inline_caches() { 1092121468Ssimokawa 1093121468Ssimokawa assert_locked_or_safepoint(CompiledIC_lock); 1094121468Ssimokawa 1095121468Ssimokawa // If the method is not entrant or zombie then a JMP is plastered over the 1096121468Ssimokawa // first few bytes. If an oop in the old code was there, that oop 1097121468Ssimokawa // should not get GC'd. Skip the first few bytes of oops on 1098122356Ssimokawa // not-entrant methods. 1099121468Ssimokawa address low_boundary = verified_entry_point(); 1100121468Ssimokawa if (!is_in_use()) { 1101121468Ssimokawa low_boundary += NativeJump::instruction_size; 1102121468Ssimokawa // %%% Note: On SPARC we patch only a 4-byte trap, not a full NativeJump. 1103121468Ssimokawa // This means that the low_boundary is going to be a little too high. 1104121468Ssimokawa // This shouldn't matter, since oops of non-entrant methods are never used. 1105121468Ssimokawa // In fact, why are we bothering to look at oops in a non-entrant method?? 1106121468Ssimokawa } 1107121468Ssimokawa 1108121468Ssimokawa // Find all calls in an nmethod, and clear the ones that points to zombie methods 1109121468Ssimokawa ResourceMark rm; 1110121468Ssimokawa RelocIterator iter(this, low_boundary); 1111121468Ssimokawa while(iter.next()) { 1112121468Ssimokawa switch(iter.type()) { 1113121468Ssimokawa case relocInfo::virtual_call_type: 1114121468Ssimokawa case relocInfo::opt_virtual_call_type: { 1115121468Ssimokawa CompiledIC *ic = CompiledIC_at(iter.reloc()); 1116121468Ssimokawa // Ok, to lookup references to zombies here 1117121468Ssimokawa CodeBlob *cb = CodeCache::find_blob_unsafe(ic->ic_destination()); 1118121468Ssimokawa if( cb != NULL && cb->is_nmethod() ) { 1119121468Ssimokawa nmethod* nm = (nmethod*)cb; 1120121468Ssimokawa // Clean inline caches pointing to both zombie and not_entrant methods 1121121468Ssimokawa if (!nm->is_in_use() || (nm->method()->code() != nm)) ic->set_to_clean(); 1122121468Ssimokawa } 1123121468Ssimokawa break; 1124121468Ssimokawa } 1125121468Ssimokawa case relocInfo::static_call_type: { 1126121468Ssimokawa CompiledStaticCall *csc = compiledStaticCall_at(iter.reloc()); 1127121468Ssimokawa CodeBlob *cb = CodeCache::find_blob_unsafe(csc->destination()); 1128121468Ssimokawa if( cb != NULL && cb->is_nmethod() ) { 1129121468Ssimokawa nmethod* nm = (nmethod*)cb; 1130121468Ssimokawa // Clean inline caches pointing to both zombie and not_entrant methods 1131121468Ssimokawa if (!nm->is_in_use() || (nm->method()->code() != nm)) csc->set_to_clean(); 1132121468Ssimokawa } 1133121468Ssimokawa break; 1134121468Ssimokawa } 1135121468Ssimokawa } 1136143416Sstefanf } 1137121468Ssimokawa} 1138121468Ssimokawa 1139121468Ssimokawa// This is a private interface with the sweeper. 1140121468Ssimokawavoid nmethod::mark_as_seen_on_stack() { 1141121468Ssimokawa assert(is_not_entrant(), "must be a non-entrant method"); 1142121468Ssimokawa set_stack_traversal_mark(NMethodSweeper::traversal_count()); 1143121468Ssimokawa} 1144121468Ssimokawa 1145121468Ssimokawa// Tell if a non-entrant method can be converted to a zombie (i.e., there is no activations on the stack) 1146121468Ssimokawabool nmethod::can_not_entrant_be_converted() { 1147121468Ssimokawa assert(is_not_entrant(), "must be a non-entrant method"); 1148121468Ssimokawa 1149121468Ssimokawa // Since the nmethod sweeper only does partial sweep the sweeper's traversal 1150121468Ssimokawa // count can be greater than the stack traversal count before it hits the 1151121468Ssimokawa // nmethod for the second time. 1152121468Ssimokawa return stack_traversal_mark()+1 < NMethodSweeper::traversal_count(); 1153121468Ssimokawa} 1154121468Ssimokawa 1155121468Ssimokawavoid nmethod::inc_decompile_count() { 1156121468Ssimokawa // Could be gated by ProfileTraps, but do not bother... 1157121468Ssimokawa methodOop m = method(); 1158 if (m == NULL) return; 1159 methodDataOop mdo = m->method_data(); 1160 if (mdo == NULL) return; 1161 // There is a benign race here. See comments in methodDataOop.hpp. 1162 mdo->inc_decompile_count(); 1163} 1164 1165void nmethod::make_unloaded(BoolObjectClosure* is_alive, oop cause) { 1166 1167 post_compiled_method_unload(); 1168 1169 // Since this nmethod is being unloaded, make sure that dependencies 1170 // recorded in instanceKlasses get flushed and pass non-NULL closure to 1171 // indicate that this work is being done during a GC. 1172 assert(Universe::heap()->is_gc_active(), "should only be called during gc"); 1173 assert(is_alive != NULL, "Should be non-NULL"); 1174 // A non-NULL is_alive closure indicates that this is being called during GC. 1175 flush_dependencies(is_alive); 1176 1177 // Break cycle between nmethod & method 1178 if (TraceClassUnloading && WizardMode) { 1179 tty->print_cr("[Class unloading: Making nmethod " INTPTR_FORMAT 1180 " unloadable], methodOop(" INTPTR_FORMAT 1181 "), cause(" INTPTR_FORMAT ")", 1182 this, (address)_method, (address)cause); 1183 if (!Universe::heap()->is_gc_active()) 1184 cause->klass()->print(); 1185 } 1186 // Unlink the osr method, so we do not look this up again 1187 if (is_osr_method()) { 1188 invalidate_osr_method(); 1189 } 1190 // If _method is already NULL the methodOop is about to be unloaded, 1191 // so we don't have to break the cycle. Note that it is possible to 1192 // have the methodOop live here, in case we unload the nmethod because 1193 // it is pointing to some oop (other than the methodOop) being unloaded. 1194 if (_method != NULL) { 1195 // OSR methods point to the methodOop, but the methodOop does not 1196 // point back! 1197 if (_method->code() == this) { 1198 _method->clear_code(); // Break a cycle 1199 } 1200 _method = NULL; // Clear the method of this dead nmethod 1201 } 1202 // Make the class unloaded - i.e., change state and notify sweeper 1203 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); 1204 if (is_in_use()) { 1205 // Transitioning directly from live to unloaded -- so 1206 // we need to force a cache clean-up; remember this 1207 // for later on. 1208 CodeCache::set_needs_cache_clean(true); 1209 } 1210 flags.state = unloaded; 1211 1212 // Log the unloading. 1213 log_state_change(); 1214 1215 // The methodOop is gone at this point 1216 assert(_method == NULL, "Tautology"); 1217 1218 set_osr_link(NULL); 1219 //set_scavenge_root_link(NULL); // done by prune_scavenge_root_nmethods 1220 NMethodSweeper::notify(this); 1221} 1222 1223void nmethod::invalidate_osr_method() { 1224 assert(_entry_bci != InvocationEntryBci, "wrong kind of nmethod"); 1225 // Remove from list of active nmethods 1226 if (method() != NULL) 1227 instanceKlass::cast(method()->method_holder())->remove_osr_nmethod(this); 1228 // Set entry as invalid 1229 _entry_bci = InvalidOSREntryBci; 1230} 1231 1232void nmethod::log_state_change() const { 1233 if (LogCompilation) { 1234 if (xtty != NULL) { 1235 ttyLocker ttyl; // keep the following output all in one block 1236 if (flags.state == unloaded) { 1237 xtty->begin_elem("make_unloaded thread='" UINTX_FORMAT "'", 1238 os::current_thread_id()); 1239 } else { 1240 xtty->begin_elem("make_not_entrant thread='" UINTX_FORMAT "'%s", 1241 os::current_thread_id(), 1242 (flags.state == zombie ? " zombie='1'" : "")); 1243 } 1244 log_identity(xtty); 1245 xtty->stamp(); 1246 xtty->end_elem(); 1247 } 1248 } 1249 if (PrintCompilation && flags.state != unloaded) { 1250 print_on(tty, flags.state == zombie ? "made zombie " : "made not entrant "); 1251 tty->cr(); 1252 } 1253} 1254 1255// Common functionality for both make_not_entrant and make_zombie 1256bool nmethod::make_not_entrant_or_zombie(unsigned int state) { 1257 assert(state == zombie || state == not_entrant, "must be zombie or not_entrant"); 1258 1259 bool was_alive = false; 1260 1261 // Make sure the nmethod is not flushed in case of a safepoint in code below. 1262 nmethodLocker nml(this); 1263 1264 { 1265 // If the method is already zombie there is nothing to do 1266 if (is_zombie()) { 1267 return false; 1268 } 1269 1270 // invalidate osr nmethod before acquiring the patching lock since 1271 // they both acquire leaf locks and we don't want a deadlock. 1272 // This logic is equivalent to the logic below for patching the 1273 // verified entry point of regular methods. 1274 if (is_osr_method()) { 1275 // this effectively makes the osr nmethod not entrant 1276 invalidate_osr_method(); 1277 } 1278 1279 // Enter critical section. Does not block for safepoint. 1280 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag); 1281 1282 if (flags.state == state) { 1283 // another thread already performed this transition so nothing 1284 // to do, but return false to indicate this. 1285 return false; 1286 } 1287 1288 // The caller can be calling the method statically or through an inline 1289 // cache call. 1290 if (!is_osr_method() && !is_not_entrant()) { 1291 NativeJump::patch_verified_entry(entry_point(), verified_entry_point(), 1292 SharedRuntime::get_handle_wrong_method_stub()); 1293 assert (NativeJump::instruction_size == nmethod::_zombie_instruction_size, ""); 1294 } 1295 1296 was_alive = is_in_use(); // Read state under lock 1297 1298 // Change state 1299 flags.state = state; 1300 1301 // Log the transition once 1302 log_state_change(); 1303 1304 } // leave critical region under Patching_lock 1305 1306 // When the nmethod becomes zombie it is no longer alive so the 1307 // dependencies must be flushed. nmethods in the not_entrant 1308 // state will be flushed later when the transition to zombie 1309 // happens or they get unloaded. 1310 if (state == zombie) { 1311 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 1312 flush_dependencies(NULL); 1313 } else { 1314 assert(state == not_entrant, "other cases may need to be handled differently"); 1315 } 1316 1317 if (state == not_entrant) { 1318 Events::log("Make nmethod not entrant " INTPTR_FORMAT, this); 1319 } else { 1320 Events::log("Make nmethod zombie " INTPTR_FORMAT, this); 1321 } 1322 1323 if (TraceCreateZombies) { 1324 tty->print_cr("nmethod <" INTPTR_FORMAT "> code made %s", this, (state == not_entrant) ? "not entrant" : "zombie"); 1325 } 1326 1327 // Make sweeper aware that there is a zombie method that needs to be removed 1328 NMethodSweeper::notify(this); 1329 1330 // not_entrant only stuff 1331 if (state == not_entrant) { 1332 mark_as_seen_on_stack(); 1333 } 1334 1335 if (was_alive) { 1336 // It's a true state change, so mark the method as decompiled. 1337 // Do it only for transition from alive. 1338 inc_decompile_count(); 1339 } 1340 1341 // zombie only - if a JVMTI agent has enabled the CompiledMethodUnload event 1342 // and it hasn't already been reported for this nmethod then report it now. 1343 // (the event may have been reported earilier if the GC marked it for unloading). 1344 if (state == zombie) { 1345 1346 DTRACE_METHOD_UNLOAD_PROBE(method()); 1347 1348 if (JvmtiExport::should_post_compiled_method_unload() && 1349 !unload_reported()) { 1350 assert(method() != NULL, "checking"); 1351 { 1352 HandleMark hm; 1353 JvmtiExport::post_compiled_method_unload_at_safepoint( 1354 method()->jmethod_id(), code_begin()); 1355 } 1356 set_unload_reported(); 1357 } 1358 } 1359 1360 1361 // Zombie only stuff 1362 if (state == zombie) { 1363 VTune::delete_nmethod(this); 1364 } 1365 1366 // Check whether method got unloaded at a safepoint before this, 1367 // if so we can skip the flushing steps below 1368 if (method() == NULL) return true; 1369 1370 // Remove nmethod from method. 1371 // We need to check if both the _code and _from_compiled_code_entry_point 1372 // refer to this nmethod because there is a race in setting these two fields 1373 // in methodOop as seen in bugid 4947125. 1374 // If the vep() points to the zombie nmethod, the memory for the nmethod 1375 // could be flushed and the compiler and vtable stubs could still call 1376 // through it. 1377 if (method()->code() == this || 1378 method()->from_compiled_entry() == verified_entry_point()) { 1379 HandleMark hm; 1380 method()->clear_code(); 1381 } 1382 1383 return true; 1384} 1385 1386void nmethod::flush() { 1387 // Note that there are no valid oops in the nmethod anymore. 1388 assert(is_zombie() || (is_osr_method() && is_unloaded()), "must be a zombie method"); 1389 assert(is_marked_for_reclamation() || (is_osr_method() && is_unloaded()), "must be marked for reclamation"); 1390 1391 assert (!is_locked_by_vm(), "locked methods shouldn't be flushed"); 1392 assert_locked_or_safepoint(CodeCache_lock); 1393 1394 // completely deallocate this method 1395 EventMark m("flushing nmethod " INTPTR_FORMAT " %s", this, ""); 1396 if (PrintMethodFlushing) { 1397 tty->print_cr("*flushing nmethod %3d/" INTPTR_FORMAT ". Live blobs:" UINT32_FORMAT "/Free CodeCache:" SIZE_FORMAT "Kb", 1398 _compile_id, this, CodeCache::nof_blobs(), CodeCache::unallocated_capacity()/1024); 1399 } 1400 1401 // We need to deallocate any ExceptionCache data. 1402 // Note that we do not need to grab the nmethod lock for this, it 1403 // better be thread safe if we're disposing of it! 1404 ExceptionCache* ec = exception_cache(); 1405 set_exception_cache(NULL); 1406 while(ec != NULL) { 1407 ExceptionCache* next = ec->next(); 1408 delete ec; 1409 ec = next; 1410 } 1411 1412 if (on_scavenge_root_list()) { 1413 CodeCache::drop_scavenge_root_nmethod(this); 1414 } 1415 1416 if (is_speculatively_disconnected()) { 1417 CodeCache::remove_saved_code(this); 1418 } 1419 1420 ((CodeBlob*)(this))->flush(); 1421 1422 CodeCache::free(this); 1423} 1424 1425 1426// 1427// Notify all classes this nmethod is dependent on that it is no 1428// longer dependent. This should only be called in two situations. 1429// First, when a nmethod transitions to a zombie all dependents need 1430// to be clear. Since zombification happens at a safepoint there's no 1431// synchronization issues. The second place is a little more tricky. 1432// During phase 1 of mark sweep class unloading may happen and as a 1433// result some nmethods may get unloaded. In this case the flushing 1434// of dependencies must happen during phase 1 since after GC any 1435// dependencies in the unloaded nmethod won't be updated, so 1436// traversing the dependency information in unsafe. In that case this 1437// function is called with a non-NULL argument and this function only 1438// notifies instanceKlasses that are reachable 1439 1440void nmethod::flush_dependencies(BoolObjectClosure* is_alive) { 1441 assert_locked_or_safepoint(CodeCache_lock); 1442 assert(Universe::heap()->is_gc_active() == (is_alive != NULL), 1443 "is_alive is non-NULL if and only if we are called during GC"); 1444 if (!has_flushed_dependencies()) { 1445 set_has_flushed_dependencies(); 1446 for (Dependencies::DepStream deps(this); deps.next(); ) { 1447 klassOop klass = deps.context_type(); 1448 if (klass == NULL) continue; // ignore things like evol_method 1449 1450 // During GC the is_alive closure is non-NULL, and is used to 1451 // determine liveness of dependees that need to be updated. 1452 if (is_alive == NULL || is_alive->do_object_b(klass)) { 1453 instanceKlass::cast(klass)->remove_dependent_nmethod(this); 1454 } 1455 } 1456 } 1457} 1458 1459 1460// If this oop is not live, the nmethod can be unloaded. 1461bool nmethod::can_unload(BoolObjectClosure* is_alive, 1462 OopClosure* keep_alive, 1463 oop* root, bool unloading_occurred) { 1464 assert(root != NULL, "just checking"); 1465 oop obj = *root; 1466 if (obj == NULL || is_alive->do_object_b(obj)) { 1467 return false; 1468 } 1469 if (obj->is_compiledICHolder()) { 1470 compiledICHolderOop cichk_oop = compiledICHolderOop(obj); 1471 if (is_alive->do_object_b( 1472 cichk_oop->holder_method()->method_holder()) && 1473 is_alive->do_object_b(cichk_oop->holder_klass())) { 1474 // The oop should be kept alive 1475 keep_alive->do_oop(root); 1476 return false; 1477 } 1478 } 1479 // If ScavengeRootsInCode is true, an nmethod might be unloaded 1480 // simply because one of its constant oops has gone dead. 1481 // No actual classes need to be unloaded in order for this to occur. 1482 assert(unloading_occurred || ScavengeRootsInCode, "Inconsistency in unloading"); 1483 make_unloaded(is_alive, obj); 1484 return true; 1485} 1486 1487// ------------------------------------------------------------------ 1488// post_compiled_method_load_event 1489// new method for install_code() path 1490// Transfer information from compilation to jvmti 1491void nmethod::post_compiled_method_load_event() { 1492 1493 methodOop moop = method(); 1494 HS_DTRACE_PROBE8(hotspot, compiled__method__load, 1495 moop->klass_name()->bytes(), 1496 moop->klass_name()->utf8_length(), 1497 moop->name()->bytes(), 1498 moop->name()->utf8_length(), 1499 moop->signature()->bytes(), 1500 moop->signature()->utf8_length(), 1501 code_begin(), code_size()); 1502 1503 if (JvmtiExport::should_post_compiled_method_load()) { 1504 JvmtiExport::post_compiled_method_load(this); 1505 } 1506} 1507 1508void nmethod::post_compiled_method_unload() { 1509 assert(_method != NULL && !is_unloaded(), "just checking"); 1510 DTRACE_METHOD_UNLOAD_PROBE(method()); 1511 1512 // If a JVMTI agent has enabled the CompiledMethodUnload event then 1513 // post the event. Sometime later this nmethod will be made a zombie by 1514 // the sweeper but the methodOop will not be valid at that point. 1515 if (JvmtiExport::should_post_compiled_method_unload()) { 1516 assert(!unload_reported(), "already unloaded"); 1517 HandleMark hm; 1518 JvmtiExport::post_compiled_method_unload_at_safepoint( 1519 method()->jmethod_id(), code_begin()); 1520 } 1521 1522 // The JVMTI CompiledMethodUnload event can be enabled or disabled at 1523 // any time. As the nmethod is being unloaded now we mark it has 1524 // having the unload event reported - this will ensure that we don't 1525 // attempt to report the event in the unlikely scenario where the 1526 // event is enabled at the time the nmethod is made a zombie. 1527 set_unload_reported(); 1528} 1529 1530// This is called at the end of the strong tracing/marking phase of a 1531// GC to unload an nmethod if it contains otherwise unreachable 1532// oops. 1533 1534void nmethod::do_unloading(BoolObjectClosure* is_alive, 1535 OopClosure* keep_alive, bool unloading_occurred) { 1536 // Make sure the oop's ready to receive visitors 1537 assert(!is_zombie() && !is_unloaded(), 1538 "should not call follow on zombie or unloaded nmethod"); 1539 1540 // If the method is not entrant then a JMP is plastered over the 1541 // first few bytes. If an oop in the old code was there, that oop 1542 // should not get GC'd. Skip the first few bytes of oops on 1543 // not-entrant methods. 1544 address low_boundary = verified_entry_point(); 1545 if (is_not_entrant()) { 1546 low_boundary += NativeJump::instruction_size; 1547 // %%% Note: On SPARC we patch only a 4-byte trap, not a full NativeJump. 1548 // (See comment above.) 1549 } 1550 1551 // The RedefineClasses() API can cause the class unloading invariant 1552 // to no longer be true. See jvmtiExport.hpp for details. 1553 // Also, leave a debugging breadcrumb in local flag. 1554 bool a_class_was_redefined = JvmtiExport::has_redefined_a_class(); 1555 if (a_class_was_redefined) { 1556 // This set of the unloading_occurred flag is done before the 1557 // call to post_compiled_method_unload() so that the unloading 1558 // of this nmethod is reported. 1559 unloading_occurred = true; 1560 } 1561 1562 // Follow methodOop 1563 if (can_unload(is_alive, keep_alive, (oop*)&_method, unloading_occurred)) { 1564 return; 1565 } 1566 1567 // Exception cache 1568 ExceptionCache* ec = exception_cache(); 1569 while (ec != NULL) { 1570 oop* ex_addr = (oop*)ec->exception_type_addr(); 1571 oop ex = *ex_addr; 1572 ExceptionCache* next_ec = ec->next(); 1573 if (ex != NULL && !is_alive->do_object_b(ex)) { 1574 assert(!ex->is_compiledICHolder(), "Possible error here"); 1575 remove_from_exception_cache(ec); 1576 } 1577 ec = next_ec; 1578 } 1579 1580 // If class unloading occurred we first iterate over all inline caches and 1581 // clear ICs where the cached oop is referring to an unloaded klass or method. 1582 // The remaining live cached oops will be traversed in the relocInfo::oop_type 1583 // iteration below. 1584 if (unloading_occurred) { 1585 RelocIterator iter(this, low_boundary); 1586 while(iter.next()) { 1587 if (iter.type() == relocInfo::virtual_call_type) { 1588 CompiledIC *ic = CompiledIC_at(iter.reloc()); 1589 oop ic_oop = ic->cached_oop(); 1590 if (ic_oop != NULL && !is_alive->do_object_b(ic_oop)) { 1591 // The only exception is compiledICHolder oops which may 1592 // yet be marked below. (We check this further below). 1593 if (ic_oop->is_compiledICHolder()) { 1594 compiledICHolderOop cichk_oop = compiledICHolderOop(ic_oop); 1595 if (is_alive->do_object_b( 1596 cichk_oop->holder_method()->method_holder()) && 1597 is_alive->do_object_b(cichk_oop->holder_klass())) { 1598 continue; 1599 } 1600 } 1601 ic->set_to_clean(); 1602 assert(ic->cached_oop() == NULL, 1603 "cached oop in IC should be cleared"); 1604 } 1605 } 1606 } 1607 } 1608 1609 // Compiled code 1610 RelocIterator iter(this, low_boundary); 1611 while (iter.next()) { 1612 if (iter.type() == relocInfo::oop_type) { 1613 oop_Relocation* r = iter.oop_reloc(); 1614 // In this loop, we must only traverse those oops directly embedded in 1615 // the code. Other oops (oop_index>0) are seen as part of scopes_oops. 1616 assert(1 == (r->oop_is_immediate()) + 1617 (r->oop_addr() >= oops_begin() && r->oop_addr() < oops_end()), 1618 "oop must be found in exactly one place"); 1619 if (r->oop_is_immediate() && r->oop_value() != NULL) { 1620 if (can_unload(is_alive, keep_alive, r->oop_addr(), unloading_occurred)) { 1621 return; 1622 } 1623 } 1624 } 1625 } 1626 1627 1628 // Scopes 1629 for (oop* p = oops_begin(); p < oops_end(); p++) { 1630 if (*p == Universe::non_oop_word()) continue; // skip non-oops 1631 if (can_unload(is_alive, keep_alive, p, unloading_occurred)) { 1632 return; 1633 } 1634 } 1635 1636#ifndef PRODUCT 1637 // This nmethod was not unloaded; check below that all CompiledICs 1638 // refer to marked oops. 1639 { 1640 RelocIterator iter(this, low_boundary); 1641 while (iter.next()) { 1642 if (iter.type() == relocInfo::virtual_call_type) { 1643 CompiledIC *ic = CompiledIC_at(iter.reloc()); 1644 oop ic_oop = ic->cached_oop(); 1645 assert(ic_oop == NULL || is_alive->do_object_b(ic_oop), 1646 "Found unmarked ic_oop in reachable nmethod"); 1647 } 1648 } 1649 } 1650#endif // !PRODUCT 1651} 1652 1653// This method is called twice during GC -- once while 1654// tracing the "active" nmethods on thread stacks during 1655// the (strong) marking phase, and then again when walking 1656// the code cache contents during the weak roots processing 1657// phase. The two uses are distinguished by means of the 1658// 'do_strong_roots_only' flag, which is true in the first 1659// case. We want to walk the weak roots in the nmethod 1660// only in the second case. The weak roots in the nmethod 1661// are the oops in the ExceptionCache and the InlineCache 1662// oops. 1663void nmethod::oops_do(OopClosure* f, bool do_strong_roots_only) { 1664 // make sure the oops ready to receive visitors 1665 assert(!is_zombie() && !is_unloaded(), 1666 "should not call follow on zombie or unloaded nmethod"); 1667 1668 // If the method is not entrant or zombie then a JMP is plastered over the 1669 // first few bytes. If an oop in the old code was there, that oop 1670 // should not get GC'd. Skip the first few bytes of oops on 1671 // not-entrant methods. 1672 address low_boundary = verified_entry_point(); 1673 if (is_not_entrant()) { 1674 low_boundary += NativeJump::instruction_size; 1675 // %%% Note: On SPARC we patch only a 4-byte trap, not a full NativeJump. 1676 // (See comment above.) 1677 } 1678 1679 // Compiled code 1680 f->do_oop((oop*) &_method); 1681 if (!do_strong_roots_only) { 1682 // weak roots processing phase -- update ExceptionCache oops 1683 ExceptionCache* ec = exception_cache(); 1684 while(ec != NULL) { 1685 f->do_oop((oop*)ec->exception_type_addr()); 1686 ec = ec->next(); 1687 } 1688 } // Else strong roots phase -- skip oops in ExceptionCache 1689 1690 RelocIterator iter(this, low_boundary); 1691 1692 while (iter.next()) { 1693 if (iter.type() == relocInfo::oop_type ) { 1694 oop_Relocation* r = iter.oop_reloc(); 1695 // In this loop, we must only follow those oops directly embedded in 1696 // the code. Other oops (oop_index>0) are seen as part of scopes_oops. 1697 assert(1 == (r->oop_is_immediate()) + 1698 (r->oop_addr() >= oops_begin() && r->oop_addr() < oops_end()), 1699 "oop must be found in exactly one place"); 1700 if (r->oop_is_immediate() && r->oop_value() != NULL) { 1701 f->do_oop(r->oop_addr()); 1702 } 1703 } 1704 } 1705 1706 // Scopes 1707 // This includes oop constants not inlined in the code stream. 1708 for (oop* p = oops_begin(); p < oops_end(); p++) { 1709 if (*p == Universe::non_oop_word()) continue; // skip non-oops 1710 f->do_oop(p); 1711 } 1712} 1713 1714#define NMETHOD_SENTINEL ((nmethod*)badAddress) 1715 1716nmethod* volatile nmethod::_oops_do_mark_nmethods; 1717 1718// An nmethod is "marked" if its _mark_link is set non-null. 1719// Even if it is the end of the linked list, it will have a non-null link value, 1720// as long as it is on the list. 1721// This code must be MP safe, because it is used from parallel GC passes. 1722bool nmethod::test_set_oops_do_mark() { 1723 assert(nmethod::oops_do_marking_is_active(), "oops_do_marking_prologue must be called"); 1724 nmethod* observed_mark_link = _oops_do_mark_link; 1725 if (observed_mark_link == NULL) { 1726 // Claim this nmethod for this thread to mark. 1727 observed_mark_link = (nmethod*) 1728 Atomic::cmpxchg_ptr(NMETHOD_SENTINEL, &_oops_do_mark_link, NULL); 1729 if (observed_mark_link == NULL) { 1730 1731 // Atomically append this nmethod (now claimed) to the head of the list: 1732 nmethod* observed_mark_nmethods = _oops_do_mark_nmethods; 1733 for (;;) { 1734 nmethod* required_mark_nmethods = observed_mark_nmethods; 1735 _oops_do_mark_link = required_mark_nmethods; 1736 observed_mark_nmethods = (nmethod*) 1737 Atomic::cmpxchg_ptr(this, &_oops_do_mark_nmethods, required_mark_nmethods); 1738 if (observed_mark_nmethods == required_mark_nmethods) 1739 break; 1740 } 1741 // Mark was clear when we first saw this guy. 1742 NOT_PRODUCT(if (TraceScavenge) print_on(tty, "oops_do, mark\n")); 1743 return false; 1744 } 1745 } 1746 // On fall through, another racing thread marked this nmethod before we did. 1747 return true; 1748} 1749 1750void nmethod::oops_do_marking_prologue() { 1751 NOT_PRODUCT(if (TraceScavenge) tty->print_cr("[oops_do_marking_prologue")); 1752 assert(_oops_do_mark_nmethods == NULL, "must not call oops_do_marking_prologue twice in a row"); 1753 // We use cmpxchg_ptr instead of regular assignment here because the user 1754 // may fork a bunch of threads, and we need them all to see the same state. 1755 void* observed = Atomic::cmpxchg_ptr(NMETHOD_SENTINEL, &_oops_do_mark_nmethods, NULL); 1756 guarantee(observed == NULL, "no races in this sequential code"); 1757} 1758 1759void nmethod::oops_do_marking_epilogue() { 1760 assert(_oops_do_mark_nmethods != NULL, "must not call oops_do_marking_epilogue twice in a row"); 1761 nmethod* cur = _oops_do_mark_nmethods; 1762 while (cur != NMETHOD_SENTINEL) { 1763 assert(cur != NULL, "not NULL-terminated"); 1764 nmethod* next = cur->_oops_do_mark_link; 1765 cur->_oops_do_mark_link = NULL; 1766 NOT_PRODUCT(if (TraceScavenge) cur->print_on(tty, "oops_do, unmark\n")); 1767 cur = next; 1768 } 1769 void* required = _oops_do_mark_nmethods; 1770 void* observed = Atomic::cmpxchg_ptr(NULL, &_oops_do_mark_nmethods, required); 1771 guarantee(observed == required, "no races in this sequential code"); 1772 NOT_PRODUCT(if (TraceScavenge) tty->print_cr("oops_do_marking_epilogue]")); 1773} 1774 1775class DetectScavengeRoot: public OopClosure { 1776 bool _detected_scavenge_root; 1777public: 1778 DetectScavengeRoot() : _detected_scavenge_root(false) 1779 { NOT_PRODUCT(_print_nm = NULL); } 1780 bool detected_scavenge_root() { return _detected_scavenge_root; } 1781 virtual void do_oop(oop* p) { 1782 if ((*p) != NULL && (*p)->is_scavengable()) { 1783 NOT_PRODUCT(maybe_print(p)); 1784 _detected_scavenge_root = true; 1785 } 1786 } 1787 virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); } 1788 1789#ifndef PRODUCT 1790 nmethod* _print_nm; 1791 void maybe_print(oop* p) { 1792 if (_print_nm == NULL) return; 1793 if (!_detected_scavenge_root) _print_nm->print_on(tty, "new scavenge root"); 1794 tty->print_cr(""PTR_FORMAT"[offset=%d] detected non-perm oop "PTR_FORMAT" (found at "PTR_FORMAT")", 1795 _print_nm, (int)((intptr_t)p - (intptr_t)_print_nm), 1796 (intptr_t)(*p), (intptr_t)p); 1797 (*p)->print(); 1798 } 1799#endif //PRODUCT 1800}; 1801 1802bool nmethod::detect_scavenge_root_oops() { 1803 DetectScavengeRoot detect_scavenge_root; 1804 NOT_PRODUCT(if (TraceScavenge) detect_scavenge_root._print_nm = this); 1805 oops_do(&detect_scavenge_root); 1806 return detect_scavenge_root.detected_scavenge_root(); 1807} 1808 1809// Method that knows how to preserve outgoing arguments at call. This method must be 1810// called with a frame corresponding to a Java invoke 1811void nmethod::preserve_callee_argument_oops(frame fr, const RegisterMap *reg_map, OopClosure* f) { 1812 if (!method()->is_native()) { 1813 SimpleScopeDesc ssd(this, fr.pc()); 1814 Bytecode_invoke* call = Bytecode_invoke_at(ssd.method(), ssd.bci()); 1815 bool has_receiver = call->has_receiver(); 1816 symbolOop signature = call->signature(); 1817 fr.oops_compiled_arguments_do(signature, has_receiver, reg_map, f); 1818 } 1819} 1820 1821 1822oop nmethod::embeddedOop_at(u_char* p) { 1823 RelocIterator iter(this, p, p + oopSize); 1824 while (iter.next()) 1825 if (iter.type() == relocInfo::oop_type) { 1826 return iter.oop_reloc()->oop_value(); 1827 } 1828 return NULL; 1829} 1830 1831 1832inline bool includes(void* p, void* from, void* to) { 1833 return from <= p && p < to; 1834} 1835 1836 1837void nmethod::copy_scopes_pcs(PcDesc* pcs, int count) { 1838 assert(count >= 2, "must be sentinel values, at least"); 1839 1840#ifdef ASSERT 1841 // must be sorted and unique; we do a binary search in find_pc_desc() 1842 int prev_offset = pcs[0].pc_offset(); 1843 assert(prev_offset == PcDesc::lower_offset_limit, 1844 "must start with a sentinel"); 1845 for (int i = 1; i < count; i++) { 1846 int this_offset = pcs[i].pc_offset(); 1847 assert(this_offset > prev_offset, "offsets must be sorted"); 1848 prev_offset = this_offset; 1849 } 1850 assert(prev_offset == PcDesc::upper_offset_limit, 1851 "must end with a sentinel"); 1852#endif //ASSERT 1853 1854 // Search for MethodHandle invokes and tag the nmethod. 1855 for (int i = 0; i < count; i++) { 1856 if (pcs[i].is_method_handle_invoke()) { 1857 set_has_method_handle_invokes(true); 1858 break; 1859 } 1860 } 1861 1862 int size = count * sizeof(PcDesc); 1863 assert(scopes_pcs_size() >= size, "oob"); 1864 memcpy(scopes_pcs_begin(), pcs, size); 1865 1866 // Adjust the final sentinel downward. 1867 PcDesc* last_pc = &scopes_pcs_begin()[count-1]; 1868 assert(last_pc->pc_offset() == PcDesc::upper_offset_limit, "sanity"); 1869 last_pc->set_pc_offset(instructions_size() + 1); 1870 for (; last_pc + 1 < scopes_pcs_end(); last_pc += 1) { 1871 // Fill any rounding gaps with copies of the last record. 1872 last_pc[1] = last_pc[0]; 1873 } 1874 // The following assert could fail if sizeof(PcDesc) is not 1875 // an integral multiple of oopSize (the rounding term). 1876 // If it fails, change the logic to always allocate a multiple 1877 // of sizeof(PcDesc), and fill unused words with copies of *last_pc. 1878 assert(last_pc + 1 == scopes_pcs_end(), "must match exactly"); 1879} 1880 1881void nmethod::copy_scopes_data(u_char* buffer, int size) { 1882 assert(scopes_data_size() >= size, "oob"); 1883 memcpy(scopes_data_begin(), buffer, size); 1884} 1885 1886 1887#ifdef ASSERT 1888static PcDesc* linear_search(nmethod* nm, int pc_offset, bool approximate) { 1889 PcDesc* lower = nm->scopes_pcs_begin(); 1890 PcDesc* upper = nm->scopes_pcs_end(); 1891 lower += 1; // exclude initial sentinel 1892 PcDesc* res = NULL; 1893 for (PcDesc* p = lower; p < upper; p++) { 1894 NOT_PRODUCT(--nmethod_stats.pc_desc_tests); // don't count this call to match_desc 1895 if (match_desc(p, pc_offset, approximate)) { 1896 if (res == NULL) 1897 res = p; 1898 else 1899 res = (PcDesc*) badAddress; 1900 } 1901 } 1902 return res; 1903} 1904#endif 1905 1906 1907// Finds a PcDesc with real-pc equal to "pc" 1908PcDesc* nmethod::find_pc_desc_internal(address pc, bool approximate) { 1909 address base_address = instructions_begin(); 1910 if ((pc < base_address) || 1911 (pc - base_address) >= (ptrdiff_t) PcDesc::upper_offset_limit) { 1912 return NULL; // PC is wildly out of range 1913 } 1914 int pc_offset = (int) (pc - base_address); 1915 1916 // Check the PcDesc cache if it contains the desired PcDesc 1917 // (This as an almost 100% hit rate.) 1918 PcDesc* res = _pc_desc_cache.find_pc_desc(pc_offset, approximate); 1919 if (res != NULL) { 1920 assert(res == linear_search(this, pc_offset, approximate), "cache ok"); 1921 return res; 1922 } 1923 1924 // Fallback algorithm: quasi-linear search for the PcDesc 1925 // Find the last pc_offset less than the given offset. 1926 // The successor must be the required match, if there is a match at all. 1927 // (Use a fixed radix to avoid expensive affine pointer arithmetic.) 1928 PcDesc* lower = scopes_pcs_begin(); 1929 PcDesc* upper = scopes_pcs_end(); 1930 upper -= 1; // exclude final sentinel 1931 if (lower >= upper) return NULL; // native method; no PcDescs at all 1932 1933#define assert_LU_OK \ 1934 /* invariant on lower..upper during the following search: */ \ 1935 assert(lower->pc_offset() < pc_offset, "sanity"); \ 1936 assert(upper->pc_offset() >= pc_offset, "sanity") 1937 assert_LU_OK; 1938 1939 // Use the last successful return as a split point. 1940 PcDesc* mid = _pc_desc_cache.last_pc_desc(); 1941 NOT_PRODUCT(++nmethod_stats.pc_desc_searches); 1942 if (mid->pc_offset() < pc_offset) { 1943 lower = mid; 1944 } else { 1945 upper = mid; 1946 } 1947 1948 // Take giant steps at first (4096, then 256, then 16, then 1) 1949 const int LOG2_RADIX = 4 /*smaller steps in debug mode:*/ debug_only(-1); 1950 const int RADIX = (1 << LOG2_RADIX); 1951 for (int step = (1 << (LOG2_RADIX*3)); step > 1; step >>= LOG2_RADIX) { 1952 while ((mid = lower + step) < upper) { 1953 assert_LU_OK; 1954 NOT_PRODUCT(++nmethod_stats.pc_desc_searches); 1955 if (mid->pc_offset() < pc_offset) { 1956 lower = mid; 1957 } else { 1958 upper = mid; 1959 break; 1960 } 1961 } 1962 assert_LU_OK; 1963 } 1964 1965 // Sneak up on the value with a linear search of length ~16. 1966 while (true) { 1967 assert_LU_OK; 1968 mid = lower + 1; 1969 NOT_PRODUCT(++nmethod_stats.pc_desc_searches); 1970 if (mid->pc_offset() < pc_offset) { 1971 lower = mid; 1972 } else { 1973 upper = mid; 1974 break; 1975 } 1976 } 1977#undef assert_LU_OK 1978 1979 if (match_desc(upper, pc_offset, approximate)) { 1980 assert(upper == linear_search(this, pc_offset, approximate), "search ok"); 1981 _pc_desc_cache.add_pc_desc(upper); 1982 return upper; 1983 } else { 1984 assert(NULL == linear_search(this, pc_offset, approximate), "search ok"); 1985 return NULL; 1986 } 1987} 1988 1989 1990bool nmethod::check_all_dependencies() { 1991 bool found_check = false; 1992 // wholesale check of all dependencies 1993 for (Dependencies::DepStream deps(this); deps.next(); ) { 1994 if (deps.check_dependency() != NULL) { 1995 found_check = true; 1996 NOT_DEBUG(break); 1997 } 1998 } 1999 return found_check; // tell caller if we found anything 2000} 2001 2002bool nmethod::check_dependency_on(DepChange& changes) { 2003 // What has happened: 2004 // 1) a new class dependee has been added 2005 // 2) dependee and all its super classes have been marked 2006 bool found_check = false; // set true if we are upset 2007 for (Dependencies::DepStream deps(this); deps.next(); ) { 2008 // Evaluate only relevant dependencies. 2009 if (deps.spot_check_dependency_at(changes) != NULL) { 2010 found_check = true; 2011 NOT_DEBUG(break); 2012 } 2013 } 2014 return found_check; 2015} 2016 2017bool nmethod::is_evol_dependent_on(klassOop dependee) { 2018 instanceKlass *dependee_ik = instanceKlass::cast(dependee); 2019 objArrayOop dependee_methods = dependee_ik->methods(); 2020 for (Dependencies::DepStream deps(this); deps.next(); ) { 2021 if (deps.type() == Dependencies::evol_method) { 2022 methodOop method = deps.method_argument(0); 2023 for (int j = 0; j < dependee_methods->length(); j++) { 2024 if ((methodOop) dependee_methods->obj_at(j) == method) { 2025 // RC_TRACE macro has an embedded ResourceMark 2026 RC_TRACE(0x01000000, 2027 ("Found evol dependency of nmethod %s.%s(%s) compile_id=%d on method %s.%s(%s)", 2028 _method->method_holder()->klass_part()->external_name(), 2029 _method->name()->as_C_string(), 2030 _method->signature()->as_C_string(), compile_id(), 2031 method->method_holder()->klass_part()->external_name(), 2032 method->name()->as_C_string(), 2033 method->signature()->as_C_string())); 2034 if (TraceDependencies || LogCompilation) 2035 deps.log_dependency(dependee); 2036 return true; 2037 } 2038 } 2039 } 2040 } 2041 return false; 2042} 2043 2044// Called from mark_for_deoptimization, when dependee is invalidated. 2045bool nmethod::is_dependent_on_method(methodOop dependee) { 2046 for (Dependencies::DepStream deps(this); deps.next(); ) { 2047 if (deps.type() != Dependencies::evol_method) 2048 continue; 2049 methodOop method = deps.method_argument(0); 2050 if (method == dependee) return true; 2051 } 2052 return false; 2053} 2054 2055 2056bool nmethod::is_patchable_at(address instr_addr) { 2057 assert (code_contains(instr_addr), "wrong nmethod used"); 2058 if (is_zombie()) { 2059 // a zombie may never be patched 2060 return false; 2061 } 2062 return true; 2063} 2064 2065 2066address nmethod::continuation_for_implicit_exception(address pc) { 2067 // Exception happened outside inline-cache check code => we are inside 2068 // an active nmethod => use cpc to determine a return address 2069 int exception_offset = pc - instructions_begin(); 2070 int cont_offset = ImplicitExceptionTable(this).at( exception_offset ); 2071#ifdef ASSERT 2072 if (cont_offset == 0) { 2073 Thread* thread = ThreadLocalStorage::get_thread_slow(); 2074 ResetNoHandleMark rnm; // Might be called from LEAF/QUICK ENTRY 2075 HandleMark hm(thread); 2076 ResourceMark rm(thread); 2077 CodeBlob* cb = CodeCache::find_blob(pc); 2078 assert(cb != NULL && cb == this, ""); 2079 tty->print_cr("implicit exception happened at " INTPTR_FORMAT, pc); 2080 print(); 2081 method()->print_codes(); 2082 print_code(); 2083 print_pcs(); 2084 } 2085#endif 2086 if (cont_offset == 0) { 2087 // Let the normal error handling report the exception 2088 return NULL; 2089 } 2090 return instructions_begin() + cont_offset; 2091} 2092 2093 2094 2095void nmethod_init() { 2096 // make sure you didn't forget to adjust the filler fields 2097 assert(sizeof(nmFlags) <= 4, "nmFlags occupies more than a word"); 2098 assert(sizeof(nmethod) % oopSize == 0, "nmethod size must be multiple of a word"); 2099} 2100 2101 2102//------------------------------------------------------------------------------------------- 2103 2104 2105// QQQ might we make this work from a frame?? 2106nmethodLocker::nmethodLocker(address pc) { 2107 CodeBlob* cb = CodeCache::find_blob(pc); 2108 guarantee(cb != NULL && cb->is_nmethod(), "bad pc for a nmethod found"); 2109 _nm = (nmethod*)cb; 2110 lock_nmethod(_nm); 2111} 2112 2113void nmethodLocker::lock_nmethod(nmethod* nm) { 2114 if (nm == NULL) return; 2115 Atomic::inc(&nm->_lock_count); 2116 guarantee(!nm->is_zombie(), "cannot lock a zombie method"); 2117} 2118 2119void nmethodLocker::unlock_nmethod(nmethod* nm) { 2120 if (nm == NULL) return; 2121 Atomic::dec(&nm->_lock_count); 2122 guarantee(nm->_lock_count >= 0, "unmatched nmethod lock/unlock"); 2123} 2124 2125 2126// ----------------------------------------------------------------------------- 2127// nmethod::get_deopt_original_pc 2128// 2129// Return the original PC for the given PC if: 2130// (a) the given PC belongs to a nmethod and 2131// (b) it is a deopt PC 2132address nmethod::get_deopt_original_pc(const frame* fr) { 2133 if (fr->cb() == NULL) return NULL; 2134 2135 nmethod* nm = fr->cb()->as_nmethod_or_null(); 2136 if (nm != NULL && nm->is_deopt_pc(fr->pc())) 2137 return nm->get_original_pc(fr); 2138 2139 return NULL; 2140} 2141 2142 2143// ----------------------------------------------------------------------------- 2144// MethodHandle 2145 2146bool nmethod::is_method_handle_return(address return_pc) { 2147 if (!has_method_handle_invokes()) return false; 2148 PcDesc* pd = pc_desc_at(return_pc); 2149 if (pd == NULL) 2150 return false; 2151 return pd->is_method_handle_invoke(); 2152} 2153 2154 2155// ----------------------------------------------------------------------------- 2156// Verification 2157 2158class VerifyOopsClosure: public OopClosure { 2159 nmethod* _nm; 2160 bool _ok; 2161public: 2162 VerifyOopsClosure(nmethod* nm) : _nm(nm), _ok(true) { } 2163 bool ok() { return _ok; } 2164 virtual void do_oop(oop* p) { 2165 if ((*p) == NULL || (*p)->is_oop()) return; 2166 if (_ok) { 2167 _nm->print_nmethod(true); 2168 _ok = false; 2169 } 2170 tty->print_cr("*** non-oop "PTR_FORMAT" found at "PTR_FORMAT" (offset %d)", 2171 (intptr_t)(*p), (intptr_t)p, (int)((intptr_t)p - (intptr_t)_nm)); 2172 } 2173 virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); } 2174}; 2175 2176void nmethod::verify() { 2177 2178 // Hmm. OSR methods can be deopted but not marked as zombie or not_entrant 2179 // seems odd. 2180 2181 if( is_zombie() || is_not_entrant() ) 2182 return; 2183 2184 // Make sure all the entry points are correctly aligned for patching. 2185 NativeJump::check_verified_entry_alignment(entry_point(), verified_entry_point()); 2186 2187 assert(method()->is_oop(), "must be valid"); 2188 2189 ResourceMark rm; 2190 2191 if (!CodeCache::contains(this)) { 2192 fatal(err_msg("nmethod at " INTPTR_FORMAT " not in zone", this)); 2193 } 2194 2195 if(is_native_method() ) 2196 return; 2197 2198 nmethod* nm = CodeCache::find_nmethod(verified_entry_point()); 2199 if (nm != this) { 2200 fatal(err_msg("findNMethod did not find this nmethod (" INTPTR_FORMAT ")", 2201 this)); 2202 } 2203 2204 for (PcDesc* p = scopes_pcs_begin(); p < scopes_pcs_end(); p++) { 2205 if (! p->verify(this)) { 2206 tty->print_cr("\t\tin nmethod at " INTPTR_FORMAT " (pcs)", this); 2207 } 2208 } 2209 2210 VerifyOopsClosure voc(this); 2211 oops_do(&voc); 2212 assert(voc.ok(), "embedded oops must be OK"); 2213 verify_scavenge_root_oops(); 2214 2215 verify_scopes(); 2216} 2217 2218 2219void nmethod::verify_interrupt_point(address call_site) { 2220 // This code does not work in release mode since 2221 // owns_lock only is available in debug mode. 2222 CompiledIC* ic = NULL; 2223 Thread *cur = Thread::current(); 2224 if (CompiledIC_lock->owner() == cur || 2225 ((cur->is_VM_thread() || cur->is_ConcurrentGC_thread()) && 2226 SafepointSynchronize::is_at_safepoint())) { 2227 ic = CompiledIC_at(call_site); 2228 CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops()); 2229 } else { 2230 MutexLocker ml_verify (CompiledIC_lock); 2231 ic = CompiledIC_at(call_site); 2232 } 2233 PcDesc* pd = pc_desc_at(ic->end_of_call()); 2234 assert(pd != NULL, "PcDesc must exist"); 2235 for (ScopeDesc* sd = new ScopeDesc(this, pd->scope_decode_offset(), 2236 pd->obj_decode_offset(), pd->should_reexecute(), 2237 pd->return_oop()); 2238 !sd->is_top(); sd = sd->sender()) { 2239 sd->verify(); 2240 } 2241} 2242 2243void nmethod::verify_scopes() { 2244 if( !method() ) return; // Runtime stubs have no scope 2245 if (method()->is_native()) return; // Ignore stub methods. 2246 // iterate through all interrupt point 2247 // and verify the debug information is valid. 2248 RelocIterator iter((nmethod*)this); 2249 while (iter.next()) { 2250 address stub = NULL; 2251 switch (iter.type()) { 2252 case relocInfo::virtual_call_type: 2253 verify_interrupt_point(iter.addr()); 2254 break; 2255 case relocInfo::opt_virtual_call_type: 2256 stub = iter.opt_virtual_call_reloc()->static_stub(); 2257 verify_interrupt_point(iter.addr()); 2258 break; 2259 case relocInfo::static_call_type: 2260 stub = iter.static_call_reloc()->static_stub(); 2261 //verify_interrupt_point(iter.addr()); 2262 break; 2263 case relocInfo::runtime_call_type: 2264 address destination = iter.reloc()->value(); 2265 // Right now there is no way to find out which entries support 2266 // an interrupt point. It would be nice if we had this 2267 // information in a table. 2268 break; 2269 } 2270 assert(stub == NULL || stub_contains(stub), "static call stub outside stub section"); 2271 } 2272} 2273 2274 2275// ----------------------------------------------------------------------------- 2276// Non-product code 2277#ifndef PRODUCT 2278 2279class DebugScavengeRoot: public OopClosure { 2280 nmethod* _nm; 2281 bool _ok; 2282public: 2283 DebugScavengeRoot(nmethod* nm) : _nm(nm), _ok(true) { } 2284 bool ok() { return _ok; } 2285 virtual void do_oop(oop* p) { 2286 if ((*p) == NULL || !(*p)->is_scavengable()) return; 2287 if (_ok) { 2288 _nm->print_nmethod(true); 2289 _ok = false; 2290 } 2291 tty->print_cr("*** non-perm oop "PTR_FORMAT" found at "PTR_FORMAT" (offset %d)", 2292 (intptr_t)(*p), (intptr_t)p, (int)((intptr_t)p - (intptr_t)_nm)); 2293 (*p)->print(); 2294 } 2295 virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); } 2296}; 2297 2298void nmethod::verify_scavenge_root_oops() { 2299 if (!on_scavenge_root_list()) { 2300 // Actually look inside, to verify the claim that it's clean. 2301 DebugScavengeRoot debug_scavenge_root(this); 2302 oops_do(&debug_scavenge_root); 2303 if (!debug_scavenge_root.ok()) 2304 fatal("found an unadvertised bad non-perm oop in the code cache"); 2305 } 2306 assert(scavenge_root_not_marked(), ""); 2307} 2308 2309#endif // PRODUCT 2310 2311// Printing operations 2312 2313void nmethod::print() const { 2314 ResourceMark rm; 2315 ttyLocker ttyl; // keep the following output all in one block 2316 2317 tty->print("Compiled "); 2318 2319 if (is_compiled_by_c1()) { 2320 tty->print("(c1) "); 2321 } else if (is_compiled_by_c2()) { 2322 tty->print("(c2) "); 2323 } else { 2324 tty->print("(nm) "); 2325 } 2326 2327 print_on(tty, "nmethod"); 2328 tty->cr(); 2329 if (WizardMode) { 2330 tty->print("((nmethod*) "INTPTR_FORMAT ") ", this); 2331 tty->print(" for method " INTPTR_FORMAT , (address)method()); 2332 tty->print(" { "); 2333 if (version()) tty->print("v%d ", version()); 2334 if (is_in_use()) tty->print("in_use "); 2335 if (is_not_entrant()) tty->print("not_entrant "); 2336 if (is_zombie()) tty->print("zombie "); 2337 if (is_unloaded()) tty->print("unloaded "); 2338 if (on_scavenge_root_list()) tty->print("scavenge_root "); 2339 tty->print_cr("}:"); 2340 } 2341 if (size () > 0) tty->print_cr(" total in heap [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d", 2342 (address)this, 2343 (address)this + size(), 2344 size()); 2345 if (relocation_size () > 0) tty->print_cr(" relocation [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d", 2346 relocation_begin(), 2347 relocation_end(), 2348 relocation_size()); 2349 if (code_size () > 0) tty->print_cr(" main code [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d", 2350 code_begin(), 2351 code_end(), 2352 code_size()); 2353 if (stub_size () > 0) tty->print_cr(" stub code [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d", 2354 stub_begin(), 2355 stub_end(), 2356 stub_size()); 2357 if (consts_size () > 0) tty->print_cr(" constants [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d", 2358 consts_begin(), 2359 consts_end(), 2360 consts_size()); 2361 if (oops_size () > 0) tty->print_cr(" oops [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d", 2362 oops_begin(), 2363 oops_end(), 2364 oops_size()); 2365 if (scopes_data_size () > 0) tty->print_cr(" scopes data [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d", 2366 scopes_data_begin(), 2367 scopes_data_end(), 2368 scopes_data_size()); 2369 if (scopes_pcs_size () > 0) tty->print_cr(" scopes pcs [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d", 2370 scopes_pcs_begin(), 2371 scopes_pcs_end(), 2372 scopes_pcs_size()); 2373 if (dependencies_size () > 0) tty->print_cr(" dependencies [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d", 2374 dependencies_begin(), 2375 dependencies_end(), 2376 dependencies_size()); 2377 if (handler_table_size() > 0) tty->print_cr(" handler table [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d", 2378 handler_table_begin(), 2379 handler_table_end(), 2380 handler_table_size()); 2381 if (nul_chk_table_size() > 0) tty->print_cr(" nul chk table [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d", 2382 nul_chk_table_begin(), 2383 nul_chk_table_end(), 2384 nul_chk_table_size()); 2385 if (oops_size () > 0) tty->print_cr(" oops [" INTPTR_FORMAT "," INTPTR_FORMAT "] = %d", 2386 oops_begin(), 2387 oops_end(), 2388 oops_size()); 2389} 2390 2391void nmethod::print_code() { 2392 HandleMark hm; 2393 ResourceMark m; 2394 Disassembler::decode(this); 2395} 2396 2397 2398#ifndef PRODUCT 2399 2400void nmethod::print_scopes() { 2401 // Find the first pc desc for all scopes in the code and print it. 2402 ResourceMark rm; 2403 for (PcDesc* p = scopes_pcs_begin(); p < scopes_pcs_end(); p++) { 2404 if (p->scope_decode_offset() == DebugInformationRecorder::serialized_null) 2405 continue; 2406 2407 ScopeDesc* sd = scope_desc_at(p->real_pc(this)); 2408 sd->print_on(tty, p); 2409 } 2410} 2411 2412void nmethod::print_dependencies() { 2413 ResourceMark rm; 2414 ttyLocker ttyl; // keep the following output all in one block 2415 tty->print_cr("Dependencies:"); 2416 for (Dependencies::DepStream deps(this); deps.next(); ) { 2417 deps.print_dependency(); 2418 klassOop ctxk = deps.context_type(); 2419 if (ctxk != NULL) { 2420 Klass* k = Klass::cast(ctxk); 2421 if (k->oop_is_instance() && ((instanceKlass*)k)->is_dependent_nmethod(this)) { 2422 tty->print_cr(" [nmethod<=klass]%s", k->external_name()); 2423 } 2424 } 2425 deps.log_dependency(); // put it into the xml log also 2426 } 2427} 2428 2429 2430void nmethod::print_relocations() { 2431 ResourceMark m; // in case methods get printed via the debugger 2432 tty->print_cr("relocations:"); 2433 RelocIterator iter(this); 2434 iter.print(); 2435 if (UseRelocIndex) { 2436 jint* index_end = (jint*)relocation_end() - 1; 2437 jint index_size = *index_end; 2438 jint* index_start = (jint*)( (address)index_end - index_size ); 2439 tty->print_cr(" index @" INTPTR_FORMAT ": index_size=%d", index_start, index_size); 2440 if (index_size > 0) { 2441 jint* ip; 2442 for (ip = index_start; ip+2 <= index_end; ip += 2) 2443 tty->print_cr(" (%d %d) addr=" INTPTR_FORMAT " @" INTPTR_FORMAT, 2444 ip[0], 2445 ip[1], 2446 header_end()+ip[0], 2447 relocation_begin()-1+ip[1]); 2448 for (; ip < index_end; ip++) 2449 tty->print_cr(" (%d ?)", ip[0]); 2450 tty->print_cr(" @" INTPTR_FORMAT ": index_size=%d", ip, *ip++); 2451 tty->print_cr("reloc_end @" INTPTR_FORMAT ":", ip); 2452 } 2453 } 2454} 2455 2456 2457void nmethod::print_pcs() { 2458 ResourceMark m; // in case methods get printed via debugger 2459 tty->print_cr("pc-bytecode offsets:"); 2460 for (PcDesc* p = scopes_pcs_begin(); p < scopes_pcs_end(); p++) { 2461 p->print(this); 2462 } 2463} 2464 2465#endif // PRODUCT 2466 2467const char* nmethod::reloc_string_for(u_char* begin, u_char* end) { 2468 RelocIterator iter(this, begin, end); 2469 bool have_one = false; 2470 while (iter.next()) { 2471 have_one = true; 2472 switch (iter.type()) { 2473 case relocInfo::none: return "no_reloc"; 2474 case relocInfo::oop_type: { 2475 stringStream st; 2476 oop_Relocation* r = iter.oop_reloc(); 2477 oop obj = r->oop_value(); 2478 st.print("oop("); 2479 if (obj == NULL) st.print("NULL"); 2480 else obj->print_value_on(&st); 2481 st.print(")"); 2482 return st.as_string(); 2483 } 2484 case relocInfo::virtual_call_type: return "virtual_call"; 2485 case relocInfo::opt_virtual_call_type: return "optimized virtual_call"; 2486 case relocInfo::static_call_type: return "static_call"; 2487 case relocInfo::static_stub_type: return "static_stub"; 2488 case relocInfo::runtime_call_type: return "runtime_call"; 2489 case relocInfo::external_word_type: return "external_word"; 2490 case relocInfo::internal_word_type: return "internal_word"; 2491 case relocInfo::section_word_type: return "section_word"; 2492 case relocInfo::poll_type: return "poll"; 2493 case relocInfo::poll_return_type: return "poll_return"; 2494 case relocInfo::type_mask: return "type_bit_mask"; 2495 } 2496 } 2497 return have_one ? "other" : NULL; 2498} 2499 2500// Return a the last scope in (begin..end] 2501ScopeDesc* nmethod::scope_desc_in(address begin, address end) { 2502 PcDesc* p = pc_desc_near(begin+1); 2503 if (p != NULL && p->real_pc(this) <= end) { 2504 return new ScopeDesc(this, p->scope_decode_offset(), 2505 p->obj_decode_offset(), p->should_reexecute(), 2506 p->return_oop()); 2507 } 2508 return NULL; 2509} 2510 2511void nmethod::print_nmethod_labels(outputStream* stream, address block_begin) { 2512 if (block_begin == entry_point()) stream->print_cr("[Entry Point]"); 2513 if (block_begin == verified_entry_point()) stream->print_cr("[Verified Entry Point]"); 2514 if (block_begin == exception_begin()) stream->print_cr("[Exception Handler]"); 2515 if (block_begin == stub_begin()) stream->print_cr("[Stub Code]"); 2516 if (block_begin == deopt_handler_begin()) stream->print_cr("[Deopt Handler Code]"); 2517 if (block_begin == deopt_mh_handler_begin()) stream->print_cr("[Deopt MH Handler Code]"); 2518 if (block_begin == consts_begin()) stream->print_cr("[Constants]"); 2519 if (block_begin == entry_point()) { 2520 methodHandle m = method(); 2521 if (m.not_null()) { 2522 stream->print(" # "); 2523 m->print_value_on(stream); 2524 stream->cr(); 2525 } 2526 if (m.not_null() && !is_osr_method()) { 2527 ResourceMark rm; 2528 int sizeargs = m->size_of_parameters(); 2529 BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, sizeargs); 2530 VMRegPair* regs = NEW_RESOURCE_ARRAY(VMRegPair, sizeargs); 2531 { 2532 int sig_index = 0; 2533 if (!m->is_static()) 2534 sig_bt[sig_index++] = T_OBJECT; // 'this' 2535 for (SignatureStream ss(m->signature()); !ss.at_return_type(); ss.next()) { 2536 BasicType t = ss.type(); 2537 sig_bt[sig_index++] = t; 2538 if (type2size[t] == 2) { 2539 sig_bt[sig_index++] = T_VOID; 2540 } else { 2541 assert(type2size[t] == 1, "size is 1 or 2"); 2542 } 2543 } 2544 assert(sig_index == sizeargs, ""); 2545 } 2546 const char* spname = "sp"; // make arch-specific? 2547 intptr_t out_preserve = SharedRuntime::java_calling_convention(sig_bt, regs, sizeargs, false); 2548 int stack_slot_offset = this->frame_size() * wordSize; 2549 int tab1 = 14, tab2 = 24; 2550 int sig_index = 0; 2551 int arg_index = (m->is_static() ? 0 : -1); 2552 bool did_old_sp = false; 2553 for (SignatureStream ss(m->signature()); !ss.at_return_type(); ) { 2554 bool at_this = (arg_index == -1); 2555 bool at_old_sp = false; 2556 BasicType t = (at_this ? T_OBJECT : ss.type()); 2557 assert(t == sig_bt[sig_index], "sigs in sync"); 2558 if (at_this) 2559 stream->print(" # this: "); 2560 else 2561 stream->print(" # parm%d: ", arg_index); 2562 stream->move_to(tab1); 2563 VMReg fst = regs[sig_index].first(); 2564 VMReg snd = regs[sig_index].second(); 2565 if (fst->is_reg()) { 2566 stream->print("%s", fst->name()); 2567 if (snd->is_valid()) { 2568 stream->print(":%s", snd->name()); 2569 } 2570 } else if (fst->is_stack()) { 2571 int offset = fst->reg2stack() * VMRegImpl::stack_slot_size + stack_slot_offset; 2572 if (offset == stack_slot_offset) at_old_sp = true; 2573 stream->print("[%s+0x%x]", spname, offset); 2574 } else { 2575 stream->print("reg%d:%d??", (int)(intptr_t)fst, (int)(intptr_t)snd); 2576 } 2577 stream->print(" "); 2578 stream->move_to(tab2); 2579 stream->print("= "); 2580 if (at_this) { 2581 m->method_holder()->print_value_on(stream); 2582 } else { 2583 bool did_name = false; 2584 if (!at_this && ss.is_object()) { 2585 symbolOop name = ss.as_symbol_or_null(); 2586 if (name != NULL) { 2587 name->print_value_on(stream); 2588 did_name = true; 2589 } 2590 } 2591 if (!did_name) 2592 stream->print("%s", type2name(t)); 2593 } 2594 if (at_old_sp) { 2595 stream->print(" (%s of caller)", spname); 2596 did_old_sp = true; 2597 } 2598 stream->cr(); 2599 sig_index += type2size[t]; 2600 arg_index += 1; 2601 if (!at_this) ss.next(); 2602 } 2603 if (!did_old_sp) { 2604 stream->print(" # "); 2605 stream->move_to(tab1); 2606 stream->print("[%s+0x%x]", spname, stack_slot_offset); 2607 stream->print(" (%s of caller)", spname); 2608 stream->cr(); 2609 } 2610 } 2611 } 2612} 2613 2614void nmethod::print_code_comment_on(outputStream* st, int column, u_char* begin, u_char* end) { 2615 // First, find an oopmap in (begin, end]. 2616 // We use the odd half-closed interval so that oop maps and scope descs 2617 // which are tied to the byte after a call are printed with the call itself. 2618 address base = instructions_begin(); 2619 OopMapSet* oms = oop_maps(); 2620 if (oms != NULL) { 2621 for (int i = 0, imax = oms->size(); i < imax; i++) { 2622 OopMap* om = oms->at(i); 2623 address pc = base + om->offset(); 2624 if (pc > begin) { 2625 if (pc <= end) { 2626 st->move_to(column); 2627 st->print("; "); 2628 om->print_on(st); 2629 } 2630 break; 2631 } 2632 } 2633 } 2634 2635 // Print any debug info present at this pc. 2636 ScopeDesc* sd = scope_desc_in(begin, end); 2637 if (sd != NULL) { 2638 st->move_to(column); 2639 if (sd->bci() == SynchronizationEntryBCI) { 2640 st->print(";*synchronization entry"); 2641 } else { 2642 if (sd->method().is_null()) { 2643 st->print("method is NULL"); 2644 } else if (sd->method()->is_native()) { 2645 st->print("method is native"); 2646 } else { 2647 address bcp = sd->method()->bcp_from(sd->bci()); 2648 Bytecodes::Code bc = Bytecodes::java_code_at(bcp); 2649 st->print(";*%s", Bytecodes::name(bc)); 2650 switch (bc) { 2651 case Bytecodes::_invokevirtual: 2652 case Bytecodes::_invokespecial: 2653 case Bytecodes::_invokestatic: 2654 case Bytecodes::_invokeinterface: 2655 { 2656 Bytecode_invoke* invoke = Bytecode_invoke_at(sd->method(), sd->bci()); 2657 st->print(" "); 2658 if (invoke->name() != NULL) 2659 invoke->name()->print_symbol_on(st); 2660 else 2661 st->print("<UNKNOWN>"); 2662 break; 2663 } 2664 case Bytecodes::_getfield: 2665 case Bytecodes::_putfield: 2666 case Bytecodes::_getstatic: 2667 case Bytecodes::_putstatic: 2668 { 2669 methodHandle sdm = sd->method(); 2670 Bytecode_field* field = Bytecode_field_at(sdm(), sdm->bcp_from(sd->bci())); 2671 constantPoolOop sdmc = sdm->constants(); 2672 symbolOop name = sdmc->name_ref_at(field->index()); 2673 st->print(" "); 2674 if (name != NULL) 2675 name->print_symbol_on(st); 2676 else 2677 st->print("<UNKNOWN>"); 2678 } 2679 } 2680 } 2681 } 2682 2683 // Print all scopes 2684 for (;sd != NULL; sd = sd->sender()) { 2685 st->move_to(column); 2686 st->print("; -"); 2687 if (sd->method().is_null()) { 2688 st->print("method is NULL"); 2689 } else { 2690 sd->method()->print_short_name(st); 2691 } 2692 int lineno = sd->method()->line_number_from_bci(sd->bci()); 2693 if (lineno != -1) { 2694 st->print("@%d (line %d)", sd->bci(), lineno); 2695 } else { 2696 st->print("@%d", sd->bci()); 2697 } 2698 st->cr(); 2699 } 2700 } 2701 2702 // Print relocation information 2703 const char* str = reloc_string_for(begin, end); 2704 if (str != NULL) { 2705 if (sd != NULL) st->cr(); 2706 st->move_to(column); 2707 st->print("; {%s}", str); 2708 } 2709 int cont_offset = ImplicitExceptionTable(this).at(begin - instructions_begin()); 2710 if (cont_offset != 0) { 2711 st->move_to(column); 2712 st->print("; implicit exception: dispatches to " INTPTR_FORMAT, instructions_begin() + cont_offset); 2713 } 2714 2715} 2716 2717#ifndef PRODUCT 2718 2719void nmethod::print_value_on(outputStream* st) const { 2720 print_on(st, "nmethod"); 2721} 2722 2723void nmethod::print_calls(outputStream* st) { 2724 RelocIterator iter(this); 2725 while (iter.next()) { 2726 switch (iter.type()) { 2727 case relocInfo::virtual_call_type: 2728 case relocInfo::opt_virtual_call_type: { 2729 VerifyMutexLocker mc(CompiledIC_lock); 2730 CompiledIC_at(iter.reloc())->print(); 2731 break; 2732 } 2733 case relocInfo::static_call_type: 2734 st->print_cr("Static call at " INTPTR_FORMAT, iter.reloc()->addr()); 2735 compiledStaticCall_at(iter.reloc())->print(); 2736 break; 2737 } 2738 } 2739} 2740 2741void nmethod::print_handler_table() { 2742 ExceptionHandlerTable(this).print(); 2743} 2744 2745void nmethod::print_nul_chk_table() { 2746 ImplicitExceptionTable(this).print(instructions_begin()); 2747} 2748 2749void nmethod::print_statistics() { 2750 ttyLocker ttyl; 2751 if (xtty != NULL) xtty->head("statistics type='nmethod'"); 2752 nmethod_stats.print_native_nmethod_stats(); 2753 nmethod_stats.print_nmethod_stats(); 2754 DebugInformationRecorder::print_statistics(); 2755 nmethod_stats.print_pc_stats(); 2756 Dependencies::print_statistics(); 2757 if (xtty != NULL) xtty->tail("statistics"); 2758} 2759 2760#endif // PRODUCT 2761