stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8204087: C++ Interpreter code left over in MethodData

Browse Source 
Remove unused code

Reviewed-by: kvn, lfoltan, thartmann
This commit is contained in:
Coleen Phillimore 2018-05-31 09:19:54 -04:00
parent 04482293bf
commit 89251ae9a3
3 changed files with 1 additions and 446 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

251
src/hotspot/share/interpreter/bytecodeInterpreterProfiling.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2002, 2014, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2002, 2018, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2012, 2014 SAP SE. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
@ -30,25 +30,10 @@
#ifndef SHARE_VM_INTERPRETER_BYTECODEINTERPRETERPROFILING_HPP
#define SHARE_VM_INTERPRETER_BYTECODEINTERPRETERPROFILING_HPP
// Global settings /////////////////////////////////////////////////////////////
// Enables profiling support.
#if defined(COMPILER2)
#define CC_INTERP_PROFILE
#endif
// Enables assertions for profiling code (also works in product-builds).
// #define CC_INTERP_PROFILE_WITH_ASSERTIONS
#ifdef CC_INTERP
// Empty dummy implementations if profiling code is switched off. //////////////
#ifndef CC_INTERP_PROFILE
#define SET_MDX(mdx)
#define BI_PROFILE_GET_OR_CREATE_METHOD_DATA(exception_handler) \
@ -69,240 +54,6 @@
#define BI_PROFILE_UPDATE_VIRTUALCALL(receiver)
#define BI_PROFILE_UPDATE_SWITCH(switch_index)
#else
// Non-dummy implementations ///////////////////////////////////////////////////
// Accessors for the current method data pointer 'mdx'.
#define MDX() (istate->mdx())
#define SET_MDX(mdx) \
if (TraceProfileInterpreter) { \
/* Let it look like TraceBytecodes' format. */ \
tty->print_cr("[%d] %4d " \
"mdx " PTR_FORMAT "(%d)" \
" " \
" \t-> " PTR_FORMAT "(%d)", \
(int) THREAD->osthread()->thread_id(), \
BCI(), \
p2i(MDX()), \
(MDX() == NULL \
? 0 \
: istate->method()->method_data()->dp_to_di((address)MDX())), \
p2i(mdx), \
istate->method()->method_data()->dp_to_di((address)mdx) \
); \
}; \
istate->set_mdx(mdx);
// Dumps the profiling method data for the current method.
#ifdef PRODUCT
#define BI_PROFILE_PRINT_METHOD_DATA()
#else // PRODUCT
#define BI_PROFILE_PRINT_METHOD_DATA() \
{ \
ttyLocker ttyl; \
MethodData *md = istate->method()->method_data(); \
tty->cr(); \
tty->print("method data at mdx " PTR_FORMAT "(0) for", \
p2i(md->data_layout_at(md->bci_to_di(0)))); \
istate->method()->print_short_name(tty); \
tty->cr(); \
if (md != NULL) { \
md->print_data_on(tty); \
address mdx = (address) MDX(); \
if (mdx != NULL) { \
tty->print_cr("current mdx " PTR_FORMAT "(%d)", \
p2i(mdx), \
istate->method()->method_data()->dp_to_di(mdx)); \
} \
} else { \
tty->print_cr("no method data"); \
} \
}
#endif // PRODUCT
// Gets or creates the profiling method data and initializes mdx.
#define BI_PROFILE_GET_OR_CREATE_METHOD_DATA(exception_handler) \
if (ProfileInterpreter && MDX() == NULL) { \
/* Mdx is not yet initialized for this activation. */ \
MethodData *md = istate->method()->method_data(); \
if (md == NULL) { \
MethodCounters* mcs; \
GET_METHOD_COUNTERS(mcs); \
/* The profiling method data doesn't exist for this method, */ \
/* create it if the counters have overflowed. */ \
if (mcs->invocation_counter() \
->reached_ProfileLimit(mcs->backedge_counter())) { \
/* Must use CALL_VM, because an async exception may be pending. */ \
CALL_VM((InterpreterRuntime::profile_method(THREAD)), \
exception_handler); \
md = istate->method()->method_data(); \
if (md != NULL) { \
if (TraceProfileInterpreter) { \
BI_PROFILE_PRINT_METHOD_DATA(); \
} \
Method *m = istate->method(); \
int bci = m->bci_from(pc); \
jint di = md->bci_to_di(bci); \
SET_MDX(md->data_layout_at(di)); \
} \
} \
} else { \
/* The profiling method data exists, align the method data pointer */ \
/* mdx to the current bytecode index. */ \
if (TraceProfileInterpreter) { \
BI_PROFILE_PRINT_METHOD_DATA(); \
} \
SET_MDX(md->data_layout_at(md->bci_to_di(BCI()))); \
} \
}
// Asserts that the current method data pointer mdx corresponds
// to the current bytecode.
#if defined(CC_INTERP_PROFILE_WITH_ASSERTIONS)
#define BI_PROFILE_CHECK_MDX() \
{ \
MethodData *md = istate->method()->method_data(); \
address mdx = (address) MDX(); \
address mdx2 = (address) md->data_layout_at(md->bci_to_di(BCI())); \
guarantee(md != NULL, "1"); \
guarantee(mdx != NULL, "2"); \
guarantee(mdx2 != NULL, "3"); \
if (mdx != mdx2) { \
BI_PROFILE_PRINT_METHOD_DATA(); \
fatal3("invalid mdx at bci %d:" \
" was " PTR_FORMAT \
" but expected " PTR_FORMAT, \
BCI(), \
mdx, \
mdx2); \
} \
}
#else
#define BI_PROFILE_CHECK_MDX()
#endif
// Aligns the method data pointer mdx to the current bytecode index.
#define BI_PROFILE_ALIGN_TO_CURRENT_BCI() \
if (ProfileInterpreter && MDX() != NULL) { \
MethodData *md = istate->method()->method_data(); \
SET_MDX(md->data_layout_at(md->bci_to_di(BCI()))); \
}
// Updates profiling data for a jump.
#define BI_PROFILE_UPDATE_JUMP() \
if (ProfileInterpreter && MDX() != NULL) { \
BI_PROFILE_CHECK_MDX(); \
JumpData::increment_taken_count_no_overflow(MDX()); \
/* Remember last branch taken count. */ \
mdo_last_branch_taken_count = JumpData::taken_count(MDX()); \
SET_MDX(JumpData::advance_taken(MDX())); \
}
// Updates profiling data for a taken/not taken branch.
#define BI_PROFILE_UPDATE_BRANCH(is_taken) \
if (ProfileInterpreter && MDX() != NULL) { \
BI_PROFILE_CHECK_MDX(); \
if (is_taken) { \
BranchData::increment_taken_count_no_overflow(MDX()); \
/* Remember last branch taken count. */ \
mdo_last_branch_taken_count = BranchData::taken_count(MDX()); \
SET_MDX(BranchData::advance_taken(MDX())); \
} else { \
BranchData::increment_not_taken_count_no_overflow(MDX()); \
SET_MDX(BranchData::advance_not_taken(MDX())); \
} \
}
// Updates profiling data for a ret with given bci.
#define BI_PROFILE_UPDATE_RET(bci) \
if (ProfileInterpreter && MDX() != NULL) { \
BI_PROFILE_CHECK_MDX(); \
MethodData *md = istate->method()->method_data(); \
/* FIXME: there is more to do here than increment and advance(mdx)! */ \
CounterData::increment_count_no_overflow(MDX()); \
SET_MDX(RetData::advance(md, bci)); \
}
// Decrement counter at checkcast if the subtype check fails (as template
// interpreter does!).
#define BI_PROFILE_SUBTYPECHECK_FAILED(receiver) \
if (ProfileInterpreter && MDX() != NULL) { \
BI_PROFILE_CHECK_MDX(); \
ReceiverTypeData::increment_receiver_count_no_overflow(MDX(), receiver); \
ReceiverTypeData::decrement_count(MDX()); \
}
// Updates profiling data for a checkcast (was a null seen? which receiver?).
#define BI_PROFILE_UPDATE_CHECKCAST(null_seen, receiver) \
if (ProfileInterpreter && MDX() != NULL) { \
BI_PROFILE_CHECK_MDX(); \
if (null_seen) { \
ReceiverTypeData::set_null_seen(MDX()); \
} else { \
/* Template interpreter doesn't increment count. */ \
/* ReceiverTypeData::increment_count_no_overflow(MDX()); */ \
ReceiverTypeData::increment_receiver_count_no_overflow(MDX(), receiver); \
} \
SET_MDX(ReceiverTypeData::advance(MDX())); \
}
// Updates profiling data for an instanceof (was a null seen? which receiver?).
#define BI_PROFILE_UPDATE_INSTANCEOF(null_seen, receiver) \
BI_PROFILE_UPDATE_CHECKCAST(null_seen, receiver)
// Updates profiling data for a call.
#define BI_PROFILE_UPDATE_CALL() \
if (ProfileInterpreter && MDX() != NULL) { \
BI_PROFILE_CHECK_MDX(); \
CounterData::increment_count_no_overflow(MDX()); \
SET_MDX(CounterData::advance(MDX())); \
}
// Updates profiling data for a final call.
#define BI_PROFILE_UPDATE_FINALCALL() \
if (ProfileInterpreter && MDX() != NULL) { \
BI_PROFILE_CHECK_MDX(); \
VirtualCallData::increment_count_no_overflow(MDX()); \
SET_MDX(VirtualCallData::advance(MDX())); \
}
// Updates profiling data for a virtual call with given receiver Klass.
#define BI_PROFILE_UPDATE_VIRTUALCALL(receiver) \
if (ProfileInterpreter && MDX() != NULL) { \
BI_PROFILE_CHECK_MDX(); \
VirtualCallData::increment_receiver_count_no_overflow(MDX(), receiver); \
SET_MDX(VirtualCallData::advance(MDX())); \
}
// Updates profiling data for a switch (tabelswitch or lookupswitch) with
// given taken index (-1 means default case was taken).
#define BI_PROFILE_UPDATE_SWITCH(switch_index) \
if (ProfileInterpreter && MDX() != NULL) { \
BI_PROFILE_CHECK_MDX(); \
MultiBranchData::increment_count_no_overflow(MDX(), switch_index); \
SET_MDX(MultiBranchData::advance(MDX(), switch_index)); \
}
// The end /////////////////////////////////////////////////////////////////////
#endif // CC_INTERP_PROFILE
#endif // CC_INTERP
#endif // SHARE_VM_INTERPRETER_BYTECODECINTERPRETERPROFILING_HPP

6
src/hotspot/share/oops/methodData.cpp
View File

@ -541,12 +541,6 @@ address RetData::fixup_ret(int return_bci, MethodData* h_mdo) {
return mdp;
}
#ifdef CC_INTERP
DataLayout* RetData::advance(MethodData *md, int bci) {
return (DataLayout*) md->bci_to_dp(bci);
}
#endif // CC_INTERP
void RetData::print_data_on(outputStream* st, const char* extra) const {
print_shared(st, "RetData", extra);
uint row;

190
src/hotspot/share/oops/methodData.hpp
View File

@ -232,11 +232,6 @@ public:
static ByteSize cell_offset(int index) {
return byte_offset_of(DataLayout, _cells) + in_ByteSize(index * cell_size);
}
#ifdef CC_INTERP
static int cell_offset_in_bytes(int index) {
return (int)offset_of(DataLayout, _cells[index]);
}
#endif // CC_INTERP
// Return a value which, when or-ed as a byte into _flags, sets the flag.
static int flag_number_to_byte_constant(int flag_number) {
assert(0 <= flag_number && flag_number < flag_limit, "oob");
@ -372,41 +367,6 @@ protected:
_data = data;
}
#ifdef CC_INTERP
// Static low level accessors for DataLayout with ProfileData's semantics.
static int cell_offset_in_bytes(int index) {
return DataLayout::cell_offset_in_bytes(index);
}
static void increment_uint_at_no_overflow(DataLayout* layout, int index,
int inc = DataLayout::counter_increment) {
uint count = ((uint)layout->cell_at(index)) + inc;
if (count == 0) return;
layout->set_cell_at(index, (intptr_t) count);
}
static int int_at(DataLayout* layout, int index) {
return (int)layout->cell_at(index);
}
static int uint_at(DataLayout* layout, int index) {
return (uint)layout->cell_at(index);
}
static oop oop_at(DataLayout* layout, int index) {
return cast_to_oop(layout->cell_at(index));
}
static void set_intptr_at(DataLayout* layout, int index, intptr_t value) {
layout->set_cell_at(index, (intptr_t) value);
}
static void set_flag_at(DataLayout* layout, int flag_number) {
layout->set_flag_at(flag_number);
}
#endif // CC_INTERP
public:
// Constructor for invalid ProfileData.
ProfileData();
@ -581,20 +541,6 @@ public:
return cell_offset(bit_cell_count);
}
#ifdef CC_INTERP
static int bit_data_size_in_bytes() {
return cell_offset_in_bytes(bit_cell_count);
}
static void set_null_seen(DataLayout* layout) {
set_flag_at(layout, null_seen_flag);
}
static DataLayout* advance(DataLayout* layout) {
return (DataLayout*) (((address)layout) + (ssize_t)BitData::bit_data_size_in_bytes());
}
#endif // CC_INTERP
void print_data_on(outputStream* st, const char* extra = NULL) const;
};
@ -639,25 +585,6 @@ public:
set_uint_at(count_off, count);
}
#ifdef CC_INTERP
static int counter_data_size_in_bytes() {
return cell_offset_in_bytes(counter_cell_count);
}
static void increment_count_no_overflow(DataLayout* layout) {
increment_uint_at_no_overflow(layout, count_off);
}
// Support counter decrementation at checkcast / subtype check failed.
static void decrement_count(DataLayout* layout) {
increment_uint_at_no_overflow(layout, count_off, -1);
}
static DataLayout* advance(DataLayout* layout) {
return (DataLayout*) (((address)layout) + (ssize_t)CounterData::counter_data_size_in_bytes());
}
#endif // CC_INTERP
void print_data_on(outputStream* st, const char* extra = NULL) const;
};
@ -728,20 +655,6 @@ public:
return cell_offset(displacement_off_set);
}
#ifdef CC_INTERP
static void increment_taken_count_no_overflow(DataLayout* layout) {
increment_uint_at_no_overflow(layout, taken_off_set);
}
static DataLayout* advance_taken(DataLayout* layout) {
return (DataLayout*) (((address)layout) + (ssize_t)int_at(layout, displacement_off_set));
}
static uint taken_count(DataLayout* layout) {
return (uint) uint_at(layout, taken_off_set);
}
#endif // CC_INTERP
// Specific initialization.
void post_initialize(BytecodeStream* stream, MethodData* mdo);
@ -1302,43 +1215,6 @@ public:
// GC support
virtual void clean_weak_klass_links(bool always_clean);
#ifdef CC_INTERP
static int receiver_type_data_size_in_bytes() {
return cell_offset_in_bytes(static_cell_count());
}
static Klass *receiver_unchecked(DataLayout* layout, uint row) {
Klass* recv = (Klass*)layout->cell_at(receiver_cell_index(row));
return recv;
}
static void increment_receiver_count_no_overflow(DataLayout* layout, Klass *rcvr) {
const int num_rows = row_limit();
// Receiver already exists?
for (int row = 0; row < num_rows; row++) {
if (receiver_unchecked(layout, row) == rcvr) {
increment_uint_at_no_overflow(layout, receiver_count_cell_index(row));
return;
}
}
// New receiver, find a free slot.
for (int row = 0; row < num_rows; row++) {
if (receiver_unchecked(layout, row) == NULL) {
set_intptr_at(layout, receiver_cell_index(row), (intptr_t)rcvr);
increment_uint_at_no_overflow(layout, receiver_count_cell_index(row));
return;
}
}
// Receiver did not match any saved receiver and there is no empty row for it.
// Increment total counter to indicate polymorphic case.
increment_count_no_overflow(layout);
}
static DataLayout* advance(DataLayout* layout) {
return (DataLayout*) (((address)layout) + (ssize_t)ReceiverTypeData::receiver_type_data_size_in_bytes());
}
#endif // CC_INTERP
void print_receiver_data_on(outputStream* st) const;
void print_data_on(outputStream* st, const char* extra = NULL) const;
};
@ -1371,16 +1247,6 @@ public:
return cell_offset(static_cell_count());
}
#ifdef CC_INTERP
static int virtual_call_data_size_in_bytes() {
return cell_offset_in_bytes(static_cell_count());
}
static DataLayout* advance(DataLayout* layout) {
return (DataLayout*) (((address)layout) + (ssize_t)VirtualCallData::virtual_call_data_size_in_bytes());
}
#endif // CC_INTERP
#if INCLUDE_JVMCI
static ByteSize method_offset(uint row) {
return cell_offset(method_cell_index(row));
@ -1658,10 +1524,6 @@ public:
return cell_offset(bci_displacement_cell_index(row));
}
#ifdef CC_INTERP
static DataLayout* advance(MethodData *md, int bci);
#endif // CC_INTERP
// Specific initialization.
void post_initialize(BytecodeStream* stream, MethodData* mdo);
@ -1726,20 +1588,6 @@ public:
return cell_offset(branch_cell_count);
}
#ifdef CC_INTERP
static int branch_data_size_in_bytes() {
return cell_offset_in_bytes(branch_cell_count);
}
static void increment_not_taken_count_no_overflow(DataLayout* layout) {
increment_uint_at_no_overflow(layout, not_taken_off_set);
}
static DataLayout* advance_not_taken(DataLayout* layout) {
return (DataLayout*) (((address)layout) + (ssize_t)BranchData::branch_data_size_in_bytes());
}
#endif // CC_INTERP
// Specific initialization.
void post_initialize(BytecodeStream* stream, MethodData* mdo);
@ -1779,20 +1627,6 @@ protected:
set_int_at(aindex, value);
}
#ifdef CC_INTERP
// Static low level accessors for DataLayout with ArrayData's semantics.
static void increment_array_uint_at_no_overflow(DataLayout* layout, int index) {
int aindex = index + array_start_off_set;
increment_uint_at_no_overflow(layout, aindex);
}
static int array_int_at(DataLayout* layout, int index) {
int aindex = index + array_start_off_set;
return int_at(layout, aindex);
}
#endif // CC_INTERP
// Code generation support for subclasses.
static ByteSize array_element_offset(int index) {
return cell_offset(array_start_off_set + index);
@ -1913,28 +1747,6 @@ public:
return in_ByteSize(relative_displacement_off_set) * cell_size;
}
#ifdef CC_INTERP
static void increment_count_no_overflow(DataLayout* layout, int index) {
if (index == -1) {
increment_array_uint_at_no_overflow(layout, default_count_off_set);
} else {
increment_array_uint_at_no_overflow(layout, case_array_start +
index * per_case_cell_count +
relative_count_off_set);
}
}
static DataLayout* advance(DataLayout* layout, int index) {
if (index == -1) {
return (DataLayout*) (((address)layout) + (ssize_t)array_int_at(layout, default_disaplacement_off_set));
} else {
return (DataLayout*) (((address)layout) + (ssize_t)array_int_at(layout, case_array_start +
index * per_case_cell_count +
relative_displacement_off_set));
}
}
#endif // CC_INTERP
// Specific initialization.
void post_initialize(BytecodeStream* stream, MethodData* mdo);
@ -2127,13 +1939,11 @@ public:
// adjusted in the event of a change in control flow.
//
CC_INTERP_ONLY(class BytecodeInterpreter;)
class CleanExtraDataClosure;
class MethodData : public Metadata {
friend class VMStructs;
friend class JVMCIVMStructs;
CC_INTERP_ONLY(friend class BytecodeInterpreter;)
private:
friend class ProfileData;
friend class TypeEntriesAtCall;