graal-compiler: src/share/vm/oops/methodData.cpp comparison

comparison src/share/vm/oops/methodData.cpp @ 17810:62c54fcc0a35

Merge

author	kvn
date	Tue, 25 Mar 2014 17:07:36 -0700
parents	da862781b584 606acabe7b5c
children	78bbf4d43a14

comparison

equal deleted inserted replaced

-:a433eb716ce1
+:62c54fcc0a35
 *
 */
 #include "precompiled.hpp"
 #include "classfile/systemDictionary.hpp"
+#include "compiler/compilerOracle.hpp"
 #include "interpreter/bytecode.hpp"
 #include "interpreter/bytecodeStream.hpp"
 #include "interpreter/linkResolver.hpp"
 #include "memory/heapInspection.hpp"
 #include "oops/methodData.hpp"
 // Constructor for invalid ProfileData.
 ProfileData::ProfileData() {
 _data = NULL;
 }
+char* ProfileData::print_data_on_helper(const MethodData* md) const {
+DataLayout* dp  = md->extra_data_base();
+DataLayout* end = md->extra_data_limit();
+stringStream ss;
+for (;; dp = MethodData::next_extra(dp)) {
+assert(dp < end, "moved past end of extra data");
+switch(dp->tag()) {
+case DataLayout::speculative_trap_data_tag:
+if (dp->bci() == bci()) {
+SpeculativeTrapData* data = new SpeculativeTrapData(dp);
+int trap = data->trap_state();
+char buf[100];
+ss.print("trap/");
+data->method()->print_short_name(&ss);
+ss.print("(%s) ", Deoptimization::format_trap_state(buf, sizeof(buf), trap));
+}
+break;
+case DataLayout::bit_data_tag:
+break;
+case DataLayout::no_tag:
+case DataLayout::arg_info_data_tag:
+return ss.as_string();
+break;
+default:
+fatal(err_msg("unexpected tag %d", dp->tag()));
+}
+}
+return NULL;
+}
+void ProfileData::print_data_on(outputStream* st, const MethodData* md) const {
+print_data_on(st, print_data_on_helper(md));
+}
 #ifndef PRODUCT
-void ProfileData::print_shared(outputStream* st, const char* name) const {
+void ProfileData::print_shared(outputStream* st, const char* name, const char* extra) const {
 st->print("bci: %d", bci());
 st->fill_to(tab_width_one);
 st->print("%s", name);
 tab(st);
 int trap = trap_state();
 if (trap != 0) {
 char buf[100];
 st->print("trap(%s) ", Deoptimization::format_trap_state(buf, sizeof(buf), trap));
 }
+if (extra != NULL) {
+st->print(extra);
+}
 int flags = data()->flags();
-if (flags != 0)
+if (flags != 0) {
 st->print("flags(%d) ", flags);
+}
 }
 void ProfileData::tab(outputStream* st, bool first) const {
 st->fill_to(first ? tab_width_one : tab_width_two);
 }
 // A BitData corresponds to a one-bit flag.  This is used to indicate
 // whether a checkcast bytecode has seen a null value.
 #ifndef PRODUCT
-void BitData::print_data_on(outputStream* st) const {
+void BitData::print_data_on(outputStream* st, const char* extra) const {
-print_shared(st, "BitData");
+print_shared(st, "BitData", extra);
 }
 #endif // !PRODUCT
 // ==================================================================
 // CounterData
 //
 // A CounterData corresponds to a simple counter.
 #ifndef PRODUCT
-void CounterData::print_data_on(outputStream* st) const {
+void CounterData::print_data_on(outputStream* st, const char* extra) const {
-print_shared(st, "CounterData");
+print_shared(st, "CounterData", extra);
 st->print_cr("count(%u)", count());
 }
 #endif // !PRODUCT
 // ==================================================================
 int offset = target_di - my_di;
 set_displacement(offset);
 }
 #ifndef PRODUCT
-void JumpData::print_data_on(outputStream* st) const {
+void JumpData::print_data_on(outputStream* st, const char* extra) const {
-print_shared(st, "JumpData");
+print_shared(st, "JumpData", extra);
 st->print_cr("taken(%u) displacement(%d)", taken(), displacement());
 }
 #endif // !PRODUCT
 int TypeStackSlotEntries::compute_cell_count(Symbol* signature, bool include_receiver, int max) {
 _pd->tab(st);
 print_klass(st, type());
 st->cr();
 }
-void CallTypeData::print_data_on(outputStream* st) const {
+void CallTypeData::print_data_on(outputStream* st, const char* extra) const {
-CounterData::print_data_on(st);
+CounterData::print_data_on(st, extra);
 if (has_arguments()) {
 tab(st, true);
 st->print("argument types");
 _args.print_data_on(st);
 }
 st->print("return type");
 _ret.print_data_on(st);
 }
 }
-void VirtualCallTypeData::print_data_on(outputStream* st) const {
+void VirtualCallTypeData::print_data_on(outputStream* st, const char* extra) const {
-VirtualCallData::print_data_on(st);
+VirtualCallData::print_data_on(st, extra);
 if (has_arguments()) {
 tab(st, true);
 st->print("argument types");
 _args.print_data_on(st);
 }
 receiver(row)->print_value_on(st);
 st->print_cr("(%u %4.2f)", receiver_count(row), (float) receiver_count(row) / (float) total);
 }
 }
 }
-void ReceiverTypeData::print_data_on(outputStream* st) const {
+void ReceiverTypeData::print_data_on(outputStream* st, const char* extra) const {
-print_shared(st, "ReceiverTypeData");
+print_shared(st, "ReceiverTypeData", extra);
 print_receiver_data_on(st);
 }
-void VirtualCallData::print_data_on(outputStream* st) const {
+void VirtualCallData::print_data_on(outputStream* st, const char* extra) const {
-print_shared(st, "VirtualCallData");
+print_shared(st, "VirtualCallData", extra);
 print_receiver_data_on(st);
 }
 #endif // !PRODUCT
 // ==================================================================
 return (DataLayout*) md->bci_to_dp(bci);
 }
 #endif // CC_INTERP
 #ifndef PRODUCT
-void RetData::print_data_on(outputStream* st) const {
+void RetData::print_data_on(outputStream* st, const char* extra) const {
-print_shared(st, "RetData");
+print_shared(st, "RetData", extra);
 uint row;
 int entries = 0;
 for (row = 0; row < row_limit(); row++) {
 if (bci(row) != no_bci)  entries++;
 }
 int offset = target_di - my_di;
 set_displacement(offset);
 }
 #ifndef PRODUCT
-void BranchData::print_data_on(outputStream* st) const {
+void BranchData::print_data_on(outputStream* st, const char* extra) const {
-print_shared(st, "BranchData");
+print_shared(st, "BranchData", extra);
 st->print_cr("taken(%u) displacement(%d)",
 taken(), displacement());
 tab(st);
 st->print_cr("not taken(%u)", not_taken());
 }
 set_default_displacement(offset);
 }
 }
 #ifndef PRODUCT
-void MultiBranchData::print_data_on(outputStream* st) const {
+void MultiBranchData::print_data_on(outputStream* st, const char* extra) const {
-print_shared(st, "MultiBranchData");
+print_shared(st, "MultiBranchData", extra);
 st->print_cr("default_count(%u) displacement(%d)",
 default_count(), default_displacement());
 int cases = number_of_cases();
 for (int i = 0; i < cases; i++) {
 tab(st);
 }
 }
 #endif
 #ifndef PRODUCT
-void ArgInfoData::print_data_on(outputStream* st) const {
+void ArgInfoData::print_data_on(outputStream* st, const char* extra) const {
-print_shared(st, "ArgInfoData");
+print_shared(st, "ArgInfoData", extra);
 int nargs = number_of_args();
 for (int i = 0; i < nargs; i++) {
 st->print("  0x%x", arg_modified(i));
 }
 st->cr();
 bool ParametersTypeData::profiling_enabled() {
 return MethodData::profile_parameters();
 }
 #ifndef PRODUCT
-void ParametersTypeData::print_data_on(outputStream* st) const {
+void ParametersTypeData::print_data_on(outputStream* st, const char* extra) const {
-st->print("parameter types");
+st->print("parameter types", extra);
 _parameters.print_data_on(st);
+}
+void SpeculativeTrapData::print_data_on(outputStream* st, const char* extra) const {
+print_shared(st, "SpeculativeTrapData", extra);
+tab(st);
+method()->print_short_name(st);
+st->cr();
 }
 #endif
 // ==================================================================
 // MethodData*
 //        a DataLayout header, with no extra cells.
 assert(cell_count >= 0, "sanity");
 return DataLayout::compute_size_in_bytes(cell_count);
 }
-int MethodData::compute_extra_data_count(int data_size, int empty_bc_count) {
+bool MethodData::is_speculative_trap_bytecode(Bytecodes::Code code) {
+// Bytecodes for which we may use speculation
+switch (code) {
+case Bytecodes::_checkcast:
+case Bytecodes::_instanceof:
+case Bytecodes::_aastore:
+case Bytecodes::_invokevirtual:
+case Bytecodes::_invokeinterface:
+case Bytecodes::_if_acmpeq:
+case Bytecodes::_if_acmpne:
+case Bytecodes::_invokestatic:
+#ifdef COMPILER2
+return UseTypeSpeculation;
+#endif
+default:
+return false;
+}
+return false;
+}
+int MethodData::compute_extra_data_count(int data_size, int empty_bc_count, bool needs_speculative_traps) {
 if (ProfileTraps) {
 // Assume that up to 3% of BCIs with no MDP will need to allocate one.
 int extra_data_count = (uint)(empty_bc_count * 3) / 128 + 1;
 // If the method is large, let the extra BCIs grow numerous (to ~1%).
 int one_percent_of_data
 = (uint)data_size / (DataLayout::header_size_in_bytes()*128);
 if (extra_data_count < one_percent_of_data)
 extra_data_count = one_percent_of_data;
 if (extra_data_count > empty_bc_count)
 extra_data_count = empty_bc_count;  // no need for more
-return extra_data_count;
+// Make sure we have a minimum number of extra data slots to
+// allocate SpeculativeTrapData entries. We would want to have one
+// entry per compilation that inlines this method and for which
+// some type speculation assumption fails. So the room we need for
+// the SpeculativeTrapData entries doesn't directly depend on the
+// size of the method. Because it's hard to estimate, we reserve
+// space for an arbitrary number of entries.
+int spec_data_count = (needs_speculative_traps ? SpecTrapLimitExtraEntries : 0) *
+(SpeculativeTrapData::static_cell_count() + DataLayout::header_size_in_cells());
+return MAX2(extra_data_count, spec_data_count);
 } else {
 return 0;
 }
 }
 int MethodData::compute_allocation_size_in_bytes(methodHandle method) {
 int data_size = 0;
 BytecodeStream stream(method);
 Bytecodes::Code c;
 int empty_bc_count = 0;  // number of bytecodes lacking data
+bool needs_speculative_traps = false;
 while ((c = stream.next()) >= 0) {
 int size_in_bytes = compute_data_size(&stream);
 data_size += size_in_bytes;
 if (size_in_bytes == 0)  empty_bc_count += 1;
+needs_speculative_traps = needs_speculative_traps || is_speculative_trap_bytecode(c);
 }
 int object_size = in_bytes(data_offset()) + data_size;
 // Add some extra DataLayout cells (at least one) to track stray traps.
-int extra_data_count = compute_extra_data_count(data_size, empty_bc_count);
+int extra_data_count = compute_extra_data_count(data_size, empty_bc_count, needs_speculative_traps);
 object_size += extra_data_count * DataLayout::compute_size_in_bytes(0);
 // Add a cell to record information about modified arguments.
 int arg_size = method->size_of_parameters();
 object_size += DataLayout::compute_size_in_bytes(arg_size+1);
 parameters_type_data()->post_initialize(NULL, this);
 }
 }
 // Initialize the MethodData* corresponding to a given method.
-MethodData::MethodData(methodHandle method, int size, TRAPS) {
+MethodData::MethodData(methodHandle method, int size, TRAPS)
+: _extra_data_lock(Monitor::leaf, "MDO extra data lock") {
 No_Safepoint_Verifier no_safepoint;  // init function atomic wrt GC
 ResourceMark rm;
 // Set the method back-pointer.
 _method = method();
 int data_size = 0;
 int empty_bc_count = 0;  // number of bytecodes lacking data
 _data[0] = 0;  // apparently not set below.
 BytecodeStream stream(method);
 Bytecodes::Code c;
+bool needs_speculative_traps = false;
 while ((c = stream.next()) >= 0) {
 int size_in_bytes = initialize_data(&stream, data_size);
 data_size += size_in_bytes;
 if (size_in_bytes == 0)  empty_bc_count += 1;
+needs_speculative_traps = needs_speculative_traps || is_speculative_trap_bytecode(c);
 }
 _data_size = data_size;
 int object_size = in_bytes(data_offset()) + data_size;
 // Add some extra DataLayout cells (at least one) to track stray traps.
-int extra_data_count = compute_extra_data_count(data_size, empty_bc_count);
+int extra_data_count = compute_extra_data_count(data_size, empty_bc_count, needs_speculative_traps);
 int extra_size = extra_data_count * DataLayout::compute_size_in_bytes(0);
+// Let's zero the space for the extra data
+Copy::zero_to_bytes(((address)_data) + data_size, extra_size);
 // Add a cell to record information about modified arguments.
 // Set up _args_modified array after traps cells so that
 // the code for traps cells works.
 DataLayout *dp = data_layout_at(data_size + extra_size);
 dp->initialize(DataLayout::arg_info_data_tag, 0, arg_size+1);
 int arg_data_size = DataLayout::compute_size_in_bytes(arg_size+1);
 object_size += extra_size + arg_data_size;
-int args_cell = ParametersTypeData::compute_cell_count(method());
+int parms_cell = ParametersTypeData::compute_cell_count(method());
 // If we are profiling parameters, we reserver an area near the end
 // of the MDO after the slots for bytecodes (because there's no bci
 // for method entry so they don't fit with the framework for the
 // profiling of bytecodes). We store the offset within the MDO of
 // this area (or -1 if no parameter is profiled)
-if (args_cell > 0) {
+if (parms_cell > 0) {
-object_size += DataLayout::compute_size_in_bytes(args_cell);
+object_size += DataLayout::compute_size_in_bytes(parms_cell);
 _parameters_type_data_di = data_size + extra_size + arg_data_size;
 DataLayout *dp = data_layout_at(data_size + extra_size + arg_data_size);
-dp->initialize(DataLayout::parameters_type_data_tag, 0, args_cell);
+dp->initialize(DataLayout::parameters_type_data_tag, 0, parms_cell);
 } else {
 _parameters_type_data_di = -1;
 }
 // Set an initial hint. Don't use set_hint_di() because
 _num_loops = 0;
 _num_blocks = 0;
 _highest_comp_level = 0;
 _highest_osr_comp_level = 0;
 _would_profile = true;
+#if INCLUDE_RTM_OPT
+_rtm_state = NoRTM; // No RTM lock eliding by default
+if (UseRTMLocking &&
+!CompilerOracle::has_option_string(_method, "NoRTMLockEliding")) {
+if (CompilerOracle::has_option_string(_method, "UseRTMLockEliding") || !UseRTMDeopt) {
+// Generate RTM lock eliding code without abort ratio calculation code.
+_rtm_state = UseRTM;
+} else if (UseRTMDeopt) {
+// Generate RTM lock eliding code and include abort ratio calculation
+// code if UseRTMDeopt is on.
+_rtm_state = ProfileRTM;
+}
+}
+#endif
 // Initialize flags and trap history.
 _nof_decompiles = 0;
 _nof_overflow_recompiles = 0;
 _nof_overflow_traps = 0;
 return data;
 } else if (data->bci() > bci) {
 break;
 }
 }
-return bci_to_extra_data(bci, false);
+return bci_to_extra_data(bci, NULL, false);
 }
-// Translate a bci to its corresponding extra data, or NULL.
+DataLayout* MethodData::next_extra(DataLayout* dp) {
-ProfileData* MethodData::bci_to_extra_data(int bci, bool create_if_missing) {
+int nb_cells = 0;
-DataLayout* dp    = extra_data_base();
+switch(dp->tag()) {
-DataLayout* end   = extra_data_limit();
+case DataLayout::bit_data_tag:
-DataLayout* avail = NULL;
+case DataLayout::no_tag:
-for (; dp < end; dp = next_extra(dp)) {
+nb_cells = BitData::static_cell_count();
+break;
+case DataLayout::speculative_trap_data_tag:
+nb_cells = SpeculativeTrapData::static_cell_count();
+break;
+default:
+fatal(err_msg("unexpected tag %d", dp->tag()));
+}
+return (DataLayout*)((address)dp + DataLayout::compute_size_in_bytes(nb_cells));
+}
+ProfileData* MethodData::bci_to_extra_data_helper(int bci, Method* m, DataLayout*& dp, bool concurrent) {
+DataLayout* end = extra_data_limit();
+for (;; dp = next_extra(dp)) {
+assert(dp < end, "moved past end of extra data");
 // No need for "OrderAccess::load_acquire" ops,
 // since the data structure is monotonic.
-if (dp->tag() == DataLayout::no_tag)  break;
+switch(dp->tag()) {
-if (dp->tag() == DataLayout::arg_info_data_tag) {
+case DataLayout::no_tag:
-dp = end; // ArgInfoData is at the end of extra data section.
+return NULL;
+case DataLayout::arg_info_data_tag:
+dp = end;
+return NULL; // ArgInfoData is at the end of extra data section.
+case DataLayout::bit_data_tag:
+if (m == NULL && dp->bci() == bci) {
+return new BitData(dp);
+}
 break;
-}
+case DataLayout::speculative_trap_data_tag:
-if (dp->bci() == bci) {
+if (m != NULL) {
-assert(dp->tag() == DataLayout::bit_data_tag, "sane");
+SpeculativeTrapData* data = new SpeculativeTrapData(dp);
+// data->method() may be null in case of a concurrent
+// allocation. Maybe it's for the same method. Try to use that
+// entry in that case.
+if (dp->bci() == bci) {
+if (data->method() == NULL) {
+assert(concurrent, "impossible because no concurrent allocation");
+return NULL;
+} else if (data->method() == m) {
+return data;
+}
+}
+}
+break;
+default:
+fatal(err_msg("unexpected tag %d", dp->tag()));
+}
+}
+return NULL;
+}
+// Translate a bci to its corresponding extra data, or NULL.
+ProfileData* MethodData::bci_to_extra_data(int bci, Method* m, bool create_if_missing) {
+// This code assumes an entry for a SpeculativeTrapData is 2 cells
+assert(2*DataLayout::compute_size_in_bytes(BitData::static_cell_count()) ==
+DataLayout::compute_size_in_bytes(SpeculativeTrapData::static_cell_count()),
+"code needs to be adjusted");
+DataLayout* dp  = extra_data_base();
+DataLayout* end = extra_data_limit();
+// Allocation in the extra data space has to be atomic because not
+// all entries have the same size and non atomic concurrent
+// allocation would result in a corrupted extra data space.
+ProfileData* result = bci_to_extra_data_helper(bci, m, dp, true);
+if (result != NULL) {
+return result;
+}
+if (create_if_missing && dp < end) {
+MutexLocker ml(&_extra_data_lock);
+// Check again now that we have the lock. Another thread may
+// have added extra data entries.
+ProfileData* result = bci_to_extra_data_helper(bci, m, dp, false);
+if (result != NULL || dp >= end) {
+return result;
+}
+assert(dp->tag() == DataLayout::no_tag || (dp->tag() == DataLayout::speculative_trap_data_tag && m != NULL), "should be free");
+assert(next_extra(dp)->tag() == DataLayout::no_tag || next_extra(dp)->tag() == DataLayout::arg_info_data_tag, "should be free or arg info");
+u1 tag = m == NULL ? DataLayout::bit_data_tag : DataLayout::speculative_trap_data_tag;
+// SpeculativeTrapData is 2 slots. Make sure we have room.
+if (m != NULL && next_extra(dp)->tag() != DataLayout::no_tag) {
+return NULL;
+}
+DataLayout temp;
+temp.initialize(tag, bci, 0);
+dp->set_header(temp.header());
+assert(dp->tag() == tag, "sane");
+assert(dp->bci() == bci, "no concurrent allocation");
+if (tag == DataLayout::bit_data_tag) {
 return new BitData(dp);
-}
+} else {
-}
+SpeculativeTrapData* data = new SpeculativeTrapData(dp);
-if (create_if_missing && dp < end) {
+data->set_method(m);
-// Allocate this one.  There is no mutual exclusion,
+return data;
-// so two threads could allocate different BCIs to the
+}
-// same data layout.  This means these extra data
-// records, like most other MDO contents, must not be
-// trusted too much.
-DataLayout temp;
-temp.initialize(DataLayout::bit_data_tag, bci, 0);
-dp->release_set_header(temp.header());
-assert(dp->tag() == DataLayout::bit_data_tag, "sane");
-//NO: assert(dp->bci() == bci, "no concurrent allocation");
-return new BitData(dp);
 }
 return NULL;
 }
 ArgInfoData *MethodData::arg_info() {
 parameters_type_data()->print_data_on(st);
 }
 for ( ; is_valid(data); data = next_data(data)) {
 st->print("%d", dp_to_di(data->dp()));
 st->fill_to(6);
-data->print_data_on(st);
+data->print_data_on(st, this);
 }
 st->print_cr("--- Extra data:");
 DataLayout* dp    = extra_data_base();
 DataLayout* end   = extra_data_limit();
-for (; dp < end; dp = next_extra(dp)) {
+for (;; dp = next_extra(dp)) {
+assert(dp < end, "moved past end of extra data");
 // No need for "OrderAccess::load_acquire" ops,
 // since the data structure is monotonic.
-if (dp->tag() == DataLayout::no_tag)  continue;
+switch(dp->tag()) {
-if (dp->tag() == DataLayout::bit_data_tag) {
+case DataLayout::no_tag:
+continue;
+case DataLayout::bit_data_tag:
 data = new BitData(dp);
-} else {
+break;
-assert(dp->tag() == DataLayout::arg_info_data_tag, "must be BitData or ArgInfo");
+case DataLayout::speculative_trap_data_tag:
+data = new SpeculativeTrapData(dp);
+break;
+case DataLayout::arg_info_data_tag:
 data = new ArgInfoData(dp);
 dp = end; // ArgInfoData is at the end of extra data section.
+break;
+default:
+fatal(err_msg("unexpected tag %d", dp->tag()));
 }
 st->print("%d", dp_to_di(data->dp()));
 st->fill_to(6);
 data->print_data_on(st);
+if (dp >= end) return;
 }
 }
 #endif
 #if INCLUDE_SERVICES
 }
 assert(profile_parameters_jsr292_only(), "inconsistent");
 return m->is_compiled_lambda_form();
 }
+void MethodData::clean_extra_data_helper(DataLayout* dp, int shift, bool reset) {
+if (shift == 0) {
+return;
+}
+if (!reset) {
+// Move all cells of trap entry at dp left by "shift" cells
+intptr_t* start = (intptr_t*)dp;
+intptr_t* end = (intptr_t*)next_extra(dp);
+for (intptr_t* ptr = start; ptr < end; ptr++) {
+*(ptr-shift) = *ptr;
+}
+} else {
+// Reset "shift" cells stopping at dp
+intptr_t* start = ((intptr_t*)dp) - shift;
+intptr_t* end = (intptr_t*)dp;
+for (intptr_t* ptr = start; ptr < end; ptr++) {
+*ptr = 0;
+}
+}
+}
+// Remove SpeculativeTrapData entries that reference an unloaded
+// method
+void MethodData::clean_extra_data(BoolObjectClosure* is_alive) {
+DataLayout* dp  = extra_data_base();
+DataLayout* end = extra_data_limit();
+int shift = 0;
+for (; dp < end; dp = next_extra(dp)) {
+switch(dp->tag()) {
+case DataLayout::speculative_trap_data_tag: {
+SpeculativeTrapData* data = new SpeculativeTrapData(dp);
+Method* m = data->method();
+assert(m != NULL, "should have a method");
+if (!m->method_holder()->is_loader_alive(is_alive)) {
+// "shift" accumulates the number of cells for dead
+// SpeculativeTrapData entries that have been seen so
+// far. Following entries must be shifted left by that many
+// cells to remove the dead SpeculativeTrapData entries.
+shift += (int)((intptr_t*)next_extra(dp) - (intptr_t*)dp);
+} else {
+// Shift this entry left if it follows dead
+// SpeculativeTrapData entries
+clean_extra_data_helper(dp, shift);
+}
+break;
+}
+case DataLayout::bit_data_tag:
+// Shift this entry left if it follows dead SpeculativeTrapData
+// entries
+clean_extra_data_helper(dp, shift);
+continue;
+case DataLayout::no_tag:
+case DataLayout::arg_info_data_tag:
+// We are at end of the live trap entries. The previous "shift"
+// cells contain entries that are either dead or were shifted
+// left. They need to be reset to no_tag
+clean_extra_data_helper(dp, shift, true);
+return;
+default:
+fatal(err_msg("unexpected tag %d", dp->tag()));
+}
+}
+}
+// Verify there's no unloaded method referenced by a
+// SpeculativeTrapData entry
+void MethodData::verify_extra_data_clean(BoolObjectClosure* is_alive) {
+#ifdef ASSERT
+DataLayout* dp  = extra_data_base();
+DataLayout* end = extra_data_limit();
+for (; dp < end; dp = next_extra(dp)) {
+switch(dp->tag()) {
+case DataLayout::speculative_trap_data_tag: {
+SpeculativeTrapData* data = new SpeculativeTrapData(dp);
+Method* m = data->method();
+assert(m != NULL && m->method_holder()->is_loader_alive(is_alive), "Method should exist");
+break;
+}
+case DataLayout::bit_data_tag:
+continue;
+case DataLayout::no_tag:
+case DataLayout::arg_info_data_tag:
+return;
+default:
+fatal(err_msg("unexpected tag %d", dp->tag()));
+}
+}
+#endif
+}
+void MethodData::clean_method_data(BoolObjectClosure* is_alive) {
+for (ProfileData* data = first_data();
+is_valid(data);
+data = next_data(data)) {
+data->clean_weak_klass_links(is_alive);
+}
+ParametersTypeData* parameters = parameters_type_data();
+if (parameters != NULL) {
+parameters->clean_weak_klass_links(is_alive);
+}
+clean_extra_data(is_alive);
+verify_extra_data_clean(is_alive);
+}

Mercurial > hg > graal-compiler

comparison src/share/vm/oops/methodData.cpp @ 17810:62c54fcc0a35