graal-jvmci-8: src/share/vm/code/nmethod.cpp comparison

comparison src/share/vm/code/nmethod.cpp @ 8506:c3657d00e343

-Merge with tip

author	Christos Kotselidis <christos.kotselidis@oracle.com>
date	Thu, 21 Mar 2013 14:11:13 +0100
parents	86b4965f0c9a 985a97ba083c
children	b9a918201d47

comparison

equal deleted inserted replaced

-:dee7c8b578c7
+:c3657d00e343
 #include "runtime/sharedRuntime.hpp"
 #include "runtime/sweeper.hpp"
 #include "utilities/dtrace.hpp"
 #include "utilities/events.hpp"
 #include "utilities/xmlstream.hpp"
-#include "utilities/debug.hpp"
-#include "utilities/machineCodePrinter.hpp"
 #ifdef SHARK
 #include "shark/sharkCompiler.hpp"
 #endif
 #ifdef GRAAL
 #include "graal/graalJavaAccess.hpp"
 // NMethod statistics
 // They are printed under various flags, including:
 //   PrintC1Statistics, PrintOptoStatistics, LogVMOutput, and LogCompilation.
 // (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 {
 int nmethod_count;
 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
 //---------------------------------------------------------------------------------
 _scavenge_root_state     = 0;
 _saved_nmethod_link      = NULL;
 _compiler                = NULL;
 #ifdef GRAAL
 _graal_installed_code   = NULL;
+_triggered_deoptimizations = NULL;
 #endif
 #ifdef HAVE_DTRACE_H
 _trap_offset             = 0;
 #endif // def HAVE_DTRACE_H
 }
 nm = new (native_nmethod_size)
 nmethod(method(), native_nmethod_size, compile_id, &offsets,
 code_buffer, frame_size,
 basic_lock_owner_sp_offset, basic_lock_sp_offset,
 oop_maps);
-if (nm != NULL)  nmethod_stats.note_native_nmethod(nm);
+NOT_PRODUCT(if (nm != NULL)  nmethod_stats.note_native_nmethod(nm));
 if (PrintAssembly && nm != NULL)
 Disassembler::decode(nm);
-if (PrintMachineCodeToFile) {
-MachineCodePrinter::print(nm);
-}
 }
 // verify nmethod
 debug_only(if (nm) nm->verify();) // might block
 if (nm != NULL) {
 offsets.set_value(CodeOffsets::Dtrace_trap, trap_offset);
 offsets.set_value(CodeOffsets::Frame_Complete, frame_complete);
 nm = new (nmethod_size) nmethod(method(), nmethod_size, &offsets, code_buffer, frame_size);
-if (nm != NULL)  nmethod_stats.note_nmethod(nm);
+NOT_PRODUCT(if (nm != NULL)  nmethod_stats.note_nmethod(nm));
 if (PrintAssembly && nm != NULL)
 Disassembler::decode(nm);
 }
 // verify nmethod
 debug_only(if (nm) nm->verify();) // might block
 ImplicitExceptionTable* nul_chk_table,
 AbstractCompiler* compiler,
 int comp_level,
 GrowableArray<jlong>* leaf_graph_ids
 #ifdef GRAAL
-, Handle installed_code
+, Handle installed_code,
+Handle triggered_deoptimizations
 #endif
 )
 {
 assert(debug_info->oop_recorder() == code_buffer->oop_recorder(), "shared OR");
 code_buffer->finalize_oop_references(method);
 nul_chk_table,
 compiler,
 comp_level,
 leaf_graph_ids
 #ifdef GRAAL
-, installed_code
+, installed_code,
+triggered_deoptimizations
 #endif
 );
 if (nm != NULL) {
 // To make dependency checking during class loading fast, record
 // the nmethod dependencies in the classes it is dependent on.
 // record this nmethod as dependent on this klass
 InstanceKlass::cast(klass)->add_dependent_nmethod(nm);
 }
 }
-if (nm != NULL)  nmethod_stats.note_nmethod(nm);
+NOT_PRODUCT(if (nm != NULL)  nmethod_stats.note_nmethod(nm));
 if (PrintAssembly && nm != NULL)
 Disassembler::decode(nm);
-if (nm != NULL && PrintMachineCodeToFile) {
-MachineCodePrinter::print(nm);
-}
 }
 // verify nmethod
 debug_only(if (nm) nm->verify();) // might block
 ImplicitExceptionTable* nul_chk_table,
 AbstractCompiler* compiler,
 int comp_level,
 GrowableArray<jlong>* leaf_graph_ids
 #ifdef GRAAL
-, Handle installed_code
+, Handle installed_code,
+Handle triggered_deoptimizations
 #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)),
 _consts_offset           = content_offset()      + code_buffer->total_offset_of(code_buffer->consts());
 _stub_offset             = content_offset()      + code_buffer->total_offset_of(code_buffer->stubs());
 #ifdef GRAAL
 _graal_installed_code = installed_code();
+_triggered_deoptimizations = (typeArrayOop)triggered_deoptimizations();
 #endif
 if (compiler->is_graal()) {
 // Graal might not produce any stub sections
 if (offsets->value(CodeOffsets::Exceptions) != -1) {
 _exception_offset        = code_offset()          + offsets->value(CodeOffsets::Exceptions);
 unloading_occurred = true;
 }
 #ifdef GRAAL
 // Follow Graal method
-if (_graal_installed_code != NULL && can_unload(is_alive, (oop*)&_graal_installed_code, unloading_occurred)) {
+if (_graal_installed_code != NULL) {
-return;
+if (HotSpotInstalledCode::isDefault(_graal_installed_code)) {
+if (!is_alive->do_object_b(_graal_installed_code)) {
+_graal_installed_code = NULL;
+}
+} else {
+if (can_unload(is_alive, (oop*)&_graal_installed_code, unloading_occurred)) {
+return;
+}
+}
 }
 #endif
 // Exception cache
 ExceptionCache* ec = exception_cache();
 // all strong references alive.  Any weak references should have been
 // cleared as well.  Visit all the metadata and ensure that it's
 // really alive.
 void nmethod::verify_metadata_loaders(address low_boundary, BoolObjectClosure* is_alive) {
 #ifdef ASSERT
 RelocIterator iter(this, low_boundary);
 while (iter.next()) {
 // static_stub_Relocations may have dangling references to
 // Method*s so trim them out here.  Otherwise it looks like
 // compiled code is maintaining a link to dead metadata.
 address static_call_addr = NULL;
 if (iter.type() == relocInfo::opt_virtual_call_type) {
 CompiledIC* cic = CompiledIC_at(iter.reloc());
 if (!cic->is_call_to_interpreted()) {
 static_call_addr = iter.addr();
-cic->set_to_clean();
 }
 } else if (iter.type() == relocInfo::static_call_type) {
 CompiledStaticCall* csc = compiledStaticCall_at(iter.reloc());
 if (!csc->is_call_to_interpreted()) {
 static_call_addr = iter.addr();
-csc->set_to_clean();
 }
 }
 if (static_call_addr != NULL) {
 RelocIterator sciter(this, low_boundary);
 while (sciter.next()) {
 }
 #ifdef GRAAL
 if (_graal_installed_code != NULL) {
 f->do_oop((oop*) &_graal_installed_code);
+}
+if (_triggered_deoptimizations != NULL) {
+f->do_oop((oop*) &_triggered_deoptimizations);
 }
 #endif
 RelocIterator iter(this, low_boundary);
 // Right now there is no way to find out which entries support
 // an interrupt point.  It would be nice if we had this
 // information in a table.
 break;
 }
-#ifndef GRAAL
 assert(stub == NULL || stub_contains(stub), "static call stub outside stub section");
-#endif
 }
 }
 // -----------------------------------------------------------------------------
 void nmethod::print_nul_chk_table() {
 ImplicitExceptionTable(this).print(code_begin());
 }
-#endif // PRODUCT
 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();
 nmethod_stats.print_pc_stats();
 Dependencies::print_statistics();
 if (xtty != NULL)  xtty->tail("statistics");
 }
-#ifdef GRAAL
+#endif // PRODUCT
-void DebugScopedNMethod::print_on(outputStream* st) {
-if (_nm != NULL) {
-st->print("nmethod@%p", _nm);
-Method* method = _nm->method();
-if (method != NULL) {
-char holder[O_BUFLEN];
-char nameAndSig[O_BUFLEN];
-method->method_holder()->name()->as_C_string(holder, O_BUFLEN);
-method->name_and_sig_as_C_string(nameAndSig, O_BUFLEN);
-st->print(" - %s::%s", holder, nameAndSig);
-}
-}
-}
-#endif

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/code/nmethod.cpp @ 8506:c3657d00e343