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

comparison src/share/vm/oops/methodData.cpp @ 14909:4ca6dc0799b6

Backout jdk9 merge

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Tue, 01 Apr 2014 13:57:07 +0200
parents	8762b6b8fbb6
children	52b4284cb496

comparison

equal deleted inserted replaced

-:8db6e76cb658
+:4ca6dc0799b6
 // 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 char* extra) const {
+void ProfileData::print_shared(outputStream* st, const char* name) 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 char* extra) const {
+void BitData::print_data_on(outputStream* st) const {
-print_shared(st, "BitData", extra);
+print_shared(st, "BitData");
 }
 #endif // !PRODUCT
 // ==================================================================
 // CounterData
 //
 // A CounterData corresponds to a simple counter.
 #ifndef PRODUCT
-void CounterData::print_data_on(outputStream* st, const char* extra) const {
+void CounterData::print_data_on(outputStream* st) const {
-print_shared(st, "CounterData", extra);
+print_shared(st, "CounterData");
 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 char* extra) const {
+void JumpData::print_data_on(outputStream* st) const {
-print_shared(st, "JumpData", extra);
+print_shared(st, "JumpData");
 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 char* extra) const {
+void CallTypeData::print_data_on(outputStream* st) const {
-CounterData::print_data_on(st, extra);
+CounterData::print_data_on(st);
 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 char* extra) const {
+void VirtualCallTypeData::print_data_on(outputStream* st) const {
-VirtualCallData::print_data_on(st, extra);
+VirtualCallData::print_data_on(st);
 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 char* extra) const {
+void ReceiverTypeData::print_data_on(outputStream* st) const {
-print_shared(st, "ReceiverTypeData", extra);
+print_shared(st, "ReceiverTypeData");
 print_receiver_data_on(st);
 }
 #ifdef GRAAL
 void VirtualCallData::print_method_data_on(outputStream* st) const {
 }
 }
 }
 #endif
-void VirtualCallData::print_data_on(outputStream* st, const char* extra) const {
+void VirtualCallData::print_data_on(outputStream* st) const {
-print_shared(st, "VirtualCallData", extra);
+print_shared(st, "VirtualCallData");
 print_receiver_data_on(st);
 #ifdef GRAAL
 print_method_data_on(st);
 #endif
 }
 }
 }
 return mdp;
 }
-#ifdef CC_INTERP
-DataLayout* RetData::advance(MethodData *md, int bci) {
-return (DataLayout*) md->bci_to_dp(bci);
-}
-#endif // CC_INTERP
 #ifndef PRODUCT
-void RetData::print_data_on(outputStream* st, const char* extra) const {
+void RetData::print_data_on(outputStream* st) const {
-print_shared(st, "RetData", extra);
+print_shared(st, "RetData");
 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 char* extra) const {
+void BranchData::print_data_on(outputStream* st) const {
-print_shared(st, "BranchData", extra);
+print_shared(st, "BranchData");
 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 char* extra) const {
+void MultiBranchData::print_data_on(outputStream* st) const {
-print_shared(st, "MultiBranchData", extra);
+print_shared(st, "MultiBranchData");
 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 char* extra) const {
+void ArgInfoData::print_data_on(outputStream* st) const {
-print_shared(st, "ArgInfoData", extra);
+print_shared(st, "ArgInfoData");
 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 char* extra) const {
+void ParametersTypeData::print_data_on(outputStream* st) const {
-st->print("parameter types", extra);
+st->print("parameter types");
 _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);
 }
-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;
-}
 #ifdef GRAAL
-int MethodData::compute_extra_data_count(int data_size, int empty_bc_count, bool needs_speculative_traps) {
+int MethodData::compute_extra_data_count(int data_size, int empty_bc_count) {
 if (!ProfileTraps) return 0;
 // Assume that up to 30% of the possibly trapping BCIs with no MDP will need to allocate one.
 return MIN2(empty_bc_count, MAX2(4, (empty_bc_count * 30) / 100));
 }
 #else
-int MethodData::compute_extra_data_count(int data_size, int empty_bc_count, bool needs_speculative_traps) {
+int MethodData::compute_extra_data_count(int data_size, int empty_bc_count) {
 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;
 }
 }
 #endif
 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 GRAAL_ONLY(&& Bytecodes::can_trap(c)))  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, needs_speculative_traps);
+int extra_data_count = compute_extra_data_count(data_size, empty_bc_count);
 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);
 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 GRAAL_ONLY(&& Bytecodes::can_trap(c)))  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, needs_speculative_traps);
+int extra_data_count = compute_extra_data_count(data_size, empty_bc_count);
 int extra_size = extra_data_count * DataLayout::compute_size_in_bytes(0);
-//#ifdef GRAAL
+#ifdef GRAAL
-//  if (for_reprofile) {
+if (for_reprofile) {
-//    // Clear out extra data
+// Clear out extra data
-//    Copy::zero_to_bytes((HeapWord*) extra_data_base(), extra_size);
+Copy::zero_to_bytes((HeapWord*) extra_data_base(), extra_size);
-//  }
+}
-//#endif
+#endif
-// 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 parms_cell = ParametersTypeData::compute_cell_count(method());
+int args_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 (parms_cell > 0) {
+if (args_cell > 0) {
-object_size += DataLayout::compute_size_in_bytes(parms_cell);
+object_size += DataLayout::compute_size_in_bytes(args_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, parms_cell);
+dp->initialize(DataLayout::parameters_type_data_tag, 0, args_cell);
 } else {
 _parameters_type_data_di = -1;
 }
 // Set an initial hint. Don't use set_hint_di() because
 return data;
 } else if (data->bci() > bci) {
 break;
 }
 }
-return bci_to_extra_data(bci, NULL, false);
+return bci_to_extra_data(bci, false);
 }
-DataLayout* MethodData::next_extra(DataLayout* dp) {
+// Translate a bci to its corresponding extra data, or NULL.
-int nb_cells = 0;
+ProfileData* MethodData::bci_to_extra_data(int bci, bool create_if_missing) {
-switch(dp->tag()) {
+DataLayout* dp    = extra_data_base();
-case DataLayout::bit_data_tag:
+DataLayout* end   = extra_data_limit();
-case DataLayout::no_tag:
+DataLayout* avail = NULL;
-nb_cells = BitData::static_cell_count();
+for (; dp < end; dp = next_extra(dp)) {
-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) {
-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.
-switch(dp->tag()) {
+if (dp->tag() == DataLayout::no_tag)  break;
-case DataLayout::no_tag:
+if (dp->tag() == DataLayout::arg_info_data_tag) {
-return NULL;
+dp = end; // ArgInfoData is at the end of extra data section.
-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 (m != NULL) {
+if (dp->bci() == bci) {
-SpeculativeTrapData* data = new SpeculativeTrapData(dp);
+assert(dp->tag() == DataLayout::bit_data_tag, "sane");
-// data->method() may be null in case of a concurrent
+return new BitData(dp);
-// allocation. Assume it's for the same method and use that
+}
-// entry in that case.
+}
-if (dp->bci() == bci) {
+if (create_if_missing && dp < end) {
-if (data->method() == NULL) {
+// Allocate this one.  There is no mutual exclusion,
-return NULL;
+// so two threads could allocate different BCIs to the
-} else if (data->method() == m) {
+// same data layout.  This means these extra data
-return data;
+// records, like most other MDO contents, must not be
-}
+// trusted too much.
-}
+DataLayout temp;
-}
+temp.initialize(DataLayout::bit_data_tag, bci, 0);
-break;
+dp->release_set_header(temp.header());
-default:
+assert(dp->tag() == DataLayout::bit_data_tag, "sane");
-fatal(err_msg("unexpected tag %d", dp->tag()));
+//NO: assert(dp->bci() == bci, "no concurrent allocation");
-}
+return new BitData(dp);
-}
-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.
-while (true) {
-ProfileData* result = bci_to_extra_data_helper(bci, m, dp);
-if (result != NULL) {
-return result;
-}
-if (create_if_missing && dp < end) {
-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);
-// May have been set concurrently
-if (dp->header() != temp.header() && !dp->atomic_set_header(temp.header())) {
-// Allocation failure because of concurrent allocation. Try
-// again.
-continue;
-}
-assert(dp->tag() == tag, "sane");
-assert(dp->bci() == bci, "no concurrent allocation");
-if (tag == DataLayout::bit_data_tag) {
-return new BitData(dp);
-} else {
-// If being allocated concurrently, one trap may be lost
-SpeculativeTrapData* data = new SpeculativeTrapData(dp);
-data->set_method(m);
-return data;
-}
-}
-return NULL;
 }
 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, this);
+data->print_data_on(st);
 }
 st->print_cr("--- Extra data:");
 DataLayout* dp    = extra_data_base();
 DataLayout* end   = extra_data_limit();
-for (;; dp = next_extra(dp)) {
+for (; dp < end; 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.
-switch(dp->tag()) {
+if (dp->tag() == DataLayout::no_tag)  continue;
-case DataLayout::no_tag:
+if (dp->tag() == DataLayout::bit_data_tag) {
-continue;
-case DataLayout::bit_data_tag:
 data = new BitData(dp);
-break;
+} else {
-case DataLayout::speculative_trap_data_tag:
+assert(dp->tag() == DataLayout::arg_info_data_tag, "must be BitData or ArgInfo");
-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);
-}
-// Remove SpeculativeTrapData entries that reference a redefined
-// method
-void MethodData::clean_weak_method_extra_data() {
-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->on_stack()) {
-// "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 redefined method referenced by a
-// SpeculativeTrapData entry
-void MethodData::verify_weak_method_extra_data_clean() {
-#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->on_stack(), "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_weak_method_links() {
 for (ProfileData* data = first_data();
 is_valid(data);
 data = next_data(data)) {
 data->clean_weak_method_links();
 }
+}
-clean_weak_method_extra_data();
-verify_weak_method_extra_data_clean();
-}

Mercurial > hg > graal-compiler

comparison src/share/vm/oops/methodData.cpp @ 14909:4ca6dc0799b6