< prev index next >
src/share/vm/code/nmethod.cpp
Print this page
@@ -24,10 +24,11 @@
#include "precompiled.hpp"
#include "code/codeCache.hpp"
#include "code/compiledIC.hpp"
#include "code/dependencies.hpp"
+#include "code/nativeInst.hpp"
#include "code/nmethod.hpp"
#include "code/scopeDesc.hpp"
#include "compiler/abstractCompiler.hpp"
#include "compiler/compileBroker.hpp"
#include "compiler/compileLog.hpp"
@@ -44,13 +45,31 @@
#include "runtime/sweeper.hpp"
#include "utilities/resourceHash.hpp"
#include "utilities/dtrace.hpp"
#include "utilities/events.hpp"
#include "utilities/xmlstream.hpp"
+#ifdef TARGET_ARCH_x86
+# include "nativeInst_x86.hpp"
+#endif
+#ifdef TARGET_ARCH_sparc
+# include "nativeInst_sparc.hpp"
+#endif
+#ifdef TARGET_ARCH_zero
+# include "nativeInst_zero.hpp"
+#endif
+#ifdef TARGET_ARCH_arm
+# include "nativeInst_arm.hpp"
+#endif
+#ifdef TARGET_ARCH_ppc
+# include "nativeInst_ppc.hpp"
+#endif
#ifdef SHARK
#include "shark/sharkCompiler.hpp"
#endif
+#if INCLUDE_JVMCI
+#include "jvmci/jvmciJavaClasses.hpp"
+#endif
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
unsigned char nmethod::_global_unloading_clock = 0;
@@ -82,10 +101,15 @@
if (compiler() == NULL) {
return false;
}
return compiler()->is_c1();
}
+bool nmethod::is_compiled_by_jvmci() const {
+ if (compiler() == NULL || method() == NULL) return false; // can happen during debug printing
+ if (is_native_method()) return false;
+ return compiler()->is_jvmci();
+}
bool nmethod::is_compiled_by_c2() const {
if (compiler() == NULL) {
return false;
}
return compiler()->is_c2();
@@ -106,12 +130,11 @@
// (In the latter two cases, they like other stats are printed to the log only.)
#ifndef PRODUCT
// These variables are put into one block to reduce relocations
// and make it simpler to print from the debugger.
-static
-struct nmethod_stats_struct {
+struct java_nmethod_stats_struct {
int nmethod_count;
int total_size;
int relocation_size;
int consts_size;
int insts_size;
@@ -120,62 +143,73 @@
int scopes_pcs_size;
int dependencies_size;
int handler_table_size;
int nul_chk_table_size;
int oops_size;
+ int metadata_size;
void note_nmethod(nmethod* nm) {
nmethod_count += 1;
total_size += nm->size();
relocation_size += nm->relocation_size();
consts_size += nm->consts_size();
insts_size += nm->insts_size();
stub_size += nm->stub_size();
oops_size += nm->oops_size();
+ metadata_size += nm->metadata_size();
scopes_data_size += nm->scopes_data_size();
scopes_pcs_size += nm->scopes_pcs_size();
dependencies_size += nm->dependencies_size();
handler_table_size += nm->handler_table_size();
nul_chk_table_size += nm->nul_chk_table_size();
}
- void print_nmethod_stats() {
+ void print_nmethod_stats(const char* name) {
if (nmethod_count == 0) return;
- tty->print_cr("Statistics for %d bytecoded nmethods:", nmethod_count);
+ tty->print_cr("Statistics for %d bytecoded nmethods for %s:", nmethod_count, name);
if (total_size != 0) tty->print_cr(" total in heap = %d", total_size);
+ if (nmethod_count != 0) tty->print_cr(" header = %d", nmethod_count * sizeof(nmethod));
if (relocation_size != 0) tty->print_cr(" relocation = %d", relocation_size);
if (consts_size != 0) tty->print_cr(" constants = %d", consts_size);
if (insts_size != 0) tty->print_cr(" main code = %d", insts_size);
if (stub_size != 0) tty->print_cr(" stub code = %d", stub_size);
if (oops_size != 0) tty->print_cr(" oops = %d", oops_size);
+ if (metadata_size != 0) tty->print_cr(" metadata = %d", metadata_size);
if (scopes_data_size != 0) tty->print_cr(" scopes data = %d", scopes_data_size);
if (scopes_pcs_size != 0) tty->print_cr(" scopes pcs = %d", scopes_pcs_size);
if (dependencies_size != 0) tty->print_cr(" dependencies = %d", dependencies_size);
if (handler_table_size != 0) tty->print_cr(" handler table = %d", handler_table_size);
if (nul_chk_table_size != 0) tty->print_cr(" nul chk table = %d", nul_chk_table_size);
}
+};
+struct native_nmethod_stats_struct {
int native_nmethod_count;
int native_total_size;
int native_relocation_size;
int native_insts_size;
int native_oops_size;
+ int native_metadata_size;
void note_native_nmethod(nmethod* nm) {
native_nmethod_count += 1;
native_total_size += nm->size();
native_relocation_size += nm->relocation_size();
native_insts_size += nm->insts_size();
native_oops_size += nm->oops_size();
+ native_metadata_size += nm->metadata_size();
}
void print_native_nmethod_stats() {
if (native_nmethod_count == 0) return;
tty->print_cr("Statistics for %d native nmethods:", native_nmethod_count);
if (native_total_size != 0) tty->print_cr(" N. total size = %d", native_total_size);
if (native_relocation_size != 0) tty->print_cr(" N. relocation = %d", native_relocation_size);
if (native_insts_size != 0) tty->print_cr(" N. main code = %d", native_insts_size);
if (native_oops_size != 0) tty->print_cr(" N. oops = %d", native_oops_size);
+ if (native_metadata_size != 0) tty->print_cr(" N. metadata = %d", native_metadata_size);
}
+};
+struct pc_nmethod_stats_struct {
int pc_desc_resets; // number of resets (= number of caches)
int pc_desc_queries; // queries to nmethod::find_pc_desc
int pc_desc_approx; // number of those which have approximate true
int pc_desc_repeats; // number of _pc_descs[0] hits
int pc_desc_hits; // number of LRU cache hits
@@ -192,13 +226,55 @@
pc_desc_resets,
pc_desc_queries, pc_desc_approx,
pc_desc_repeats, pc_desc_hits,
pc_desc_tests, pc_desc_searches, pc_desc_adds);
}
-} nmethod_stats;
-#endif //PRODUCT
+};
+#ifdef COMPILER1
+static java_nmethod_stats_struct c1_java_nmethod_stats;
+#endif
+#ifdef COMPILER2
+static java_nmethod_stats_struct c2_java_nmethod_stats;
+#endif
+#if INCLUDE_JVMCI
+static java_nmethod_stats_struct jvmci_java_nmethod_stats;
+#endif
+#ifdef SHARK
+static java_nmethod_stats_struct shark_java_nmethod_stats;
+#endif
+static java_nmethod_stats_struct unknown_java_nmethod_stats;
+
+static native_nmethod_stats_struct native_nmethod_stats;
+static pc_nmethod_stats_struct pc_nmethod_stats;
+
+static void note_java_nmethod(nmethod* nm) {
+#ifdef COMPILER1
+ if (nm->is_compiled_by_c1()) {
+ c1_java_nmethod_stats.note_nmethod(nm);
+ } else
+#endif
+#ifdef COMPILER2
+ if (nm->is_compiled_by_c2()) {
+ c2_java_nmethod_stats.note_nmethod(nm);
+ } else
+#endif
+#if INCLUDE_JVMCI
+ if (nm->is_compiled_by_jvmci()) {
+ jvmci_java_nmethod_stats.note_nmethod(nm);
+ } else
+#endif
+#ifdef SHARK
+ if (nm->is_compiled_by_shark()) {
+ shark_java_nmethod_stats.note_nmethod(nm);
+ } else
+#endif
+ {
+ unknown_java_nmethod_stats.note_nmethod(nm);
+ }
+}
+#endif // !PRODUCT
//---------------------------------------------------------------------------------
ExceptionCache::ExceptionCache(Handle exception, address pc, address handler) {
@@ -274,11 +350,11 @@
//-----------------------------------------------------------------------------
// Helper used by both find_pc_desc methods.
static inline bool match_desc(PcDesc* pc, int pc_offset, bool approximate) {
- NOT_PRODUCT(++nmethod_stats.pc_desc_tests);
+ NOT_PRODUCT(++pc_nmethod_stats.pc_desc_tests);
if (!approximate)
return pc->pc_offset() == pc_offset;
else
return (pc-1)->pc_offset() < pc_offset && pc_offset <= pc->pc_offset();
}
@@ -286,20 +362,20 @@
void PcDescCache::reset_to(PcDesc* initial_pc_desc) {
if (initial_pc_desc == NULL) {
_pc_descs[0] = NULL; // native method; no PcDescs at all
return;
}
- NOT_PRODUCT(++nmethod_stats.pc_desc_resets);
+ NOT_PRODUCT(++pc_nmethod_stats.pc_desc_resets);
// reset the cache by filling it with benign (non-null) values
assert(initial_pc_desc->pc_offset() < 0, "must be sentinel");
for (int i = 0; i < cache_size; i++)
_pc_descs[i] = initial_pc_desc;
}
PcDesc* PcDescCache::find_pc_desc(int pc_offset, bool approximate) {
- NOT_PRODUCT(++nmethod_stats.pc_desc_queries);
- NOT_PRODUCT(if (approximate) ++nmethod_stats.pc_desc_approx);
+ NOT_PRODUCT(++pc_nmethod_stats.pc_desc_queries);
+ NOT_PRODUCT(if (approximate) ++pc_nmethod_stats.pc_desc_approx);
// Note: one might think that caching the most recently
// read value separately would be a win, but one would be
// wrong. When many threads are updating it, the cache
// line it's in would bounce between caches, negating
@@ -311,30 +387,30 @@
// Step one: Check the most recently added value.
res = _pc_descs[0];
if (res == NULL) return NULL; // native method; no PcDescs at all
if (match_desc(res, pc_offset, approximate)) {
- NOT_PRODUCT(++nmethod_stats.pc_desc_repeats);
+ NOT_PRODUCT(++pc_nmethod_stats.pc_desc_repeats);
return res;
}
// Step two: Check the rest of the LRU cache.
for (int i = 1; i < cache_size; ++i) {
res = _pc_descs[i];
if (res->pc_offset() < 0) break; // optimization: skip empty cache
if (match_desc(res, pc_offset, approximate)) {
- NOT_PRODUCT(++nmethod_stats.pc_desc_hits);
+ NOT_PRODUCT(++pc_nmethod_stats.pc_desc_hits);
return res;
}
}
// Report failure.
return NULL;
}
void PcDescCache::add_pc_desc(PcDesc* pc_desc) {
- NOT_PRODUCT(++nmethod_stats.pc_desc_adds);
+ NOT_PRODUCT(++pc_nmethod_stats.pc_desc_adds);
// Update the LRU cache by shifting pc_desc forward.
for (int i = 0; i < cache_size; i++) {
PcDesc* next = _pc_descs[i];
_pc_descs[i] = pc_desc;
pc_desc = next;
@@ -476,10 +552,14 @@
_scavenge_root_state = 0;
_compiler = NULL;
#if INCLUDE_RTM_OPT
_rtm_state = NoRTM;
#endif
+#if INCLUDE_JVMCI
+ _jvmci_installed_code = NULL;
+ _speculation_log = NULL;
+#endif
}
nmethod* nmethod::new_native_nmethod(methodHandle method,
int compile_id,
CodeBuffer *code_buffer,
@@ -501,11 +581,11 @@
nm = new (native_nmethod_size, CompLevel_none) nmethod(method(), native_nmethod_size,
compile_id, &offsets,
code_buffer, frame_size,
basic_lock_owner_sp_offset,
basic_lock_sp_offset, oop_maps);
- NOT_PRODUCT(if (nm != NULL) nmethod_stats.note_native_nmethod(nm));
+ NOT_PRODUCT(if (nm != NULL) native_nmethod_stats.note_native_nmethod(nm));
if ((PrintAssembly || CompilerOracle::should_print(method)) && nm != NULL) {
Disassembler::decode(nm);
}
}
// verify nmethod
@@ -529,10 +609,14 @@
OopMapSet* oop_maps,
ExceptionHandlerTable* handler_table,
ImplicitExceptionTable* nul_chk_table,
AbstractCompiler* compiler,
int comp_level
+#if INCLUDE_JVMCI
+ , Handle installed_code,
+ Handle speculationLog
+#endif
)
{
assert(debug_info->oop_recorder() == code_buffer->oop_recorder(), "shared OR");
code_buffer->finalize_oop_references(method);
// create nmethod
@@ -551,11 +635,16 @@
orig_pc_offset, debug_info, dependencies, code_buffer, frame_size,
oop_maps,
handler_table,
nul_chk_table,
compiler,
- comp_level);
+ comp_level
+#if INCLUDE_JVMCI
+ , installed_code,
+ speculationLog
+#endif
+ );
if (nm != NULL) {
// To make dependency checking during class loading fast, record
// the nmethod dependencies in the classes it is dependent on.
// This allows the dependency checking code to simply walk the
@@ -576,11 +665,11 @@
}
// record this nmethod as dependent on this klass
InstanceKlass::cast(klass)->add_dependent_nmethod(nm);
}
}
- NOT_PRODUCT(nmethod_stats.note_nmethod(nm));
+ NOT_PRODUCT(if (nm != NULL) note_java_nmethod(nm));
if (PrintAssembly || CompilerOracle::has_option_string(method, "PrintAssembly")) {
Disassembler::decode(nm);
}
}
}
@@ -591,11 +680,14 @@
nm->log_new_nmethod();
}
return nm;
}
-
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4355) // warning C4355: 'this' : used in base member initializer list
+#endif
// For native wrappers
nmethod::nmethod(
Method* method,
int nmethod_size,
int compile_id,
@@ -681,10 +773,14 @@
xtty->tail("print_native_nmethod");
}
}
}
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
void* nmethod::operator new(size_t size, int nmethod_size, int comp_level) throw () {
return CodeCache::allocate(nmethod_size, CodeCache::get_code_blob_type(comp_level));
}
nmethod::nmethod(
@@ -701,10 +797,14 @@
OopMapSet* oop_maps,
ExceptionHandlerTable* handler_table,
ImplicitExceptionTable* nul_chk_table,
AbstractCompiler* compiler,
int comp_level
+#if INCLUDE_JVMCI
+ , Handle installed_code,
+ Handle speculation_log
+#endif
)
: CodeBlob("nmethod", code_buffer, sizeof(nmethod),
nmethod_size, offsets->value(CodeOffsets::Frame_Complete), frame_size, oop_maps),
_native_receiver_sp_offset(in_ByteSize(-1)),
_native_basic_lock_sp_offset(in_ByteSize(-1))
@@ -725,19 +825,46 @@
// Section offsets
_consts_offset = content_offset() + code_buffer->total_offset_of(code_buffer->consts());
_stub_offset = content_offset() + code_buffer->total_offset_of(code_buffer->stubs());
+#if INCLUDE_JVMCI
+ _jvmci_installed_code = installed_code();
+ _speculation_log = (instanceOop)speculation_log();
+
+ if (compiler->is_jvmci()) {
+ // JVMCI might not produce any stub sections
+ if (offsets->value(CodeOffsets::Exceptions) != -1) {
+ _exception_offset = code_offset() + offsets->value(CodeOffsets::Exceptions);
+ } else {
+ _exception_offset = -1;
+ }
+ if (offsets->value(CodeOffsets::Deopt) != -1) {
+ _deoptimize_offset = code_offset() + offsets->value(CodeOffsets::Deopt);
+ } else {
+ _deoptimize_offset = -1;
+ }
+ if (offsets->value(CodeOffsets::DeoptMH) != -1) {
+ _deoptimize_mh_offset = code_offset() + offsets->value(CodeOffsets::DeoptMH);
+ } else {
+ _deoptimize_mh_offset = -1;
+ }
+ } else {
+#endif
// Exception handler and deopt handler are in the stub section
assert(offsets->value(CodeOffsets::Exceptions) != -1, "must be set");
assert(offsets->value(CodeOffsets::Deopt ) != -1, "must be set");
+
_exception_offset = _stub_offset + offsets->value(CodeOffsets::Exceptions);
_deoptimize_offset = _stub_offset + offsets->value(CodeOffsets::Deopt);
if (offsets->value(CodeOffsets::DeoptMH) != -1) {
_deoptimize_mh_offset = _stub_offset + offsets->value(CodeOffsets::DeoptMH);
} else {
_deoptimize_mh_offset = -1;
+#if INCLUDE_JVMCI
+ }
+#endif
}
if (offsets->value(CodeOffsets::UnwindHandler) != -1) {
_unwind_handler_offset = code_offset() + offsets->value(CodeOffsets::UnwindHandler);
} else {
_unwind_handler_offset = -1;
@@ -777,24 +904,23 @@
handler_table->copy_to(this);
nul_chk_table->copy_to(this);
// we use the information of entry points to find out if a method is
// static or non static
- assert(compiler->is_c2() ||
+ assert(compiler->is_c2() || compiler->is_jvmci() ||
_method->is_static() == (entry_point() == _verified_entry_point),
" entry points must be same for static methods and vice versa");
}
- bool printnmethods = PrintNMethods
+ bool printnmethods = PrintNMethods || PrintNMethodsAtLevel == _comp_level
|| CompilerOracle::should_print(_method)
|| CompilerOracle::has_option_string(_method, "PrintNMethods");
if (printnmethods || PrintDebugInfo || PrintRelocations || PrintDependencies || PrintExceptionHandlers) {
print_nmethod(printnmethods);
}
}
-
// Print a short set of xml attributes to identify this nmethod. The
// output should be embedded in some other element.
void nmethod::log_identity(xmlStream* log) const {
log->print(" compile_id='%d'", compile_id());
const char* nm_kind = compile_kind();
@@ -831,10 +957,11 @@
LOG_OFFSET(xtty, scopes_pcs);
LOG_OFFSET(xtty, dependencies);
LOG_OFFSET(xtty, handler_table);
LOG_OFFSET(xtty, nul_chk_table);
LOG_OFFSET(xtty, oops);
+ LOG_OFFSET(xtty, metadata);
xtty->method(method());
xtty->stamp();
xtty->end_elem();
}
@@ -872,17 +999,17 @@
print_pcs();
if (oop_maps()) {
oop_maps()->print();
}
}
- if (PrintDebugInfo) {
+ if (PrintDebugInfo || CompilerOracle::has_option_string(_method, "PrintDebugInfo")) {
print_scopes();
}
- if (PrintRelocations) {
+ if (PrintRelocations || CompilerOracle::has_option_string(_method, "PrintRelocations")) {
print_relocations();
}
- if (PrintDependencies) {
+ if (PrintDependencies || CompilerOracle::has_option_string(_method, "PrintDependencies")) {
print_dependencies();
}
if (PrintExceptionHandlers) {
print_handler_table();
print_nul_chk_table();
@@ -988,11 +1115,11 @@
ScopeDesc* nmethod::scope_desc_at(address pc) {
PcDesc* pd = pc_desc_at(pc);
guarantee(pd != NULL, "scope must be present");
return new ScopeDesc(this, pd->scope_decode_offset(),
- pd->obj_decode_offset(), pd->should_reexecute(),
+ pd->obj_decode_offset(), pd->should_reexecute(), pd->rethrow_exception(),
pd->return_oop());
}
void nmethod::clear_inline_caches() {
@@ -1159,11 +1286,11 @@
return stack_traversal_mark()+1 < NMethodSweeper::traversal_count() &&
!is_locked_by_vm();
}
void nmethod::inc_decompile_count() {
- if (!is_compiled_by_c2()) return;
+ if (!is_compiled_by_c2() && !is_compiled_by_jvmci()) return;
// Could be gated by ProfileTraps, but do not bother...
Method* m = method();
if (m == NULL) return;
MethodData* mdo = m->method_data();
if (mdo == NULL) return;
@@ -1223,10 +1350,11 @@
if (_method->code() == this) {
_method->clear_code(); // Break a cycle
}
_method = NULL; // Clear the method of this dead nmethod
}
+
// Make the class unloaded - i.e., change state and notify sweeper
assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
if (is_in_use()) {
// Transitioning directly from live to unloaded -- so
// we need to force a cache clean-up; remember this
@@ -1235,10 +1363,22 @@
}
// Unregister must be done before the state change
Universe::heap()->unregister_nmethod(this);
+#if INCLUDE_JVMCI
+ // The method can only be unloaded after the pointer to the installed code
+ // Java wrapper is no longer alive. Here we need to clear out this weak
+ // reference to the dead object. Nulling out the reference has to happen
+ // after the method is unregistered since the original value may be still
+ // tracked by the rset.
+ if (_jvmci_installed_code != NULL) {
+ InstalledCode::set_address(_jvmci_installed_code, 0);
+ _jvmci_installed_code = NULL;
+ }
+#endif
+
_state = unloaded;
// Log the unloading.
log_state_change();
@@ -1398,13 +1538,20 @@
// nmethod is in zombie state
set_method(NULL);
} else {
assert(state == not_entrant, "other cases may need to be handled differently");
}
+#if INCLUDE_JVMCI
+ if (_jvmci_installed_code != NULL) {
+ // Break the link between nmethod and InstalledCode such that the nmethod can subsequently be flushed safely.
+ InstalledCode::set_address(_jvmci_installed_code, 0);
+ }
+#endif
if (TraceCreateZombies) {
- tty->print_cr("nmethod <" INTPTR_FORMAT "> code made %s", this, (state == not_entrant) ? "not entrant" : "zombie");
+ ResourceMark m;
+ tty->print_cr("nmethod <" INTPTR_FORMAT "> %s code made %s", this, this->method() ? this->method()->name_and_sig_as_C_string() : "null", (state == not_entrant) ? "not entrant" : "zombie");
}
NMethodSweeper::report_state_change(this);
return true;
}
@@ -1688,10 +1835,37 @@
if (can_unload(is_alive, p, unloading_occurred)) {
return;
}
}
+#if INCLUDE_JVMCI
+ // Follow JVMCI method
+ BarrierSet* bs = Universe::heap()->barrier_set();
+ if (_jvmci_installed_code != NULL) {
+ if (_jvmci_installed_code->is_a(HotSpotNmethod::klass()) && HotSpotNmethod::isDefault(_jvmci_installed_code)) {
+ if (!is_alive->do_object_b(_jvmci_installed_code)) {
+ bs->write_ref_nmethod_pre(&_jvmci_installed_code, this);
+ _jvmci_installed_code = NULL;
+ bs->write_ref_nmethod_post(&_jvmci_installed_code, this);
+ }
+ } else {
+ if (can_unload(is_alive, (oop*)&_jvmci_installed_code, unloading_occurred)) {
+ return;
+ }
+ }
+ }
+
+ if (_speculation_log != NULL) {
+ if (!is_alive->do_object_b(_speculation_log)) {
+ bs->write_ref_nmethod_pre(&_speculation_log, this);
+ _speculation_log = NULL;
+ bs->write_ref_nmethod_post(&_speculation_log, this);
+ }
+ }
+#endif
+
+
// Ensure that all metadata is still alive
verify_metadata_loaders(low_boundary, is_alive);
}
template <class CompiledICorStaticCall>
@@ -1770,10 +1944,31 @@
// call to post_compiled_method_unload() so that the unloading
// of this nmethod is reported.
unloading_occurred = true;
}
+#if INCLUDE_JVMCI
+ // Follow JVMCI method
+ if (_jvmci_installed_code != NULL) {
+ if (_jvmci_installed_code->is_a(HotSpotNmethod::klass()) && HotSpotNmethod::isDefault(_jvmci_installed_code)) {
+ if (!is_alive->do_object_b(_jvmci_installed_code)) {
+ _jvmci_installed_code = NULL;
+ }
+ } else {
+ if (can_unload(is_alive, (oop*)&_jvmci_installed_code, unloading_occurred)) {
+ return false;
+ }
+ }
+ }
+
+ if (_speculation_log != NULL) {
+ if (!is_alive->do_object_b(_speculation_log)) {
+ _speculation_log = NULL;
+ }
+ }
+#endif
+
// Exception cache
clean_exception_cache(is_alive);
bool is_unloaded = false;
bool postponed = false;
@@ -1827,10 +2022,36 @@
if (is_unloaded) {
return postponed;
}
+#if INCLUDE_JVMCI
+ // Follow JVMCI method
+ BarrierSet* bs = Universe::heap()->barrier_set();
+ if (_jvmci_installed_code != NULL) {
+ if (_jvmci_installed_code->is_a(HotSpotNmethod::klass()) && HotSpotNmethod::isDefault(_jvmci_installed_code)) {
+ if (!is_alive->do_object_b(_jvmci_installed_code)) {
+ bs->write_ref_nmethod_pre(&_jvmci_installed_code, this);
+ _jvmci_installed_code = NULL;
+ bs->write_ref_nmethod_post(&_jvmci_installed_code, this);
+ }
+ } else {
+ if (can_unload(is_alive, (oop*)&_jvmci_installed_code, unloading_occurred)) {
+ is_unloaded = true;
+ }
+ }
+ }
+
+ if (_speculation_log != NULL) {
+ if (!is_alive->do_object_b(_speculation_log)) {
+ bs->write_ref_nmethod_pre(&_speculation_log, this);
+ _speculation_log = NULL;
+ bs->write_ref_nmethod_post(&_speculation_log, this);
+ }
+ }
+#endif
+
// Ensure that all metadata is still alive
verify_metadata_loaders(low_boundary, is_alive);
return postponed;
}
@@ -2011,10 +2232,19 @@
low_boundary += NativeJump::instruction_size;
// %%% Note: On SPARC we patch only a 4-byte trap, not a full NativeJump.
// (See comment above.)
}
+#if INCLUDE_JVMCI
+ if (_jvmci_installed_code != NULL) {
+ f->do_oop((oop*) &_jvmci_installed_code);
+ }
+ if (_speculation_log != NULL) {
+ f->do_oop((oop*) &_speculation_log);
+ }
+#endif
+
RelocIterator iter(this, low_boundary);
while (iter.next()) {
if (iter.type() == relocInfo::oop_type ) {
oop_Relocation* r = iter.oop_reloc();
@@ -2135,11 +2365,11 @@
// Method that knows how to preserve outgoing arguments at call. This method must be
// called with a frame corresponding to a Java invoke
void nmethod::preserve_callee_argument_oops(frame fr, const RegisterMap *reg_map, OopClosure* f) {
#ifndef SHARK
- if (!method()->is_native()) {
+ if (method() != NULL && !method()->is_native()) {
SimpleScopeDesc ssd(this, fr.pc());
Bytecode_invoke call(ssd.method(), ssd.bci());
bool has_receiver = call.has_receiver();
bool has_appendix = call.has_appendix();
Symbol* signature = call.signature();
@@ -2201,19 +2431,27 @@
void nmethod::copy_scopes_data(u_char* buffer, int size) {
assert(scopes_data_size() >= size, "oob");
memcpy(scopes_data_begin(), buffer, size);
}
+// When using JVMCI the address might be off by the size of a call instruction.
+bool nmethod::is_deopt_entry(address pc) {
+ return pc == deopt_handler_begin()
+#if INCLUDE_JVMCI
+ || pc == (deopt_handler_begin() + NativeCall::instruction_size)
+#endif
+ ;
+}
#ifdef ASSERT
static PcDesc* linear_search(nmethod* nm, int pc_offset, bool approximate) {
PcDesc* lower = nm->scopes_pcs_begin();
PcDesc* upper = nm->scopes_pcs_end();
lower += 1; // exclude initial sentinel
PcDesc* res = NULL;
for (PcDesc* p = lower; p < upper; p++) {
- NOT_PRODUCT(--nmethod_stats.pc_desc_tests); // don't count this call to match_desc
+ NOT_PRODUCT(--pc_nmethod_stats.pc_desc_tests); // don't count this call to match_desc
if (match_desc(p, pc_offset, approximate)) {
if (res == NULL)
res = p;
else
res = (PcDesc*) badAddress;
@@ -2256,11 +2494,11 @@
assert(upper->pc_offset() >= pc_offset, "sanity")
assert_LU_OK;
// Use the last successful return as a split point.
PcDesc* mid = _pc_desc_cache.last_pc_desc();
- NOT_PRODUCT(++nmethod_stats.pc_desc_searches);
+ NOT_PRODUCT(++pc_nmethod_stats.pc_desc_searches);
if (mid->pc_offset() < pc_offset) {
lower = mid;
} else {
upper = mid;
}
@@ -2269,11 +2507,11 @@
const int LOG2_RADIX = 4 /*smaller steps in debug mode:*/ debug_only(-1);
const int RADIX = (1 << LOG2_RADIX);
for (int step = (1 << (LOG2_RADIX*3)); step > 1; step >>= LOG2_RADIX) {
while ((mid = lower + step) < upper) {
assert_LU_OK;
- NOT_PRODUCT(++nmethod_stats.pc_desc_searches);
+ NOT_PRODUCT(++pc_nmethod_stats.pc_desc_searches);
if (mid->pc_offset() < pc_offset) {
lower = mid;
} else {
upper = mid;
break;
@@ -2284,11 +2522,11 @@
// Sneak up on the value with a linear search of length ~16.
while (true) {
assert_LU_OK;
mid = lower + 1;
- NOT_PRODUCT(++nmethod_stats.pc_desc_searches);
+ NOT_PRODUCT(++pc_nmethod_stats.pc_desc_searches);
if (mid->pc_offset() < pc_offset) {
lower = mid;
} else {
upper = mid;
break;
@@ -2471,11 +2709,10 @@
if (nm == NULL) return;
Atomic::dec(&nm->_lock_count);
assert(nm->_lock_count >= 0, "unmatched nmethod lock/unlock");
}
-
// -----------------------------------------------------------------------------
// nmethod::get_deopt_original_pc
//
// Return the original PC for the given PC if:
// (a) the given PC belongs to a nmethod and
@@ -2585,11 +2822,11 @@
}
PcDesc* pd = pc_desc_at(nativeCall_at(call_site)->return_address());
assert(pd != NULL, "PcDesc must exist");
for (ScopeDesc* sd = new ScopeDesc(this, pd->scope_decode_offset(),
- pd->obj_decode_offset(), pd->should_reexecute(),
+ pd->obj_decode_offset(), pd->should_reexecute(), pd->rethrow_exception(),
pd->return_oop());
!sd->is_top(); sd = sd->sender()) {
sd->verify();
}
}
@@ -2678,10 +2915,12 @@
tty->print("(c1) ");
} else if (is_compiled_by_c2()) {
tty->print("(c2) ");
} else if (is_compiled_by_shark()) {
tty->print("(shark) ");
+ } else if (is_compiled_by_jvmci()) {
+ tty->print("(JVMCI) ");
} else {
tty->print("(nm) ");
}
print_on(tty, NULL);
@@ -2762,11 +3001,14 @@
for (PcDesc* p = scopes_pcs_begin(); p < scopes_pcs_end(); p++) {
if (p->scope_decode_offset() == DebugInformationRecorder::serialized_null)
continue;
ScopeDesc* sd = scope_desc_at(p->real_pc(this));
+ while (sd != NULL) {
sd->print_on(tty, p);
+ sd = sd->sender();
+ }
}
}
void nmethod::print_dependencies() {
ResourceMark rm;
@@ -2879,22 +3121,22 @@
// Return a the last scope in (begin..end]
ScopeDesc* nmethod::scope_desc_in(address begin, address end) {
PcDesc* p = pc_desc_near(begin+1);
if (p != NULL && p->real_pc(this) <= end) {
return new ScopeDesc(this, p->scope_decode_offset(),
- p->obj_decode_offset(), p->should_reexecute(),
+ p->obj_decode_offset(), p->should_reexecute(), p->rethrow_exception(),
p->return_oop());
}
return NULL;
}
void nmethod::print_nmethod_labels(outputStream* stream, address block_begin) const {
if (block_begin == entry_point()) stream->print_cr("[Entry Point]");
if (block_begin == verified_entry_point()) stream->print_cr("[Verified Entry Point]");
- if (block_begin == exception_begin()) stream->print_cr("[Exception Handler]");
+ if (JVMCI_ONLY(_exception_offset >= 0 &&) block_begin == exception_begin()) stream->print_cr("[Exception Handler]");
if (block_begin == stub_begin()) stream->print_cr("[Stub Code]");
- if (block_begin == deopt_handler_begin()) stream->print_cr("[Deopt Handler Code]");
+ if (JVMCI_ONLY(_deoptimize_offset >= 0 &&) block_begin == deopt_handler_begin()) stream->print_cr("[Deopt Handler Code]");
if (has_method_handle_invokes())
if (block_begin == deopt_mh_handler_begin()) stream->print_cr("[Deopt MH Handler Code]");
if (block_begin == consts_begin()) stream->print_cr("[Constants]");
@@ -3056,10 +3298,11 @@
else
st->print("<UNKNOWN>");
}
}
}
+ st->print(" {reexecute=%d rethrow=%d return_oop=%d}", sd->should_reexecute(), sd->rethrow_exception(), sd->return_oop());
}
// Print all scopes
for (;sd != NULL; sd = sd->sender()) {
st->move_to(column);
@@ -3128,14 +3371,51 @@
}
void nmethod::print_statistics() {
ttyLocker ttyl;
if (xtty != NULL) xtty->head("statistics type='nmethod'");
- nmethod_stats.print_native_nmethod_stats();
- nmethod_stats.print_nmethod_stats();
+ native_nmethod_stats.print_native_nmethod_stats();
+#ifdef COMPILER1
+ c1_java_nmethod_stats.print_nmethod_stats("C1");
+#endif
+#ifdef COMPILER2
+ c2_java_nmethod_stats.print_nmethod_stats("C2");
+#endif
+#if INCLUDE_JVMCI
+ jvmci_java_nmethod_stats.print_nmethod_stats("JVMCI");
+#endif
+#ifdef SHARK
+ shark_java_nmethod_stats.print_nmethod_stats("Shark");
+#endif
+ unknown_java_nmethod_stats.print_nmethod_stats("Unknown");
DebugInformationRecorder::print_statistics();
- nmethod_stats.print_pc_stats();
+#ifndef PRODUCT
+ pc_nmethod_stats.print_pc_stats();
+#endif
Dependencies::print_statistics();
if (xtty != NULL) xtty->tail("statistics");
}
-#endif // PRODUCT
+#endif // !PRODUCT
+
+#if INCLUDE_JVMCI
+char* nmethod::jvmci_installed_code_name(char* buf, size_t buflen) {
+ if (!this->is_compiled_by_jvmci()) {
+ return NULL;
+ }
+ oop installedCode = this->jvmci_installed_code();
+ if (installedCode != NULL) {
+ oop installedCodeName = NULL;
+ if (installedCode->is_a(InstalledCode::klass())) {
+ installedCodeName = InstalledCode::name(installedCode);
+ }
+ if (installedCodeName != NULL) {
+ return java_lang_String::as_utf8_string(installedCodeName, buf, (int)buflen);
+ } else {
+ jio_snprintf(buf, buflen, "null");
+ return buf;
+ }
+ }
+ jio_snprintf(buf, buflen, "noInstalledCode");
+ return buf;
+}
+#endif
< prev index next >