infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-03-15 10:23:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

8297864: Dead code elimination

Browse Source 
Reviewed-by: coleenp, pchilanomate
This commit is contained in:
Robbin Ehn 2022-12-05 10:31:35 +00:00
parent 777fb52ef5
commit d523d9d081
100 changed files with 11 additions and 1058 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/hotspot/cpu/aarch64/continuationFreezeThaw_aarch64.inline.hpp
View File

@ -196,11 +196,6 @@ inline void ThawBase::prefetch_chunk_pd(void* start, int size) {
Prefetch::read(start, size - 64);
}
void ThawBase::patch_chunk_pd(intptr_t* sp) {
intptr_t* fp = _cont.entryFP();
*(intptr_t**)(sp - frame::sender_sp_offset) = fp;
}
template <typename ConfigT>
inline void Thaw<ConfigT>::patch_caller_links(intptr_t* sp, intptr_t* bottom) {
// Fast path depends on !PreserveFramePointer. See can_thaw_fast().

6
src/hotspot/cpu/aarch64/stackChunkFrameStream_aarch64.inline.hpp
View File

@ -76,12 +76,6 @@ inline intptr_t* StackChunkFrameStream<frame_kind>::unextended_sp_for_interprete
return derelativize(frame::interpreter_frame_last_sp_offset);
}
template <ChunkFrames frame_kind>
intptr_t* StackChunkFrameStream<frame_kind>::next_sp_for_interpreter_frame() const {
assert_is_interpreted_and_frame_type_mixed();
return (derelativize(frame::interpreter_frame_locals_offset) + 1 >= _end) ? _end : fp() + frame::sender_sp_offset;
}
template <ChunkFrames frame_kind>
inline void StackChunkFrameStream<frame_kind>::next_for_interpreter_frame() {
assert_is_interpreted_and_frame_type_mixed();

4
src/hotspot/cpu/arm/continuationFreezeThaw_arm.inline.hpp
View File

@ -87,10 +87,6 @@ inline void ThawBase::patch_pd(frame& f, const frame& caller) {
Unimplemented();
}
void ThawBase::patch_chunk_pd(intptr_t* sp) {
Unimplemented();
}
template <typename ConfigT>
inline void Thaw<ConfigT>::patch_caller_links(intptr_t* sp, intptr_t* bottom) {
Unimplemented();

6
src/hotspot/cpu/arm/stackChunkFrameStream_arm.inline.hpp
View File

@ -67,12 +67,6 @@ inline intptr_t* StackChunkFrameStream<frame_kind>::unextended_sp_for_interprete
return NULL;
}
template <ChunkFrames frame_kind>
intptr_t* StackChunkFrameStream<frame_kind>::next_sp_for_interpreter_frame() const {
Unimplemented();
return NULL;
}
template <ChunkFrames frame_kind>
inline void StackChunkFrameStream<frame_kind>::next_for_interpreter_frame() {
Unimplemented();

6
src/hotspot/cpu/ppc/stackChunkFrameStream_ppc.inline.hpp
View File

@ -80,12 +80,6 @@ inline intptr_t* StackChunkFrameStream<frame_kind>::unextended_sp_for_interprete
return derelativize(ijava_idx(esp)) + 1 - frame::metadata_words; // On PPC esp points to the next free slot
}
template <ChunkFrames frame_kind>
intptr_t* StackChunkFrameStream<frame_kind>::next_sp_for_interpreter_frame() const {
Unimplemented();
return NULL;
}
template <ChunkFrames frame_kind>
inline void StackChunkFrameStream<frame_kind>::next_for_interpreter_frame() {
assert_is_interpreted_and_frame_type_mixed();

5
src/hotspot/cpu/riscv/continuationFreezeThaw_riscv.inline.hpp
View File

@ -199,11 +199,6 @@ inline void ThawBase::prefetch_chunk_pd(void* start, int size) {
Prefetch::read(start, size - 64);
}
void ThawBase::patch_chunk_pd(intptr_t* sp) {
intptr_t* fp = _cont.entryFP();
*(intptr_t**)(sp - 2) = fp;
}
template <typename ConfigT>
inline void Thaw<ConfigT>::patch_caller_links(intptr_t* sp, intptr_t* bottom) {
// Fast path depends on !PreserveFramePointer. See can_thaw_fast().

6
src/hotspot/cpu/riscv/stackChunkFrameStream_riscv.inline.hpp
View File

@ -76,12 +76,6 @@ inline intptr_t* StackChunkFrameStream<frame_kind>::unextended_sp_for_interprete
return derelativize(frame::interpreter_frame_last_sp_offset);
}
template <ChunkFrames frame_kind>
intptr_t* StackChunkFrameStream<frame_kind>::next_sp_for_interpreter_frame() const {
assert_is_interpreted_and_frame_type_mixed();
return (derelativize(frame::interpreter_frame_locals_offset) + 1 >= _end) ? _end : fp() + frame::sender_sp_offset;
}
template <ChunkFrames frame_kind>
inline void StackChunkFrameStream<frame_kind>::next_for_interpreter_frame() {
assert_is_interpreted_and_frame_type_mixed();

4
src/hotspot/cpu/s390/continuationFreezeThaw_s390.inline.hpp
View File

@ -87,10 +87,6 @@ inline void ThawBase::patch_pd(frame& f, const frame& caller) {
Unimplemented();
}
void ThawBase::patch_chunk_pd(intptr_t* sp) {
Unimplemented();
}
template <typename ConfigT>
inline void Thaw<ConfigT>::patch_caller_links(intptr_t* sp, intptr_t* bottom) {
Unimplemented();

6
src/hotspot/cpu/s390/stackChunkFrameStream_s390.inline.hpp
View File

@ -67,12 +67,6 @@ inline intptr_t* StackChunkFrameStream<frame_kind>::unextended_sp_for_interprete
return NULL;
}
template <ChunkFrames frame_kind>
intptr_t* StackChunkFrameStream<frame_kind>::next_sp_for_interpreter_frame() const {
Unimplemented();
return NULL;
}
template <ChunkFrames frame_kind>
inline void StackChunkFrameStream<frame_kind>::next_for_interpreter_frame() {
Unimplemented();

5
src/hotspot/cpu/x86/continuationFreezeThaw_x86.inline.hpp
View File

@ -199,11 +199,6 @@ inline void Thaw<ConfigT>::patch_caller_links(intptr_t* sp, intptr_t* bottom) {
assert(!PreserveFramePointer, "Frame pointers need to be fixed");
}
void ThawBase::patch_chunk_pd(intptr_t* sp) {
intptr_t* fp = _cont.entryFP();
*(intptr_t**)(sp - frame::sender_sp_offset) = fp;
}
// Slow path
inline frame ThawBase::new_entry_frame() {

6
src/hotspot/cpu/x86/stackChunkFrameStream_x86.inline.hpp
View File

@ -76,12 +76,6 @@ inline intptr_t* StackChunkFrameStream<frame_kind>::unextended_sp_for_interprete
return derelativize(frame::interpreter_frame_last_sp_offset);
}
template <ChunkFrames frame_kind>
intptr_t* StackChunkFrameStream<frame_kind>::next_sp_for_interpreter_frame() const {
assert_is_interpreted_and_frame_type_mixed();
return (derelativize(frame::interpreter_frame_locals_offset) + 1 >= _end) ? _end : fp() + frame::sender_sp_offset;
}
template <ChunkFrames frame_kind>
inline void StackChunkFrameStream<frame_kind>::next_for_interpreter_frame() {
assert_is_interpreted_and_frame_type_mixed();

4
src/hotspot/cpu/zero/continuationFreezeThaw_zero.inline.hpp
View File

@ -87,10 +87,6 @@ inline void ThawBase::patch_pd(frame& f, const frame& caller) {
Unimplemented();
}
void ThawBase::patch_chunk_pd(intptr_t* sp) {
Unimplemented();
}
template <typename ConfigT>
inline void Thaw<ConfigT>::patch_caller_links(intptr_t* sp, intptr_t* bottom) {
Unimplemented();

6
src/hotspot/cpu/zero/stackChunkFrameStream_zero.inline.hpp
View File

@ -67,12 +67,6 @@ inline intptr_t* StackChunkFrameStream<frame_kind>::unextended_sp_for_interprete
return NULL;
}
template <ChunkFrames frame_kind>
intptr_t* StackChunkFrameStream<frame_kind>::next_sp_for_interpreter_frame() const {
Unimplemented();
return NULL;
}
template <ChunkFrames frame_kind>
inline void StackChunkFrameStream<frame_kind>::next_for_interpreter_frame() {
Unimplemented();

3
src/hotspot/cpu/zero/stubGenerator_zero.cpp
View File

@ -191,12 +191,9 @@ class StubGenerator: public StubCodeGenerator {
// atomic calls
StubRoutines::_atomic_xchg_entry = ShouldNotCallThisStub();
StubRoutines::_atomic_xchg_long_entry = ShouldNotCallThisStub();
StubRoutines::_atomic_cmpxchg_entry = ShouldNotCallThisStub();
StubRoutines::_atomic_cmpxchg_byte_entry = ShouldNotCallThisStub();
StubRoutines::_atomic_cmpxchg_long_entry = ShouldNotCallThisStub();
StubRoutines::_atomic_add_entry = ShouldNotCallThisStub();
StubRoutines::_atomic_add_long_entry = ShouldNotCallThisStub();
StubRoutines::_fence_entry = ShouldNotCallThisStub();
}

4
src/hotspot/share/prims/forte.cpp
View File

@ -606,9 +606,6 @@ void AsyncGetCallTrace(ASGCT_CallTrace *trace, jint depth, void* ucontext) {
return;
}
// !important! make sure all to call thread->set_in_asgct(false) before every return
thread->set_in_asgct(true);
switch (thread->thread_state()) {
case _thread_new:
case _thread_uninitialized:
@ -666,7 +663,6 @@ void AsyncGetCallTrace(ASGCT_CallTrace *trace, jint depth, void* ucontext) {
trace->num_frames = ticks_unknown_state; // -7
break;
}
thread->set_in_asgct(false);
}

11
src/hotspot/share/runtime/abstract_vm_version.cpp
View File

@ -161,13 +161,6 @@ const char* Abstract_VM_Version::vm_release() {
return VM_RELEASE;
}
// NOTE: do *not* use stringStream. this function is called by
// fatal error handlers. if the crash is in native thread,
// stringStream cannot get resource allocated and will SEGV.
const char* Abstract_VM_Version::jre_release_version() {
return VERSION_STRING;
}
#define OS LINUX_ONLY("linux") \
WINDOWS_ONLY("windows") \
AIX_ONLY("aix") \
@ -281,10 +274,6 @@ const char* Abstract_VM_Version::internal_vm_info_string() {
: VMNAME " (" DEBUG_LEVEL " " INTERNAL_VERSION_SUFFIX;
}
const char *Abstract_VM_Version::vm_build_user() {
return HOTSPOT_BUILD_USER;
}
const char *Abstract_VM_Version::jdk_debug_level() {
return DEBUG_LEVEL;
}

8
src/hotspot/share/runtime/abstract_vm_version.hpp
View File

@ -102,7 +102,6 @@ class Abstract_VM_Version: AllStatic {
static const char* vm_info_string();
static const char* vm_release();
static const char* vm_platform_string();
static const char* vm_build_user();
static int vm_major_version() { return _vm_major_version; }
static int vm_minor_version() { return _vm_minor_version; }
@ -115,7 +114,6 @@ class Abstract_VM_Version: AllStatic {
// Internal version providing additional build information
static const char* internal_vm_info_string();
static const char* jre_release_version();
static const char* jdk_debug_level();
static const char* printable_jdk_debug_level();
@ -166,12 +164,6 @@ class Abstract_VM_Version: AllStatic {
return _data_cache_line_flush_size != 0;
}
// Number of page sizes efficiently supported by the hardware. Most chips now
// support two sizes, thus this default implementation. Processor-specific
// subclasses should define new versions to hide this one as needed. Note
// that the O/S may support more sizes, but at most this many are used.
static uint page_size_count() { return 2; }
// Denominator for computing default ParallelGCThreads for machines with
// a large number of cores.
static uint parallel_worker_threads_denominator() { return 8; }

32
src/hotspot/share/runtime/arguments.cpp
View File

@ -4163,38 +4163,6 @@ const char* Arguments::PropertyList_get_readable_value(SystemProperty *pl, const
return NULL;
}
const char* Arguments::PropertyList_get_key_at(SystemProperty *pl, int index) {
int count = 0;
const char* ret_val = NULL;
while(pl != NULL) {
if(count >= index) {
ret_val = pl->key();
break;
}
count++;
pl = pl->next();
}
return ret_val;
}
char* Arguments::PropertyList_get_value_at(SystemProperty* pl, int index) {
int count = 0;
char* ret_val = NULL;
while(pl != NULL) {
if(count >= index) {
ret_val = pl->value();
break;
}
count++;
pl = pl->next();
}
return ret_val;
}
void Arguments::PropertyList_add(SystemProperty** plist, SystemProperty *new_p) {
SystemProperty* p = *plist;
if (p == NULL) {

6
src/hotspot/share/runtime/arguments.hpp
View File

@ -86,7 +86,6 @@ public:
ModulePatchPath(const char* module_name, const char* path);
~ModulePatchPath();
inline void set_path(const char* path) { _path->set_value(path); }
inline const char* module_name() const { return _module_name; }
inline char* path_string() const { return _path->value(); }
};
@ -174,7 +173,6 @@ public:
void set_static_lib(bool is_static_lib) { _is_static_lib = is_static_lib; }
bool valid() { return (_state == agent_valid); }
void set_valid() { _state = agent_valid; }
void set_invalid() { _state = agent_invalid; }
// Constructor
AgentLibrary(const char* name, const char* options, bool is_absolute_path,
@ -592,8 +590,6 @@ class Arguments : AllStatic {
static const char* PropertyList_get_readable_value(SystemProperty* plist, const char* key);
static int PropertyList_count(SystemProperty* pl);
static int PropertyList_readable_count(SystemProperty* pl);
static const char* PropertyList_get_key_at(SystemProperty* pl,int index);
static char* PropertyList_get_value_at(SystemProperty* pl,int index);
static bool is_internal_module_property(const char* option);
@ -618,12 +614,10 @@ class Arguments : AllStatic {
static GrowableArray<ModulePatchPath*>* get_patch_mod_prefix() { return _patch_mod_prefix; }
static char* get_boot_class_path() { return _boot_class_path->value(); }
static char* get_jdk_boot_class_path_append() { return _jdk_boot_class_path_append->value(); }
static bool has_jimage() { return _has_jimage; }
static char* get_java_home() { return _java_home->value(); }
static char* get_dll_dir() { return _sun_boot_library_path->value(); }
static char* get_ext_dirs() { return _ext_dirs; }
static char* get_appclasspath() { return _java_class_path->value(); }
static void fix_appclasspath();

2
src/hotspot/share/runtime/continuationEntry.hpp
View File

@ -103,8 +103,6 @@ public:
static address compiled_entry();
static address interpreted_entry();
static CompiledMethod* enter_special() { return _enter_special; }
int argsize() const { return _argsize; }
void set_argsize(int value) { _argsize = value; }

5
src/hotspot/share/runtime/continuationFreezeThaw.cpp
View File

@ -388,7 +388,6 @@ public:
protected:
inline void init_rest();
void freeze_fast_init_cont_data(intptr_t* frame_sp);
void throw_stack_overflow_on_humongous_chunk();
// fast path
@ -1721,7 +1720,6 @@ protected:
// fast path
inline void prefetch_chunk_pd(void* start, int size_words);
void patch_return(intptr_t* sp, bool is_last);
void patch_chunk_pd(intptr_t* sp); // TODO remove
// slow path
NOINLINE intptr_t* thaw_slow(stackChunkOop chunk, bool return_barrier);
@ -1803,8 +1801,6 @@ public:
assert(_base - 1 <= top() + total_size() + frame::metadata_words_at_bottom, "missed entry frame");
}
int thaw_size() const { return _thaw_size; }
int argsize() const { return _argsize; }
int entry_frame_extension() const { return _argsize + (_argsize > 0 ? frame::metadata_words_at_top : 0); }
// top and bottom stack pointers
@ -1865,7 +1861,6 @@ void ThawBase::patch_return(intptr_t* sp, bool is_last) {
address pc = !is_last ? StubRoutines::cont_returnBarrier() : _cont.entryPC();
*(address*)(sp - frame::sender_sp_ret_address_offset()) = pc;
// patch_chunk_pd(sp); -- TODO: If not needed - remove method; it's not used elsewhere
}
template <typename ConfigT>

8
src/hotspot/share/runtime/continuationHelper.hpp
View File

@ -75,10 +75,6 @@ public:
static inline intptr_t* frame_top(const frame &f);
static inline bool is_deopt_return(address pc, const frame& sender);
static bool assert_frame_laid_out(frame f);
static char* method_name(Method* m) { return m != nullptr ? m->name_and_sig_as_C_string() : nullptr; }
static Method* top_java_frame_method(const frame& f);
static Method* bottom_java_frame_method(const frame& f) { return frame_method(f); }
#endif
};
@ -97,7 +93,6 @@ public:
static address return_pc(const frame& f);
static void patch_sender_sp(frame& f, const frame& caller);
static int size(const frame& f, InterpreterOopMap* mask);
static int size(const frame& f);
static inline int expression_stack_size(const frame &f, InterpreterOopMap* mask);
@ -118,7 +113,6 @@ public:
static inline int size(const frame& f);
static inline int stack_argsize(const frame& f);
static inline int num_oops(const frame& f);
};
class ContinuationHelper::NonInterpretedUnknownFrame : public ContinuationHelper::NonInterpretedFrame {
@ -128,8 +122,6 @@ public:
class ContinuationHelper::CompiledFrame : public ContinuationHelper::NonInterpretedFrame {
public:
static inline int num_oops(const frame& f);
static bool is_instance(const frame& f);
#ifdef ASSERT

29
src/hotspot/share/runtime/continuationHelper.inline.hpp
View File

@ -61,21 +61,6 @@ inline intptr_t* ContinuationHelper::Frame::frame_top(const frame &f) {
}
}
inline Method* ContinuationHelper::Frame::top_java_frame_method(const frame& f) {
Method* m = nullptr;
if (f.is_interpreted_frame()) {
m = f.interpreter_frame_method();
} else if (f.is_compiled_frame()) {
CompiledMethod* cm = f.cb()->as_compiled_method();
ScopeDesc* scope = cm->scope_desc_at(f.pc());
m = scope->method();
} else if (f.is_native_frame()) {
m = f.cb()->as_nmethod()->method();
}
return m;
}
inline bool ContinuationHelper::Frame::is_deopt_return(address pc, const frame& sender) {
if (sender.is_interpreted_frame()) return false;
@ -131,10 +116,6 @@ inline intptr_t* ContinuationHelper::InterpretedFrame::frame_top(const frame& f)
return f.unextended_sp();
}
inline int ContinuationHelper::InterpretedFrame::size(const frame&f, InterpreterOopMap* mask) {
return InterpretedFrame::frame_bottom(f) - InterpretedFrame::frame_top(f, mask);
}
inline intptr_t* ContinuationHelper::NonInterpretedFrame::frame_top(const frame& f, int callee_argsize, bool callee_interpreted) {
return f.unextended_sp() + (callee_interpreted ? 0 : callee_argsize);
}
@ -156,20 +137,10 @@ inline int ContinuationHelper::NonInterpretedFrame::stack_argsize(const frame& f
return f.compiled_frame_stack_argsize();
}
inline int ContinuationHelper::NonInterpretedFrame::num_oops(const frame& f) {
assert(!f.is_interpreted_frame(), "");
return f.num_oops();
}
inline bool ContinuationHelper::CompiledFrame::is_instance(const frame& f) {
return f.is_compiled_frame();
}
inline int ContinuationHelper::CompiledFrame::num_oops(const frame& f) {
assert(CompiledFrame::is_instance(f), "Not a compiled frame");
return f.num_oops() + 1;
}
#ifdef ASSERT
template<typename RegisterMapT>
bool ContinuationHelper::CompiledFrame::is_owning_locks(JavaThread* thread, RegisterMapT* map, const frame& f) {

18
src/hotspot/share/runtime/continuationJavaClasses.hpp
View File

@ -41,8 +41,6 @@ class jdk_internal_vm_ContinuationScope: AllStatic {
static void compute_offsets();
public:
static void serialize_offsets(SerializeClosure* f) NOT_CDS_RETURN;
static inline oop name(oop ref);
};
// Interface to jdk.internal.vm.Continuation objects
@ -63,13 +61,9 @@ class jdk_internal_vm_Continuation: AllStatic {
static void serialize_offsets(SerializeClosure* f) NOT_CDS_RETURN;
// Accessors
static inline oop scope(oop continuation);
static inline oop target(oop continuation);
static inline oop parent(oop continuation);
static inline oop yieldInfo(oop continuation);
static inline void set_yieldInfo(oop continuation, oop value);
static inline stackChunkOop tail(oop continuation);
static inline void set_tail(oop continuation, stackChunkOop value);
static inline bool on_local_stack(oop continuation, address adr);
static inline bool done(oop continuation);
static inline bool is_preempted(oop continuation);
static inline void set_preempted(oop continuation, bool value);
@ -130,12 +124,12 @@ class jdk_internal_vm_StackChunk: AllStatic {
static inline void set_maxThawingSize(oop chunk, int value);
// cont oop's processing is essential for the chunk's GC protocol
static inline oop cont(oop chunk);
static inline void set_cont(oop chunk, oop value);
template<typename P>
static inline void set_cont_raw(oop chunk, oop value);
template<DecoratorSet decorators>
static inline void set_cont_access(oop chunk, oop value);
static inline oop cont(oop chunk);
static inline void set_cont(oop chunk, oop value);
template<typename P>
static inline void set_cont_raw(oop chunk, oop value);
template<DecoratorSet decorators>
static inline void set_cont_access(oop chunk, oop value);
};
#endif // SHARE_RUNTIME_CONTINUATIONJAVACLASSES_HPP

16
src/hotspot/share/runtime/continuationJavaClasses.inline.hpp
View File

@ -33,30 +33,14 @@
#include "oops/stackChunkOop.inline.hpp"
#include "runtime/atomic.hpp"
inline oop jdk_internal_vm_ContinuationScope::name(oop ref) {
return ref->obj_field(_name_offset);
}
inline oop jdk_internal_vm_Continuation::scope(oop continuation) {
return continuation->obj_field(_scope_offset);
}
inline oop jdk_internal_vm_Continuation::target(oop continuation) {
return continuation->obj_field(_target_offset);
}
inline oop jdk_internal_vm_Continuation::parent(oop continuation) {
return continuation->obj_field(_parent_offset);
}
inline oop jdk_internal_vm_Continuation::yieldInfo(oop continuation) {
return continuation->obj_field(_yieldInfo_offset);
}
inline void jdk_internal_vm_Continuation::set_yieldInfo(oop continuation, oop value) {
continuation->obj_field_put(_yieldInfo_offset, value);
}
inline stackChunkOop jdk_internal_vm_Continuation::tail(oop continuation) {
return stackChunkOopDesc::cast(continuation->obj_field(_tail_offset));
}

10
src/hotspot/share/runtime/continuationWrapper.inline.hpp
View File

@ -111,9 +111,7 @@ public:
stackChunkOop tail() const { return _tail; }
void set_tail(stackChunkOop chunk) { _tail = chunk; }
inline oop parent();
inline bool is_preempted();
inline void set_preempted(bool value);
inline void read();
inline void write();
@ -162,18 +160,10 @@ inline ContinuationWrapper::ContinuationWrapper(oop continuation)
read();
}
inline oop ContinuationWrapper::parent() {
return jdk_internal_vm_Continuation::parent(_continuation);
}
inline bool ContinuationWrapper::is_preempted() {
return jdk_internal_vm_Continuation::is_preempted(_continuation);
}
inline void ContinuationWrapper::set_preempted(bool value) {
jdk_internal_vm_Continuation::set_preempted(_continuation, value);
}
inline void ContinuationWrapper::read() {
_tail = jdk_internal_vm_Continuation::tail(_continuation);
}

15
src/hotspot/share/runtime/deoptimization.cpp
View File

@ -98,8 +98,6 @@
#include "jfr/metadata/jfrSerializer.hpp"
#endif
bool DeoptimizationMarker::_is_active = false;
Deoptimization::UnrollBlock::UnrollBlock(int size_of_deoptimized_frame,
int caller_adjustment,
int caller_actual_parameters,
@ -126,21 +124,12 @@ Deoptimization::UnrollBlock::UnrollBlock(int size_of_deoptimized_frame,
assert(exec_mode >= 0 && exec_mode < Unpack_LIMIT, "Unexpected exec_mode");
}
Deoptimization::UnrollBlock::~UnrollBlock() {
FREE_C_HEAP_ARRAY(intptr_t, _frame_sizes);
FREE_C_HEAP_ARRAY(intptr_t, _frame_pcs);
FREE_C_HEAP_ARRAY(intptr_t, _register_block);
}
intptr_t* Deoptimization::UnrollBlock::value_addr_at(int register_number) const {
assert(register_number < RegisterMap::reg_count, "checking register number");
return &_register_block[register_number * 2];
}
int Deoptimization::UnrollBlock::size_of_frames() const {
// Account first for the adjustment of the initial frame
int result = _caller_adjustment;
@ -150,7 +139,6 @@ int Deoptimization::UnrollBlock::size_of_frames() const {
return result;
}
void Deoptimization::UnrollBlock::print() {
ResourceMark rm;
stringStream st;
@ -164,7 +152,6 @@ void Deoptimization::UnrollBlock::print() {
tty->print_raw(st.freeze());
}
// In order to make fetch_unroll_info work properly with escape
// analysis, the method was changed from JRT_LEAF to JRT_BLOCK_ENTRY.
// The actual reallocation of previously eliminated objects occurs in realloc_objects,
@ -933,7 +920,6 @@ class DeoptimizeMarkedClosure : public HandshakeClosure {
void Deoptimization::deoptimize_all_marked(nmethod* nmethod_only) {
ResourceMark rm;
DeoptimizationMarker dm;
// Make the dependent methods not entrant
if (nmethod_only != NULL) {
@ -1655,7 +1641,6 @@ void Deoptimization::deoptimize(JavaThread* thread, frame fr, DeoptReason reason
return;
}
ResourceMark rm;
DeoptimizationMarker dm;
deoptimize_single_frame(thread, fr, reason);
}

16
src/hotspot/share/runtime/deoptimization.hpp
View File

@ -227,14 +227,9 @@ class Deoptimization : AllStatic {
int unpack_kind);
~UnrollBlock();
// Returns where a register is located.
intptr_t* value_addr_at(int register_number) const;
// Accessors
intptr_t* frame_sizes() const { return _frame_sizes; }
int number_of_frames() const { return _number_of_frames; }
address* frame_pcs() const { return _frame_pcs ; }
int unpack_kind() const { return _unpack_kind; }
// Returns the total size of frames
int size_of_frames() const;
@ -250,8 +245,6 @@ class Deoptimization : AllStatic {
static int frame_sizes_offset_in_bytes() { return offset_of(UnrollBlock, _frame_sizes); }
static int total_frame_sizes_offset_in_bytes() { return offset_of(UnrollBlock, _total_frame_sizes); }
static int frame_pcs_offset_in_bytes() { return offset_of(UnrollBlock, _frame_pcs); }
static int register_block_offset_in_bytes() { return offset_of(UnrollBlock, _register_block); }
static int return_type_offset_in_bytes() { return offset_of(UnrollBlock, _return_type); }
static int counter_temp_offset_in_bytes() { return offset_of(UnrollBlock, _counter_temp); }
static int initial_info_offset_in_bytes() { return offset_of(UnrollBlock, _initial_info); }
static int unpack_kind_offset_in_bytes() { return offset_of(UnrollBlock, _unpack_kind); }
@ -473,13 +466,4 @@ class Deoptimization : AllStatic {
static void update_method_data_from_interpreter(MethodData* trap_mdo, int trap_bci, int reason);
};
class DeoptimizationMarker : StackObj { // for profiling
static bool _is_active;
public:
DeoptimizationMarker() { _is_active = true; }
~DeoptimizationMarker() { _is_active = false; }
static bool is_active() { return _is_active; }
};
#endif // SHARE_RUNTIME_DEOPTIMIZATION_HPP

2
src/hotspot/share/runtime/escapeBarrier.hpp
View File

@ -120,8 +120,6 @@ public:
// Returns true iff objects were reallocated and relocked because of access through JVMTI.
static bool objs_are_deoptimized(JavaThread* thread, intptr_t* fr_id);
static bool deoptimizing_objects_for_all_threads() { return _deoptimizing_objects_for_all_threads; }
~EscapeBarrier() {
if (!barrier_active()) return;
if (all_threads()) {

5
src/hotspot/share/runtime/fieldDescriptor.cpp
View File

@ -35,11 +35,6 @@
#include "runtime/handles.inline.hpp"
#include "runtime/signature.hpp"
oop fieldDescriptor::loader() const {
return _cp->pool_holder()->class_loader();
}
Symbol* fieldDescriptor::generic_signature() const {
if (!has_generic_signature()) {
return NULL;

5
src/hotspot/share/runtime/fieldDescriptor.hpp
View File

@ -61,7 +61,6 @@ class fieldDescriptor {
inline ConstantPool* constants() const;
AccessFlags access_flags() const { return _access_flags; }
oop loader() const;
// Offset (in bytes) of field from start of instanceOop / Klass*
inline int offset() const;
Symbol* generic_signature() const;
@ -83,16 +82,12 @@ class fieldDescriptor {
inline BasicType field_type() const;
// Access flags
bool is_public() const { return access_flags().is_public(); }
bool is_private() const { return access_flags().is_private(); }
bool is_protected() const { return access_flags().is_protected(); }
bool is_package_private() const { return !is_public() && !is_private() && !is_protected(); }
bool is_static() const { return access_flags().is_static(); }
bool is_final() const { return access_flags().is_final(); }
bool is_stable() const { return access_flags().is_stable(); }
bool is_volatile() const { return access_flags().is_volatile(); }
bool is_transient() const { return access_flags().is_transient(); }
bool is_synthetic() const { return access_flags().is_synthetic(); }

2
src/hotspot/share/runtime/frame.cpp
View File

@ -773,8 +773,6 @@ class InterpreterFrameClosure : public OffsetClosure {
}
}
}
int max_locals() { return _max_locals; }
};

19
src/hotspot/share/runtime/frame.hpp
View File

@ -210,9 +210,6 @@ class frame {
// the frame size in machine words
inline int frame_size() const;
// the number of oops in the frame for non-interpreted frames
inline int num_oops() const;
// the size, in words, of stack-passed arguments
inline int compiled_frame_stack_argsize() const;
@ -235,7 +232,6 @@ class frame {
inline frame sender_for_compiled_frame(RegisterMap* map) const;
frame sender_for_entry_frame(RegisterMap* map) const;
frame sender_for_interpreter_frame(RegisterMap* map) const;
frame sender_for_native_frame(RegisterMap* map) const;
frame sender_for_upcall_stub_frame(RegisterMap* map) const;
bool is_entry_frame_valid(JavaThread* thread) const;
@ -255,20 +251,6 @@ class frame {
return _on_heap ? at_relative(index) : at_absolute(index);
}
// accessors for locals
oop obj_at(int offset) const { return *obj_at_addr(offset); }
void obj_at_put(int offset, oop value) { *obj_at_addr(offset) = value; }
jint int_at(int offset) const { return *int_at_addr(offset); }
void int_at_put(int offset, jint value) { *int_at_addr(offset) = value; }
oop* obj_at_addr(int offset) const { return (oop*) addr_at(offset); }
oop* adjusted_obj_at_addr(Method* method, int index) { return obj_at_addr(adjust_offset(method, index)); }
private:
jint* int_at_addr(int offset) const { return (jint*) addr_at(offset); }
public:
// Link (i.e., the pointer to the previous frame)
// might crash if the frame has no parent
@ -465,7 +447,6 @@ class frame {
void oops_code_blob_do(OopClosure* f, CodeBlobClosure* cf,
DerivedOopClosure* df, DerivedPointerIterationMode derived_mode,
const RegisterMap* map) const;
int adjust_offset(Method* method, int index); // helper for above fn
public:
// Memory management
void oops_do(OopClosure* f, CodeBlobClosure* cf, const RegisterMap* map) {

7
src/hotspot/share/runtime/frame.inline.hpp
View File

@ -104,11 +104,4 @@ inline CodeBlob* frame::get_cb() const {
return _cb;
}
inline int frame::num_oops() const {
assert(!is_interpreted_frame(), "interpreted");
assert(oop_map() != NULL, "");
return oop_map()->num_oops() ;
}
#endif // SHARE_RUNTIME_FRAME_INLINE_HPP

3
src/hotspot/share/runtime/handles.hpp
View File

@ -213,9 +213,6 @@ class HandleArea: public Arena {
// Garbage collection support
void oops_do(OopClosure* f);
// Number of handles in use
size_t used() const { return Arena::used() / oopSize; }
debug_only(bool no_handle_mark_active() { return _no_handle_mark_nesting > 0; })
};

9
src/hotspot/share/runtime/java.hpp
View File

@ -126,15 +126,6 @@ class JDK_Version {
// Performs a full ordering comparison using all fields (patch, build, etc.)
int compare(const JDK_Version& other) const;
/**
* Performs comparison using only the major version, returning negative
* if the major version of 'this' is less than the parameter, 0 if it is
* equal, and a positive value if it is greater.
*/
int compare_major(int version) const {
return major_version() - version;
}
void to_string(char* buffer, size_t buflen) const;
static const char* java_version() {

2
src/hotspot/share/runtime/javaCalls.hpp
View File

@ -57,7 +57,6 @@ class JavaCallWrapper: StackObj {
~JavaCallWrapper();
// Accessors
JavaThread* thread() const { return _thread; }
JNIHandleBlock* handles() const { return _handles; }
JavaFrameAnchor* anchor(void) { return &_anchor; }
@ -65,7 +64,6 @@ class JavaCallWrapper: StackObj {
JavaValue* result() const { return _result; }
// GC support
Method* callee_method() { return _callee_method; }
oop receiver() { return _receiver; }
void oops_do(OopClosure* f);
bool is_first_frame() const { return _anchor.last_Java_sp() == NULL; }

34
src/hotspot/share/runtime/javaThread.cpp
View File

@ -383,7 +383,6 @@ void JavaThread::check_for_valid_safepoint_state() {
JavaThread::JavaThread() :
// Initialize fields
_in_asgct(false),
_on_thread_list(false),
DEBUG_ONLY(_java_call_counter(0) COMMA)
_entry_point(nullptr),
@ -981,30 +980,6 @@ bool JavaThread::is_lock_owned(address adr) const {
return false;
}
bool JavaThread::is_lock_owned_current(address adr) const {
address stack_end = _stack_base - _stack_size;
const ContinuationEntry* ce = vthread_continuation();
address stack_base = ce != nullptr ? (address)ce->entry_sp() : _stack_base;
if (stack_base > adr && adr >= stack_end) {
return true;
}
for (MonitorChunk* chunk = monitor_chunks(); chunk != NULL; chunk = chunk->next()) {
if (chunk->contains(adr)) {
return true;
}
}
return false;
}
bool JavaThread::is_lock_owned_carrier(address adr) const {
assert(is_vthread_mounted(), "");
address stack_end = _stack_base - _stack_size;
address stack_base = (address)vthread_continuation()->entry_sp();
return stack_base > adr && adr >= stack_end;
}
oop JavaThread::exception_oop() const {
return Atomic::load(&_exception_oop);
}
@ -1471,10 +1446,6 @@ void JavaThread::print_thread_state_on(outputStream *st) const {
st->print_cr(" JavaThread state: %s", _get_thread_state_name(_thread_state));
}
const char* JavaThread::thread_state_name() const {
return _get_thread_state_name(_thread_state);
}
// Called by Threads::print() for VM_PrintThreads operation
void JavaThread::print_on(outputStream *st, bool print_extended_info) const {
st->print_raw("\"");
@ -1909,11 +1880,6 @@ javaVFrame* JavaThread::last_java_vframe(const frame f, RegisterMap *reg_map) {
return NULL;
}
oop JavaThread::get_continuation() const {
assert(threadObj() != nullptr, "must be set");
return java_lang_Thread::continuation(threadObj());
}
Klass* JavaThread::security_get_caller_class(int depth) {
ResetNoHandleMark rnhm;
HandleMark hm(Thread::current());

26
src/hotspot/share/runtime/javaThread.hpp
View File

@ -84,7 +84,6 @@ class JavaThread: public Thread {
friend class Threads;
friend class ServiceThread; // for deferred OopHandle release access
private:
bool _in_asgct; // Is set when this JavaThread is handling ASGCT call
bool _on_thread_list; // Is set when this JavaThread is added to the Threads list
// All references to Java objects managed via OopHandles. These
@ -469,11 +468,6 @@ private:
public:
inline StackWatermarks* stack_watermarks() { return &_stack_watermarks; }
public:
jlong _extentLocal_hash_table_shift;
void allocate_extentLocal_hash_table(int count);
public:
// Constructor
JavaThread(); // delegating constructor
@ -595,7 +589,6 @@ private:
void set_requires_cross_modify_fence(bool val) PRODUCT_RETURN NOT_PRODUCT({ _requires_cross_modify_fence = val; })
// Continuation support
oop get_continuation() const;
ContinuationEntry* last_continuation() const { return _cont_entry; }
void set_cont_fastpath(intptr_t* x) { _cont_fastpath = x; }
void push_cont_fastpath(intptr_t* sp) { if (sp > _cont_fastpath) _cont_fastpath = sp; }
@ -670,8 +663,6 @@ private:
// Fast-locking support
bool is_lock_owned(address adr) const;
bool is_lock_owned_current(address adr) const; // virtual if mounted, otherwise whole thread
bool is_lock_owned_carrier(address adr) const;
// Accessors for vframe array top
// The linked list of vframe arrays are sorted on sp. This means when we
@ -697,22 +688,19 @@ private:
CompiledMethod* deopt_compiled_method() { return _deopt_nmethod; }
Method* callee_target() const { return _callee_target; }
void set_callee_target (Method* x) { _callee_target = x; }
void set_callee_target (Method* x) { _callee_target = x; }
// Oop results of vm runtime calls
oop vm_result() const { return _vm_result; }
void set_vm_result (oop x) { _vm_result = x; }
Metadata* vm_result_2() const { return _vm_result_2; }
void set_vm_result_2 (Metadata* x) { _vm_result_2 = x; }
void set_vm_result_2 (Metadata* x) { _vm_result_2 = x; }
MemRegion deferred_card_mark() const { return _deferred_card_mark; }
void set_deferred_card_mark(MemRegion mr) { _deferred_card_mark = mr; }
#if INCLUDE_JVMCI
int pending_deoptimization() const { return _pending_deoptimization; }
jlong pending_failed_speculation() const { return _pending_failed_speculation; }
bool has_pending_monitorenter() const { return _pending_monitorenter; }
void set_pending_monitorenter(bool b) { _pending_monitorenter = b; }
void set_pending_deoptimization(int reason) { _pending_deoptimization = reason; }
void set_pending_failed_speculation(jlong failed_speculation) { _pending_failed_speculation = failed_speculation; }
@ -733,8 +721,6 @@ private:
// Exception handling for compiled methods
oop exception_oop() const;
address exception_pc() const { return _exception_pc; }
address exception_handler_pc() const { return _exception_handler_pc; }
bool is_method_handle_return() const { return _is_method_handle_return == 1; }
void set_exception_oop(oop o);
void set_exception_pc(address a) { _exception_pc = a; }
@ -787,7 +773,6 @@ private:
#if INCLUDE_JVMCI
static ByteSize pending_deoptimization_offset() { return byte_offset_of(JavaThread, _pending_deoptimization); }
static ByteSize pending_monitorenter_offset() { return byte_offset_of(JavaThread, _pending_monitorenter); }
static ByteSize pending_failed_speculation_offset() { return byte_offset_of(JavaThread, _pending_failed_speculation); }
static ByteSize jvmci_alternate_call_target_offset() { return byte_offset_of(JavaThread, _jvmci._alternate_call_target); }
static ByteSize jvmci_implicit_exception_pc_offset() { return byte_offset_of(JavaThread, _jvmci._implicit_exception_pc); }
static ByteSize jvmci_counters_offset() { return byte_offset_of(JavaThread, _jvmci_counters); }
@ -923,7 +908,6 @@ private:
void print_on(outputStream* st) const { print_on(st, false); }
void print() const;
void print_thread_state_on(outputStream*) const;
const char* thread_state_name() const;
void print_on_error(outputStream* st, char* buf, int buflen) const;
void print_name_on_error(outputStream* st, char* buf, int buflen) const;
void verify();
@ -1044,7 +1028,6 @@ private:
static ByteSize popframe_condition_offset() { return byte_offset_of(JavaThread, _popframe_condition); }
bool has_pending_popframe() { return (popframe_condition() & popframe_pending_bit) != 0; }
bool popframe_forcing_deopt_reexecution() { return (popframe_condition() & popframe_force_deopt_reexecution_bit) != 0; }
void clear_popframe_forcing_deopt_reexecution() { _popframe_condition &= ~popframe_force_deopt_reexecution_bit; }
bool pop_frame_in_process(void) { return ((_popframe_condition & popframe_processing_bit) != 0); }
void set_pop_frame_in_process(void) { _popframe_condition |= popframe_processing_bit; }
@ -1096,7 +1079,6 @@ private:
int _should_post_on_exceptions_flag;
public:
int should_post_on_exceptions_flag() { return _should_post_on_exceptions_flag; }
void set_should_post_on_exceptions_flag(int val) { _should_post_on_exceptions_flag = val; }
private:
@ -1171,10 +1153,6 @@ public:
// resource allocation failure.
static void vm_exit_on_osthread_failure(JavaThread* thread);
// AsyncGetCallTrace support
inline bool in_asgct(void) {return _in_asgct;}
inline void set_in_asgct(bool value) {_in_asgct = value;}
// Deferred OopHandle release support
private:
// List of OopHandles to be released - guarded by the Service_lock.

24
src/hotspot/share/runtime/jniHandles.cpp
View File

@ -252,15 +252,6 @@ bool JNIHandles::is_weak_global_handle(jobject handle) {
return is_jweak(handle) && is_storage_handle(weak_global_handles(), jweak_ptr(handle));
}
size_t JNIHandles::global_handle_memory_usage() {
return global_handles()->total_memory_usage();
}
size_t JNIHandles::weak_global_handle_memory_usage() {
return weak_global_handles()->total_memory_usage();
}
// We assume this is called at a safepoint: no lock is needed.
void JNIHandles::print_on(outputStream* st) {
assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
@ -539,18 +530,3 @@ bool JNIHandleBlock::chain_contains(jobject handle) const {
}
return false;
}
size_t JNIHandleBlock::length() const {
size_t result = 1;
for (JNIHandleBlock* current = _next; current != NULL; current = current->_next) {
result++;
}
return result;
}
// This method is not thread-safe, i.e., must be called while holding a lock on the
// structure.
size_t JNIHandleBlock::memory_usage() const {
return length() * sizeof(JNIHandleBlock);
}

4
src/hotspot/share/runtime/jniHandles.hpp
View File

@ -108,8 +108,6 @@ class JNIHandles : AllStatic {
static bool is_frame_handle(JavaThread* thread, jobject handle);
static bool is_global_handle(jobject handle);
static bool is_weak_global_handle(jobject handle);
static size_t global_handle_memory_usage();
static size_t weak_global_handle_memory_usage();
// precondition: handle != NULL.
static jobjectRefType handle_type(JavaThread* thread, jobject handle);
@ -180,8 +178,6 @@ class JNIHandleBlock : public CHeapObj<mtInternal> {
// Debugging
bool chain_contains(jobject handle) const; // Does this block or following blocks contain handle
bool contains(jobject handle) const; // Does this block contain handle
size_t length() const; // Length of chain starting with this block
size_t memory_usage() const;
};
#endif // SHARE_RUNTIME_JNIHANDLES_HPP

22
src/hotspot/share/runtime/jniPeriodicChecker.cpp
View File

@ -34,11 +34,8 @@ class JniPeriodicCheckerTask : public PeriodicTask {
public:
JniPeriodicCheckerTask(int interval_time) : PeriodicTask(interval_time) {}
void task() { os::run_periodic_checks(tty); }
static void engage();
static void disengage();
};
//----------------------------------------------------------
// Implementation of JniPeriodicChecker
@ -56,22 +53,3 @@ void JniPeriodicChecker::engage() {
_task->enroll();
}
}
/*
* the disengage() method is responsible for deactivating the periodic
* task. This method is called from before_exit() in java.cpp and is only called
* after the WatcherThread has been stopped.
*/
void JniPeriodicChecker::disengage() {
if (CheckJNICalls && is_active()) {
// remove JniPeriodicChecker
_task->disenroll();
delete _task;
_task = NULL;
}
}
void jniPeriodicChecker_exit() {
if (!CheckJNICalls) return;
}

7
src/hotspot/share/runtime/jniPeriodicChecker.hpp
View File

@ -44,14 +44,7 @@ class JniPeriodicChecker : AllStatic {
public:
// Start/stop task
static void engage();
static void disengage();
static bool is_active() { return _task != NULL; }
static void initialize();
static void destroy();
};
void jniPeriodicChecker_exit();
#endif // SHARE_RUNTIME_JNIPERIODICCHECKER_HPP

16
src/hotspot/share/runtime/keepStackGCProcessed.cpp
View File

@ -58,19 +58,3 @@ KeepStackGCProcessedMark::~KeepStackGCProcessedMark() {
void KeepStackGCProcessedMark::finish_processing() {
StackWatermarkSet::finish_processing(_jt, NULL /* context */, StackWatermarkKind::gc);
}
#ifdef ASSERT
bool KeepStackGCProcessedMark::stack_is_kept_gc_processed(JavaThread* jt) {
if (!Thread::current()->is_Java_thread()) {
assert(SafepointSynchronize::is_at_safepoint() && Thread::current()->is_VM_thread(),
"must be either Java thread or VM thread in a safepoint");
return true;
}
StackWatermark* our_watermark = StackWatermarkSet::get(JavaThread::current(), StackWatermarkKind::gc);
if (our_watermark == nullptr) {
return true;
}
StackWatermark* their_watermark = StackWatermarkSet::get(jt, StackWatermarkKind::gc);
return our_watermark->linked_watermark() == their_watermark;
}
#endif // ASSERT

2
src/hotspot/share/runtime/keepStackGCProcessed.hpp
View File

@ -43,8 +43,6 @@ class KeepStackGCProcessedMark : public StackObj {
public:
KeepStackGCProcessedMark(JavaThread* jt);
~KeepStackGCProcessedMark();
static bool stack_is_kept_gc_processed(JavaThread* jt) NOT_DEBUG({ return true; }) ;
};

3
src/hotspot/share/runtime/monitorChunk.hpp
View File

@ -48,9 +48,6 @@ class MonitorChunk: public CHeapObj<mtSynchronizer> {
MonitorChunk* next() const { return _next; }
void set_next(MonitorChunk* next) { _next = next; }
// Tells whether the monitor chunk is linked into the JavaThread
bool is_linked() const { return next() != NULL; }
// Returns the number of monitors
int number_of_monitors() const { return _number_of_monitors; }

1
src/hotspot/share/runtime/monitorDeflationThread.hpp
View File

@ -41,7 +41,6 @@ class MonitorDeflationThread : public JavaThread {
// Hide this thread from external view.
bool is_hidden_from_external_view() const { return true; }
bool is_monitor_deflation_thread() const { return true; }
};
#endif // SHARE_RUNTIME_MONITORDEFLATIONTHREAD_HPP

1
src/hotspot/share/runtime/mutex.hpp
View File

@ -119,7 +119,6 @@ class Mutex : public CHeapObj<mtSynchronizer> {
Rank rank() const { return _rank; }
const char* rank_name() const;
Mutex* next() const { return _next; }
void set_next(Mutex *next) { _next = next; }
#endif // ASSERT
protected:

5
src/hotspot/share/runtime/mutexLocker.cpp
View File

@ -193,11 +193,6 @@ void assert_lock_strong(const Mutex* lock) {
if (lock->owned_by_self()) return;
fatal("must own lock %s", lock->name());
}
void assert_locked_or_safepoint_or_handshake(const Mutex* lock, const JavaThread* thread) {
if (thread->is_handshake_safe_for(Thread::current())) return;
assert_locked_or_safepoint(lock);
}
#endif
static void add_mutex(Mutex* var) {

4
src/hotspot/share/runtime/mutexLocker.hpp
View File

@ -176,19 +176,15 @@ extern Mutex* tty_lock; // lock to synchronize output.
void print_owned_locks_on_error(outputStream* st);
void print_lock_ranks(outputStream* st);
char *lock_name(Mutex *mutex);
// for debugging: check that we're already owning this lock (or are at a safepoint / handshake)
#ifdef ASSERT
void assert_locked_or_safepoint(const Mutex* lock);
void assert_locked_or_safepoint_weak(const Mutex* lock);
void assert_lock_strong(const Mutex* lock);
void assert_locked_or_safepoint_or_handshake(const Mutex* lock, const JavaThread* thread);
#else
#define assert_locked_or_safepoint(lock)
#define assert_locked_or_safepoint_weak(lock)
#define assert_lock_strong(lock)
#define assert_locked_or_safepoint_or_handshake(lock, thread)
#endif
class MutexLocker: public StackObj {

10
src/hotspot/share/runtime/objectMonitor.hpp
View File

@ -204,8 +204,6 @@ class ObjectMonitor : public CHeapObj<mtObjectMonitor> {
// TODO-FIXME: the "offset" routines should return a type of off_t instead of int ...
// ByteSize would also be an appropriate type.
static int header_offset_in_bytes() { return offset_of(ObjectMonitor, _header); }
static int object_offset_in_bytes() { return offset_of(ObjectMonitor, _object); }
static int owner_offset_in_bytes() { return offset_of(ObjectMonitor, _owner); }
static int recursions_offset_in_bytes() { return offset_of(ObjectMonitor, _recursions); }
static int cxq_offset_in_bytes() { return offset_of(ObjectMonitor, _cxq); }
@ -267,16 +265,8 @@ class ObjectMonitor : public CHeapObj<mtObjectMonitor> {
// Simply get _next_om field.
ObjectMonitor* next_om() const;
// Get _next_om field with acquire semantics.
ObjectMonitor* next_om_acquire() const;
// Simply set _next_om field to new_value.
void set_next_om(ObjectMonitor* new_value);
// Set _next_om field to new_value with release semantics.
void release_set_next_om(ObjectMonitor* new_value);
// Try to set _next_om field to new_value if the current value matches
// old_value, using Atomic::cmpxchg(). Otherwise, does not change the
// _next_om field. Returns the prior value of the _next_om field.
ObjectMonitor* try_set_next_om(ObjectMonitor* old_value, ObjectMonitor* new_value);
int waiters() const;

17
src/hotspot/share/runtime/objectMonitor.inline.hpp
View File

@ -160,26 +160,9 @@ inline ObjectMonitor* ObjectMonitor::next_om() const {
return Atomic::load(&_next_om);
}
// Get _next_om field with acquire semantics.
inline ObjectMonitor* ObjectMonitor::next_om_acquire() const {
return Atomic::load_acquire(&_next_om);
}
// Simply set _next_om field to new_value.
inline void ObjectMonitor::set_next_om(ObjectMonitor* new_value) {
Atomic::store(&_next_om, new_value);
}
// Set _next_om field to new_value with release semantics.
inline void ObjectMonitor::release_set_next_om(ObjectMonitor* new_value) {
Atomic::release_store(&_next_om, new_value);
}
// Try to set _next_om field to new_value if the current value matches
// old_value. Otherwise, does not change the _next_om field. Returns
// the prior value of the _next_om field.
inline ObjectMonitor* ObjectMonitor::try_set_next_om(ObjectMonitor* old_value, ObjectMonitor* new_value) {
return Atomic::cmpxchg(&_next_om, old_value, new_value);
}
#endif // SHARE_RUNTIME_OBJECTMONITOR_INLINE_HPP

3
src/hotspot/share/runtime/os.hpp
View File

@ -584,8 +584,6 @@ class os: AllStatic {
static OSReturn set_priority(Thread* thread, ThreadPriority priority);
static OSReturn get_priority(const Thread* const thread, ThreadPriority& priority);
static int pd_self_suspend_thread(Thread* thread);
static address fetch_frame_from_context(const void* ucVoid, intptr_t** sp, intptr_t** fp);
static frame fetch_frame_from_context(const void* ucVoid);
static frame fetch_compiled_frame_from_context(const void* ucVoid);
@ -1003,7 +1001,6 @@ class os: AllStatic {
static bool find(address pc, outputStream* st = tty); // OS specific function to make sense out of an address
static bool dont_yield(); // when true, JVM_Yield() is nop
static void print_statistics();
// Thread priority helpers (implemented in OS-specific part)
static OSReturn set_native_priority(Thread* thread, int native_prio);

31
src/hotspot/share/runtime/os_perf.hpp
View File

@ -31,29 +31,6 @@
#define FUNCTIONALITY_NOT_IMPLEMENTED -8
class EnvironmentVariable : public CHeapObj<mtInternal> {
public:
char* _key;
char* _value;
EnvironmentVariable() {
_key = NULL;
_value = NULL;
}
~EnvironmentVariable() {
FREE_C_HEAP_ARRAY(char, _key);
FREE_C_HEAP_ARRAY(char, _value);
}
EnvironmentVariable(char* key, char* value) {
_key = key;
_value = value;
}
};
class CPUInformation : public CHeapObj<mtInternal> {
private:
int _no_of_sockets;
@ -129,14 +106,6 @@ class SystemProcess : public CHeapObj<mtInternal> {
_next = NULL;
}
SystemProcess(int pid, char* name, char* path, char* command_line, SystemProcess* next) {
_pid = pid;
_name = name;
_path = path;
_command_line = command_line;
_next = next;
}
void set_next(SystemProcess* sys_process) {
_next = sys_process;
}

72
src/hotspot/share/runtime/perfData.cpp
View File

@ -190,10 +190,6 @@ PerfLong::PerfLong(CounterNS ns, const char* namep, Units u, Variability v)
create_entry(T_LONG, sizeof(jlong));
}
int PerfLong::format(char* buffer, int length) {
return jio_snprintf(buffer, length, JLONG_FORMAT, *(jlong*)_valuep);
}
PerfLongVariant::PerfLongVariant(CounterNS ns, const char* namep, Units u,
Variability v, jlong* sampled)
: PerfLong(ns, namep, u, v),
@ -233,10 +229,6 @@ void PerfString::set_string(const char* s2) {
((char*)_valuep)[_length-1] = '\0';
}
int PerfString::format(char* buffer, int length) {
return jio_snprintf(buffer, length, "%s", (char*)_valuep);
}
PerfStringConstant::PerfStringConstant(CounterNS ns, const char* namep,
const char* initial_value)
: PerfString(ns, namep, V_Constant,
@ -325,17 +317,6 @@ void PerfDataManager::add_item(PerfData* p, bool sampled) {
}
}
PerfDataList* PerfDataManager::all() {
MutexLocker ml(PerfDataManager_lock);
if (_all == NULL)
return NULL;
PerfDataList* clone = _all->clone();
return clone;
}
PerfDataList* PerfDataManager::sampled() {
MutexLocker ml(PerfDataManager_lock);
@ -347,17 +328,6 @@ PerfDataList* PerfDataManager::sampled() {
return clone;
}
PerfDataList* PerfDataManager::constants() {
MutexLocker ml(PerfDataManager_lock);
if (_constants == NULL)
return NULL;
PerfDataList* clone = _constants->clone();
return clone;
}
char* PerfDataManager::counter_name(const char* ns, const char* name) {
assert(ns != NULL, "ns string required");
assert(name != NULL, "name string required");
@ -458,27 +428,6 @@ PerfLongVariable* PerfDataManager::create_long_variable(CounterNS ns,
return p;
}
PerfLongVariable* PerfDataManager::create_long_variable(CounterNS ns,
const char* name,
PerfData::Units u,
jlong* sp, TRAPS) {
// Sampled counters not supported if UsePerfData is false
if (!UsePerfData) return NULL;
PerfLongVariable* p = new PerfLongVariable(ns, name, u, sp);
if (!p->is_valid()) {
// allocation of native resources failed.
delete p;
THROW_0(vmSymbols::java_lang_OutOfMemoryError());
}
add_item(p, true);
return p;
}
PerfLongVariable* PerfDataManager::create_long_variable(CounterNS ns,
const char* name,
PerfData::Units u,
@ -519,27 +468,6 @@ PerfLongCounter* PerfDataManager::create_long_counter(CounterNS ns,
return p;
}
PerfLongCounter* PerfDataManager::create_long_counter(CounterNS ns,
const char* name,
PerfData::Units u,
jlong* sp, TRAPS) {
// Sampled counters not supported if UsePerfData is false
if (!UsePerfData) return NULL;
PerfLongCounter* p = new PerfLongCounter(ns, name, u, sp);
if (!p->is_valid()) {
// allocation of native resources failed.
delete p;
THROW_0(vmSymbols::java_lang_OutOfMemoryError());
}
add_item(p, true);
return p;
}
PerfLongCounter* PerfDataManager::create_long_counter(CounterNS ns,
const char* name,
PerfData::Units u,

62
src/hotspot/share/runtime/perfData.hpp
View File

@ -333,10 +333,6 @@ class PerfData : public CHeapObj<mtInternal> {
// returns the address of the data portion of the item in the
// PerfData memory region.
inline void* get_address() { return _valuep; }
// returns the value of the data portion of the item in the
// PerfData memory region formatted as a string.
virtual int format(char* cp, int length) = 0;
};
/*
@ -362,8 +358,6 @@ class PerfLong : public PerfData {
PerfLong(CounterNS ns, const char* namep, Units u, Variability v);
public:
int format(char* buffer, int length);
// returns the value of the data portion of the item in the
// PerfData memory region.
inline jlong get_value() { return *(jlong*)_valuep; }
@ -423,7 +417,6 @@ class PerfLongVariant : public PerfLong {
inline void inc() { (*(jlong*)_valuep)++; }
inline void inc(jlong val) { (*(jlong*)_valuep) += val; }
inline void dec(jlong val) { inc(-val); }
inline void add(jlong val) { (*(jlong*)_valuep) += val; }
};
/*
@ -510,9 +503,6 @@ class PerfString : public PerfByteArray {
if (is_valid()) set_string(initial_value);
}
public:
int format(char* buffer, int length);
};
/*
@ -627,14 +617,6 @@ class PerfDataList : public CHeapObj<mtInternal> {
// add a PerfData item to this list
inline void append(PerfData *p);
// remove the given PerfData item from this list. When called
// while iterating over the list, this method will result in a
// change in the length of the container. The at(int index)
// method is also impacted by this method as elements with an
// index greater than the index of the element removed by this
// method will be shifted down by one.
inline void remove(PerfData *p);
// create a new PerfDataList from this list. The new list is
// a shallow copy of the original list and care should be taken
// with respect to delete operations on the elements of the list
@ -668,18 +650,11 @@ class PerfDataManager : AllStatic {
static void add_item(PerfData* p, bool sampled);
protected:
// return the list of all known PerfData items
static PerfDataList* all();
static inline int count();
// return the list of all known PerfData items that are to be
// sampled by the StatSampler.
static PerfDataList* sampled();
// return the list of all known PerfData items that have a
// variability classification of type Constant
static PerfDataList* constants();
public:
// method to check for the existence of a PerfData item with
@ -754,12 +729,6 @@ class PerfDataManager : AllStatic {
int max_length,
const char *s, TRAPS);
static PerfStringVariable* create_string_variable(CounterNS ns,
const char* name,
const char *s, TRAPS) {
return create_string_variable(ns, name, 0, s, THREAD);
};
static PerfLongVariable* create_long_variable(CounterNS ns,
const char* name,
PerfData::Units u,
@ -771,10 +740,6 @@ class PerfDataManager : AllStatic {
return create_long_variable(ns, name, u, (jlong)0, THREAD);
};
static PerfLongVariable* create_long_variable(CounterNS, const char* name,
PerfData::Units u,
jlong* sp, TRAPS);
static PerfLongVariable* create_long_variable(CounterNS ns,
const char* name,
PerfData::Units u,
@ -787,15 +752,6 @@ class PerfDataManager : AllStatic {
PerfData::Units u,
jlong ival, TRAPS);
static PerfLongCounter* create_long_counter(CounterNS ns, const char* name,
PerfData::Units u, TRAPS) {
return create_long_counter(ns, name, u, (jlong)0, THREAD);
};
static PerfLongCounter* create_long_counter(CounterNS ns, const char* name,
PerfData::Units u, jlong* sp,
TRAPS);
static PerfLongCounter* create_long_counter(CounterNS ns, const char* name,
PerfData::Units u,
PerfLongSampleHelper* sh,
@ -820,32 +776,17 @@ class PerfDataManager : AllStatic {
return create_long_variable(ns, name, u, (jlong)0, THREAD);
}
static PerfVariable* create_variable(CounterNS ns, const char* name,
PerfData::Units u, jlong* sp, TRAPS) {
return create_long_variable(ns, name, u, sp, THREAD);
}
static PerfVariable* create_variable(CounterNS ns, const char* name,
PerfData::Units u,
PerfSampleHelper* sh, TRAPS) {
return create_long_variable(ns, name, u, sh, THREAD);
}
static PerfCounter* create_counter(CounterNS ns, const char* name,
PerfData::Units u, jlong ival, TRAPS) {
return create_long_counter(ns, name, u, ival, THREAD);
}
static PerfCounter* create_counter(CounterNS ns, const char* name,
PerfData::Units u, TRAPS) {
return create_long_counter(ns, name, u, (jlong)0, THREAD);
}
static PerfCounter* create_counter(CounterNS ns, const char* name,
PerfData::Units u, jlong* sp, TRAPS) {
return create_long_counter(ns, name, u, sp, THREAD);
}
static PerfCounter* create_counter(CounterNS ns, const char* name,
PerfData::Units u,
PerfSampleHelper* sh, TRAPS) {
@ -900,9 +841,6 @@ class PerfTraceTime : public StackObj {
_t.start();
}
inline void suspend() { if (!UsePerfData) return; _t.stop(); }
inline void resume() { if (!UsePerfData) return; _t.start(); }
~PerfTraceTime();
};

8
src/hotspot/share/runtime/perfData.inline.hpp
View File

@ -38,18 +38,10 @@ inline void PerfDataList::append(PerfData *p) {
_set->append(p);
}
inline void PerfDataList::remove(PerfData *p) {
_set->remove(p);
}
inline PerfData* PerfDataList::at(int index) {
return _set->at(index);
}
inline int PerfDataManager::count() {
return _all->length();
}
inline bool PerfDataManager::exists(const char* name) {
if (_all != NULL) {
return _all->contains(name);

1
src/hotspot/share/runtime/reflectionUtils.hpp
View File

@ -70,7 +70,6 @@ class KlassStream {
virtual void next() = 0;
// accessors
InstanceKlass* klass() const { return _klass; }
int index() const { return _index; }
bool base_class_search_defaults() const { return _base_class_search_defaults; }
void base_class_search_defaults(bool b) { _base_class_search_defaults = b; }

10
src/hotspot/share/runtime/registerMap.hpp
View File

@ -120,16 +120,6 @@ class RegisterMap : public StackObj {
}
}
address trusted_location(VMReg reg) const {
return (address) _location[reg->value()];
}
void verify(RegisterMap& other) {
for (int i = 0; i < reg_count; ++i) {
assert(_location[i] == other._location[i], "");
}
}
void set_location(VMReg reg, address loc) {
int index = reg->value() / location_valid_type_size;
assert(0 <= reg->value() && reg->value() < reg_count, "range check");

6
src/hotspot/share/runtime/relocator.cpp
View File

@ -47,8 +47,6 @@ class ChangeItem : public ResourceObj {
virtual bool handle_code_change(Relocator *r) = 0;
// type info
virtual bool is_widen() { return false; }
virtual bool is_jump_widen() { return false; }
virtual bool is_switch_pad() { return false; }
// accessors
@ -73,8 +71,6 @@ class ChangeWiden : public ChangeItem {
// Callback to do instruction
bool handle_code_change(Relocator *r) { return r->handle_widen(bci(), _new_ilen, _inst_buffer); };
bool is_widen() { return true; }
void print() { tty->print_cr("ChangeWiden. bci: %d New_ilen: %d", bci(), _new_ilen); }
};
@ -86,8 +82,6 @@ class ChangeJumpWiden : public ChangeItem {
// Callback to do instruction
bool handle_code_change(Relocator *r) { return r->handle_jump_widen(bci(), _delta); };
bool is_jump_widen() { return true; }
// If the bci matches, adjust the delta in the change jump request.
bool adjust(int jump_bci, int delta) {
if (bci() == jump_bci) {

1
src/hotspot/share/runtime/relocator.hpp
View File

@ -37,7 +37,6 @@ class ChangeItem;
// Callback object for code relocations
class RelocatorListener : public StackObj {
public:
RelocatorListener() {};
virtual void relocated(int bci, int delta, int new_method_size) = 0;
};

2
src/hotspot/share/runtime/rtmLocking.hpp
View File

@ -97,8 +97,6 @@ class RTMLockingCounters {
}
uintx* total_count_addr() { return &_total_count; }
uintx* abort_count_addr() { return &_abort_count; }
uintx* abortX_count_addr() { return &_abortX_count[0]; }
static int total_count_offset() { return (int)offset_of(RTMLockingCounters, _total_count); }
static int abort_count_offset() { return (int)offset_of(RTMLockingCounters, _abort_count); }

3
src/hotspot/share/runtime/safepoint.hpp
View File

@ -165,9 +165,6 @@ public:
static void set_is_at_safepoint() { _state = _synchronized; }
static void set_is_not_at_safepoint() { _state = _not_synchronized; }
// Assembly support
static address address_of_state() { return (address)&_state; }
// Only used for making sure that no safepoint has happened in
// JNI_FastGetField. Therefore only the low 32-bits are needed
// even if this is a 64-bit counter.

1
src/hotspot/share/runtime/safepointMechanism.hpp
View File

@ -73,7 +73,6 @@ class SafepointMechanism : public AllStatic {
inline uintptr_t get_polling_word();
inline void set_polling_page(uintptr_t poll_value);
inline uintptr_t get_polling_page();
};
// Call this method to see if this thread should block for a safepoint or process handshake.

6
src/hotspot/share/runtime/safepointMechanism.inline.hpp
View File

@ -37,12 +37,6 @@ inline void SafepointMechanism::ThreadData::set_polling_page(uintptr_t poll_valu
Atomic::store(&_polling_page, poll_value);
}
// The acquire makes sure reading of polling page is done before
// the reading the handshake operation or the global state
inline uintptr_t SafepointMechanism::ThreadData::get_polling_page() {
return Atomic::load_acquire(&_polling_page);
}
// Caller is responsible for using a memory barrier if needed.
inline void SafepointMechanism::ThreadData::set_polling_word(uintptr_t poll_value) {
Atomic::store(&_polling_word, poll_value);

29
src/hotspot/share/runtime/sharedRuntime.cpp
View File

@ -143,15 +143,12 @@ int SharedRuntime::_implicit_null_throws = 0;
int SharedRuntime::_implicit_div0_throws = 0;
int64_t SharedRuntime::_nof_normal_calls = 0;
int64_t SharedRuntime::_nof_optimized_calls = 0;
int64_t SharedRuntime::_nof_inlined_calls = 0;
int64_t SharedRuntime::_nof_megamorphic_calls = 0;
int64_t SharedRuntime::_nof_static_calls = 0;
int64_t SharedRuntime::_nof_inlined_static_calls = 0;
int64_t SharedRuntime::_nof_interface_calls = 0;
int64_t SharedRuntime::_nof_optimized_interface_calls = 0;
int64_t SharedRuntime::_nof_inlined_interface_calls = 0;
int64_t SharedRuntime::_nof_megamorphic_interface_calls = 0;
int SharedRuntime::_new_instance_ctr=0;
int SharedRuntime::_new_array_ctr=0;
@ -680,17 +677,6 @@ address SharedRuntime::get_poll_stub(address pc) {
return stub;
}
oop SharedRuntime::retrieve_receiver( Symbol* sig, frame caller ) {
assert(caller.is_interpreted_frame(), "");
int args_size = ArgumentSizeComputer(sig).size() + 1;
assert(args_size <= caller.interpreter_frame_expression_stack_size(), "receiver must be on interpreter stack");
oop result = cast_to_oop(*caller.interpreter_frame_tos_at(args_size - 1));
assert(Universe::heap()->is_in(result) && oopDesc::is_oop(result), "receiver must be an oop");
return result;
}
void SharedRuntime::throw_and_post_jvmti_exception(JavaThread* current, Handle h_exception) {
if (JvmtiExport::can_post_on_exceptions()) {
vframeStream vfst(current, true);
@ -2379,10 +2365,6 @@ void SharedRuntime::print_statistics() {
if (xtty != NULL) xtty->tail("statistics");
}
inline double percent(int x, int y) {
return 100.0 * x / MAX2(y, 1);
}
inline double percent(int64_t x, int64_t y) {
return 100.0 * x / MAX2(y, (int64_t)1);
}
@ -2470,19 +2452,16 @@ int MethodArityHistogram::_max_size;
void SharedRuntime::print_call_statistics(uint64_t comp_total) {
tty->print_cr("Calls from compiled code:");
int64_t total = _nof_normal_calls + _nof_interface_calls + _nof_static_calls;
int64_t mono_c = _nof_normal_calls - _nof_optimized_calls - _nof_megamorphic_calls;
int64_t mono_i = _nof_interface_calls - _nof_optimized_interface_calls - _nof_megamorphic_interface_calls;
int64_t mono_c = _nof_normal_calls - _nof_megamorphic_calls;
int64_t mono_i = _nof_interface_calls;
tty->print_cr("\t" INT64_FORMAT_W(12) " (100%%) total non-inlined ", total);
tty->print_cr("\t" INT64_FORMAT_W(12) " (%4.1f%%) |- virtual calls ", _nof_normal_calls, percent(_nof_normal_calls, total));
tty->print_cr("\t" INT64_FORMAT_W(12) " (%4.0f%%) | |- inlined ", _nof_inlined_calls, percent(_nof_inlined_calls, _nof_normal_calls));
tty->print_cr("\t" INT64_FORMAT_W(12) " (%4.0f%%) | |- optimized ", _nof_optimized_calls, percent(_nof_optimized_calls, _nof_normal_calls));
tty->print_cr("\t" INT64_FORMAT_W(12) " (%4.0f%%) | |- monomorphic ", mono_c, percent(mono_c, _nof_normal_calls));
tty->print_cr("\t" INT64_FORMAT_W(12) " (%4.0f%%) | |- megamorphic ", _nof_megamorphic_calls, percent(_nof_megamorphic_calls, _nof_normal_calls));
tty->print_cr("\t" INT64_FORMAT_W(12) " (%4.1f%%) |- interface calls ", _nof_interface_calls, percent(_nof_interface_calls, total));
tty->print_cr("\t" INT64_FORMAT_W(12) " (%4.0f%%) | |- inlined ", _nof_inlined_interface_calls, percent(_nof_inlined_interface_calls, _nof_interface_calls));
tty->print_cr("\t" INT64_FORMAT_W(12) " (%4.0f%%) | |- optimized ", _nof_optimized_interface_calls, percent(_nof_optimized_interface_calls, _nof_interface_calls));
tty->print_cr("\t" INT64_FORMAT_W(12) " (%4.0f%%) | |- monomorphic ", mono_i, percent(mono_i, _nof_interface_calls));
tty->print_cr("\t" INT64_FORMAT_W(12) " (%4.0f%%) | |- megamorphic ", _nof_megamorphic_interface_calls, percent(_nof_megamorphic_interface_calls, _nof_interface_calls));
tty->print_cr("\t" INT64_FORMAT_W(12) " (%4.1f%%) |- static/special calls", _nof_static_calls, percent(_nof_static_calls, total));
tty->print_cr("\t" INT64_FORMAT_W(12) " (%4.0f%%) | |- inlined ", _nof_inlined_static_calls, percent(_nof_inlined_static_calls, _nof_static_calls));
tty->cr();
@ -2750,10 +2729,6 @@ BufferBlob* AdapterHandlerLibrary::buffer_blob() {
return _buffer;
}
extern "C" void unexpected_adapter_call() {
ShouldNotCallThis();
}
static void post_adapter_creation(const AdapterBlob* new_adapter,
const AdapterHandlerEntry* entry) {
if (Forte::is_enabled() || JvmtiExport::should_post_dynamic_code_generated()) {

8
src/hotspot/share/runtime/sharedRuntime.hpp
View File

@ -272,8 +272,6 @@ class SharedRuntime: AllStatic {
// To be used as the entry point for unresolved native methods.
static address native_method_throw_unsatisfied_link_error_entry();
static oop retrieve_receiver(Symbol* sig, frame caller);
static void register_finalizer(JavaThread* thread, oopDesc* obj);
// dtrace notifications
@ -556,26 +554,20 @@ class SharedRuntime: AllStatic {
// Statistics code
// stats for "normal" compiled calls (non-interface)
static int64_t _nof_normal_calls; // total # of calls
static int64_t _nof_optimized_calls; // total # of statically-bound calls
static int64_t _nof_inlined_calls; // total # of inlined normal calls
static int64_t _nof_static_calls; // total # of calls to static methods or super methods (invokespecial)
static int64_t _nof_inlined_static_calls; // total # of inlined static calls
// stats for compiled interface calls
static int64_t _nof_interface_calls; // total # of compiled calls
static int64_t _nof_optimized_interface_calls; // total # of statically-bound interface calls
static int64_t _nof_inlined_interface_calls; // total # of inlined interface calls
static int64_t _nof_megamorphic_interface_calls;// total # of megamorphic interface calls
public: // for compiler
static address nof_normal_calls_addr() { return (address)&_nof_normal_calls; }
static address nof_optimized_calls_addr() { return (address)&_nof_optimized_calls; }
static address nof_inlined_calls_addr() { return (address)&_nof_inlined_calls; }
static address nof_static_calls_addr() { return (address)&_nof_static_calls; }
static address nof_inlined_static_calls_addr() { return (address)&_nof_inlined_static_calls; }
static address nof_interface_calls_addr() { return (address)&_nof_interface_calls; }
static address nof_optimized_interface_calls_addr() { return (address)&_nof_optimized_interface_calls; }
static address nof_inlined_interface_calls_addr() { return (address)&_nof_inlined_interface_calls; }
static address nof_megamorphic_interface_calls_addr() { return (address)&_nof_megamorphic_interface_calls; }
static void print_call_statistics(uint64_t comp_total);
static void print_statistics();
static void print_ic_miss_histogram();

17
src/hotspot/share/runtime/signature.cpp
View File

@ -569,12 +569,6 @@ ResolvingSignatureStream::ResolvingSignatureStream(const Method* method)
initialize_load_origin(method->method_holder());
}
ResolvingSignatureStream::ResolvingSignatureStream(fieldDescriptor& field)
: SignatureStream(field.signature(), false)
{
initialize_load_origin(field.field_holder());
}
void ResolvingSignatureStream::cache_handles() {
assert(_load_origin != NULL, "");
JavaThread* current = JavaThread::current();
@ -582,17 +576,6 @@ void ResolvingSignatureStream::cache_handles() {
_protection_domain = Handle(current, _load_origin->protection_domain());
}
Klass* ResolvingSignatureStream::as_klass_if_loaded(TRAPS) {
Klass* klass = as_klass(CachedOrNull, THREAD);
// SD::find does not trigger loading, so there should be no throws
// Still, bad things can happen, so we CHECK_NULL and ask callers
// to do likewise.
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
}
return klass;
}
#ifdef ASSERT
extern bool signature_constants_sane(); // called from basic_types_init()

19
src/hotspot/share/runtime/signature.hpp
View File

@ -97,14 +97,6 @@ class Signature : AllStatic {
// Returns T_ILLEGAL for an illegal signature char.
static BasicType basic_type(int ch);
// Assuming it is either a class name or signature,
// determine if it in fact cannot be a class name.
// This means it either starts with '[' or ends with ';'
static bool not_class_name(const Symbol* signature) {
return (signature->starts_with(JVM_SIGNATURE_ARRAY) ||
signature->ends_with(JVM_SIGNATURE_ENDCLASS));
}
// Assuming it is either a class name or signature,
// determine if it in fact is an array descriptor.
static bool is_array(const Symbol* signature) {
@ -230,10 +222,6 @@ class SignatureIterator: public ResourceObj {
template<typename T> inline void do_parameters_on(T* callback); // iterates over parameters only
BasicType return_type(); // computes the value on the fly if necessary
static bool fp_is_static(fingerprint_t fingerprint) {
assert(fp_is_valid(fingerprint), "invalid fingerprint");
return fingerprint & fp_is_static_bit;
}
static BasicType fp_return_type(fingerprint_t fingerprint) {
assert(fp_is_valid(fingerprint), "invalid fingerprint");
return (BasicType) ((fingerprint >> fp_static_feature_size) & fp_result_feature_mask);
@ -509,7 +497,6 @@ class SignatureStream : public StackObj {
bool is_reference() const { return is_reference_type(_type); }
bool is_array() const { return _type == T_ARRAY; }
bool is_primitive() const { return is_java_primitive(_type); }
BasicType type() const { return _type; }
const u1* raw_bytes() const { return _signature->bytes() + _begin; }
@ -602,13 +589,7 @@ class ResolvingSignatureStream : public SignatureStream {
ResolvingSignatureStream(Symbol* signature, Klass* load_origin, bool is_method = true);
ResolvingSignatureStream(Symbol* signature, Handle class_loader, Handle protection_domain, bool is_method = true);
ResolvingSignatureStream(const Method* method);
ResolvingSignatureStream(fieldDescriptor& field);
Klass* load_origin() { return _load_origin; }
Handle class_loader() { need_handles(); return _class_loader; }
Handle protection_domain() { need_handles(); return _protection_domain; }
Klass* as_klass_if_loaded(TRAPS);
Klass* as_klass(FailureMode failure_mode, TRAPS) {
need_handles();
return SignatureStream::as_klass(_class_loader, _protection_domain,

12
src/hotspot/share/runtime/stackChunkFrameStream.hpp
View File

@ -63,19 +63,12 @@ public:
inline StackChunkFrameStream(stackChunkOop chunk, const frame& f);
bool is_done() const { return _sp >= _end; }
bool is_last() const { return next_sp() >= _end; }
intptr_t* end() { return _end; }
void set_end(intptr_t* end) { _end = end; }
// Query
intptr_t* end() const { return _end; }
intptr_t* sp() const { return _sp; }
inline address pc() const { return get_pc(); }
inline intptr_t* fp() const;
inline intptr_t* unextended_sp() const { return frame_kind == ChunkFrames::Mixed ? _unextended_sp : _sp; }
NOT_PRODUCT(int index() { return _index; })
inline address orig_pc() const;
inline bool is_interpreted() const;
@ -94,13 +87,10 @@ public:
void handle_deopted() const;
inline int to_offset(stackChunkOop chunk) const;
inline frame to_frame() const;
#ifdef ASSERT
bool is_in_frame(void* p) const;
bool is_deoptimized() const;
template <typename RegisterMapT> bool is_in_oops(void* p, const RegisterMapT* map) const;
#endif
@ -110,12 +100,10 @@ public:
inline address get_pc() const;
inline void get_cb();
inline intptr_t* next_sp() const;
inline int interpreter_frame_size() const;
inline int interpreter_frame_num_oops() const;
inline int interpreter_frame_stack_argsize() const;
inline void next_for_interpreter_frame();
inline intptr_t* next_sp_for_interpreter_frame() const;
inline intptr_t* unextended_sp_for_interpreter_frame() const;
inline intptr_t* derelativize(int offset) const;
inline void get_oopmap() const;

19
src/hotspot/share/runtime/stackChunkFrameStream.inline.hpp
View File

@ -236,11 +236,6 @@ inline void StackChunkFrameStream<frame_kind>::next(RegisterMapT* map, bool stop
}
}
template <ChunkFrames frame_kind>
inline intptr_t* StackChunkFrameStream<frame_kind>::next_sp() const {
return is_interpreted() ? next_sp_for_interpreter_frame() : unextended_sp() + cb()->frame_size();
}
template <ChunkFrames frame_kind>
inline void StackChunkFrameStream<frame_kind>::get_cb() {
_oopmap = nullptr;
@ -334,20 +329,6 @@ inline address StackChunkFrameStream<frame_kind>::orig_pc() const {
return pc1;
}
template <ChunkFrames frame_kind>
inline int StackChunkFrameStream<frame_kind>::to_offset(stackChunkOop chunk) const {
assert(!is_done(), "");
return _sp - chunk->start_address();
}
#ifdef ASSERT
template <ChunkFrames frame_kind>
bool StackChunkFrameStream<frame_kind>::is_deoptimized() const {
address pc1 = pc();
return is_compiled() && CodeCache::find_oopmap_slot_fast(pc1) < 0 && cb()->as_compiled_method()->is_deopt_pc(pc1);
}
#endif
template<ChunkFrames frame_kind>
void StackChunkFrameStream<frame_kind>::handle_deopted() const {
assert(!is_done(), "");

14
src/hotspot/share/runtime/stackOverflow.cpp
View File

@ -214,20 +214,6 @@ void StackOverflow::disable_stack_yellow_reserved_zone() {
}
}
void StackOverflow::enable_stack_red_zone() {
// The base notation is from the stacks point of view, growing downward.
// We need to adjust it to work correctly with guard_memory()
assert(_stack_guard_state != stack_guard_unused, "must be using guard pages.");
address base = stack_red_zone_base() - stack_red_zone_size();
guarantee(base < stack_base(), "Error calculating stack red zone");
guarantee(base < os::current_stack_pointer(), "Error calculating stack red zone");
if (!os::guard_memory((char *) base, stack_red_zone_size())) {
warning("Attempt to guard stack red zone failed.");
}
}
void StackOverflow::disable_stack_red_zone() {
// The base notation is from the stacks point of view, growing downward.
// We need to adjust it to work correctly with guard_memory()

1
src/hotspot/share/runtime/stackOverflow.hpp
View File

@ -300,7 +300,6 @@ class StackOverflow {
void disable_stack_reserved_zone();
void enable_stack_yellow_reserved_zone();
void disable_stack_yellow_reserved_zone();
void enable_stack_red_zone();
void disable_stack_red_zone();
bool stack_guard_zone_unused() const { return _stack_guard_state == stack_guard_unused; }

1
src/hotspot/share/runtime/stackValueCollection.hpp
View File

@ -34,7 +34,6 @@ class StackValueCollection : public ResourceObj {
GrowableArray<StackValue*>* _values;
public:
StackValueCollection() { _values = new GrowableArray<StackValue*>(); }
StackValueCollection(int length) { _values = new GrowableArray<StackValue*>(length); }
void add(StackValue *val) const { _values->push(val); }

1
src/hotspot/share/runtime/stackWatermark.hpp
View File

@ -130,7 +130,6 @@ public:
void set_next(StackWatermark* n) { _next = n; }
void link_watermark(StackWatermark* watermark);
DEBUG_ONLY(StackWatermark* linked_watermark() const { return _linked_watermark; })
uintptr_t watermark();
uintptr_t last_processed();

6
src/hotspot/share/runtime/stubCodeGenerator.cpp
View File

@ -46,12 +46,6 @@ StubCodeDesc* StubCodeDesc::desc_for(address pc) {
return p;
}
const char* StubCodeDesc::name_for(address pc) {
StubCodeDesc* p = desc_for(pc);
return p == NULL ? NULL : p->name();
}
void StubCodeDesc::freeze() {
assert(!_frozen, "repeated freeze operation");
_frozen = true;

1
src/hotspot/share/runtime/stubCodeGenerator.hpp
View File

@ -69,7 +69,6 @@ class StubCodeDesc: public CHeapObj<mtCode> {
static StubCodeDesc* next(StubCodeDesc* desc) { return desc->_next; }
static StubCodeDesc* desc_for(address pc); // returns the code descriptor for the code containing pc or NULL
static const char* name_for(address pc); // returns the name of the code containing pc or NULL
StubCodeDesc(const char* group, const char* name, address begin, address end = NULL) {
assert(!_frozen, "no modifications allowed");

4
src/hotspot/share/runtime/stubRoutines.cpp
View File

@ -67,13 +67,9 @@ address StubRoutines::_throw_delayed_StackOverflowError_entry = NULL;
jint StubRoutines::_verify_oop_count = 0;
address StubRoutines::_verify_oop_subroutine_entry = NULL;
address StubRoutines::_atomic_xchg_entry = NULL;
address StubRoutines::_atomic_xchg_long_entry = NULL;
address StubRoutines::_atomic_store_entry = NULL;
address StubRoutines::_atomic_cmpxchg_entry = NULL;
address StubRoutines::_atomic_cmpxchg_byte_entry = NULL;
address StubRoutines::_atomic_cmpxchg_long_entry = NULL;
address StubRoutines::_atomic_add_entry = NULL;
address StubRoutines::_atomic_add_long_entry = NULL;
address StubRoutines::_fence_entry = NULL;
// Compiled code entry points default values

8
src/hotspot/share/runtime/stubRoutines.hpp
View File

@ -143,13 +143,9 @@ class StubRoutines: AllStatic {
static address _throw_delayed_StackOverflowError_entry;
static address _atomic_xchg_entry;
static address _atomic_xchg_long_entry;
static address _atomic_store_entry;
static address _atomic_cmpxchg_entry;
static address _atomic_cmpxchg_byte_entry;
static address _atomic_cmpxchg_long_entry;
static address _atomic_add_entry;
static address _atomic_add_long_entry;
static address _fence_entry;
static BufferBlob* _code1; // code buffer for initial routines
@ -314,13 +310,9 @@ class StubRoutines: AllStatic {
static address throw_delayed_StackOverflowError_entry() { return _throw_delayed_StackOverflowError_entry; }
static address atomic_xchg_entry() { return _atomic_xchg_entry; }
static address atomic_xchg_long_entry() { return _atomic_xchg_long_entry; }
static address atomic_store_entry() { return _atomic_store_entry; }
static address atomic_cmpxchg_entry() { return _atomic_cmpxchg_entry; }
static address atomic_cmpxchg_byte_entry() { return _atomic_cmpxchg_byte_entry; }
static address atomic_cmpxchg_long_entry() { return _atomic_cmpxchg_long_entry; }
static address atomic_add_entry() { return _atomic_add_entry; }
static address atomic_add_long_entry() { return _atomic_add_long_entry; }
static address fence_entry() { return _fence_entry; }
static address select_arraycopy_function(BasicType t, bool aligned, bool disjoint, const char* &name, bool dest_uninitialized);

1
src/hotspot/share/runtime/suspendedThreadTask.hpp
View File

@ -41,7 +41,6 @@ class SuspendedThreadTask {
public:
SuspendedThreadTask(Thread* thread) : _thread(thread), _done(false) {}
void run();
bool is_done() { return _done; }
virtual void do_task(const SuspendedThreadTaskContext& context) = 0;
protected:
~SuspendedThreadTask() {}

10
src/hotspot/share/runtime/synchronizer.cpp
View File

@ -694,16 +694,6 @@ int ObjectSynchronizer::wait(Handle obj, jlong millis, TRAPS) {
return ret_code;
}
// No exception are possible in this case as we only use this internally when locking is
// correct and we have to wait until notified - so no interrupts or timeouts.
void ObjectSynchronizer::wait_uninterruptibly(Handle obj, JavaThread* current) {
// The ObjectMonitor* can't be async deflated because the _waiters
// field is incremented before ownership is dropped and decremented
// after ownership is regained.
ObjectMonitor* monitor = inflate(current, obj(), inflate_cause_wait);
monitor->wait(0 /* wait-forever */, false /* not interruptible */, current);
}
void ObjectSynchronizer::notify(Handle obj, TRAPS) {
JavaThread* current = THREAD;

11
src/hotspot/share/runtime/synchronizer.hpp
View File

@ -79,11 +79,6 @@ class ObjectMonitorsHashtable {
return (listpp == nullptr) ? nullptr : *listpp;
}
bool has_entry(void* key) {
PtrList** listpp = _ptrs->get(key);
return listpp != nullptr && *listpp != nullptr;
}
bool has_entry(void* key, ObjectMonitor* om);
size_t key_count() { return _key_count; }
@ -159,11 +154,6 @@ class ObjectSynchronizer : AllStatic {
static bool quick_notify(oopDesc* obj, JavaThread* current, bool All);
static bool quick_enter(oop obj, JavaThread* current, BasicLock* Lock);
// Special internal-use-only method for use by JVM infrastructure
// that needs to wait() on a java-level object but must not respond
// to interrupt requests and doesn't timeout.
static void wait_uninterruptibly(Handle obj, JavaThread* current);
// used by classloading to free classloader object lock,
// wait on an internal lock, and reclaim original lock
// with original recursion count
@ -266,7 +256,6 @@ class ObjectLocker : public StackObj {
// Monitor behavior
void wait(TRAPS) { ObjectSynchronizer::wait(_obj, 0, CHECK); } // wait forever
void notify_all(TRAPS) { ObjectSynchronizer::notifyall(_obj, CHECK); }
void wait_uninterruptibly(JavaThread* current) { ObjectSynchronizer::wait_uninterruptibly(_obj, current); }
};
#endif // SHARE_RUNTIME_SYNCHRONIZER_HPP

8
src/hotspot/share/runtime/thread.cpp
View File

@ -368,14 +368,6 @@ bool Thread::is_JavaThread_protected_by_TLH(const JavaThread* target) {
return false;
}
ThreadPriority Thread::get_priority(const Thread* const thread) {
ThreadPriority priority;
// Can return an error!
(void)os::get_priority(thread, priority);
assert(MinPriority <= priority && priority <= MaxPriority, "non-Java priority found");
return priority;
}
void Thread::set_priority(Thread* thread, ThreadPriority priority) {
debug_only(check_for_dangling_thread_pointer(thread);)
// Can return an error!

6
src/hotspot/share/runtime/thread.hpp
View File

@ -119,10 +119,6 @@ class Thread: public ThreadShadow {
uint64_t _nmethod_disarm_value;
public:
int nmethod_disarm_value() {
return (int)(uint32_t)_nmethod_disarm_value;
}
void set_nmethod_disarm_value(int value) {
_nmethod_disarm_value = (uint64_t)(uint32_t)value;
}
@ -324,7 +320,6 @@ class Thread: public ThreadShadow {
virtual bool is_Java_thread() const { return false; }
virtual bool is_Compiler_thread() const { return false; }
virtual bool is_service_thread() const { return false; }
virtual bool is_monitor_deflation_thread() const { return false; }
virtual bool is_hidden_from_external_view() const { return false; }
virtual bool is_jvmti_agent_thread() const { return false; }
virtual bool is_Watcher_thread() const { return false; }
@ -363,7 +358,6 @@ class Thread: public ThreadShadow {
static void check_for_dangling_thread_pointer(Thread *thread);
#endif
static void set_priority(Thread* thread, ThreadPriority priority);
static ThreadPriority get_priority(const Thread* const thread);
static void start(Thread* thread);
void set_native_thread_name(const char *name) {

1
src/hotspot/share/runtime/threadHeapSampler.hpp
View File

@ -54,7 +54,6 @@ class ThreadHeapSampler {
}
size_t bytes_until_sample() { return _bytes_until_sample; }
void set_bytes_until_sample(size_t bytes) { _bytes_until_sample = bytes; }
void check_for_sampling(oop obj, size_t size_in_bytes, size_t bytes_allocated_before);

23
src/hotspot/share/runtime/threadSMR.hpp
View File

@ -122,8 +122,6 @@ class ThreadsSMRSupport : AllStatic {
static uint _to_delete_list_cnt;
static uint _to_delete_list_max;
static ThreadsList *acquire_stable_list_fast_path(Thread *self);
static ThreadsList *acquire_stable_list_nested_path(Thread *self);
static void add_deleted_thread_times(uint add_value);
static void add_tlh_times(uint add_value);
static void clear_delete_notify();
@ -139,7 +137,6 @@ class ThreadsSMRSupport : AllStatic {
static void update_deleted_thread_time_max(uint new_value);
static void update_java_thread_list_max(uint new_value);
static void update_tlh_time_max(uint new_value);
static void verify_hazard_ptr_scanned(Thread *self, ThreadsList *threads);
static ThreadsList* xchg_java_thread_list(ThreadsList* new_list);
public:
@ -274,17 +271,6 @@ public:
}
}
// Constructor that transfers ownership of the pointer.
SafeThreadsListPtr(SafeThreadsListPtr& other) :
_previous(other._previous),
_thread(other._thread),
_list(other._list),
_has_ref_count(other._has_ref_count),
_needs_release(other._needs_release)
{
other._needs_release = false;
}
~SafeThreadsListPtr() {
if (_needs_release) {
release_stable_list();
@ -332,11 +318,6 @@ public:
inline Iterator begin();
inline Iterator end();
template <class T>
void threads_do(T *cl) const {
return list()->threads_do(cl);
}
bool cv_internal_thread_to_JavaThread(jobject jthread, JavaThread ** jt_pp, oop * thread_oop_p);
bool includes(JavaThread* p) {
@ -378,10 +359,6 @@ public:
return _list->length();
}
ThreadsList *list() const {
return _list;
}
JavaThread *next() {
if (++_index >= length()) {
return NULL;

1
src/hotspot/share/runtime/threadStatisticalInfo.hpp
View File

@ -39,7 +39,6 @@ class ThreadStatisticalInfo {
public:
ThreadStatisticalInfo() : _start_time_stamp(os::javaTimeNanos()), _define_class_count(0) {}
uint64_t getDefineClassCount() const { return _define_class_count; }
void setDefineClassCount(uint64_t defineClassCount) { _define_class_count = defineClassCount; }
void incr_define_class_count() { _define_class_count += 1; }
uint64_t getElapsedTime() const { return nanos_to_millis(os::javaTimeNanos() - _start_time_stamp); }
};

6
src/hotspot/share/runtime/threads.cpp
View File

@ -246,12 +246,6 @@ void Threads::java_threads_do(ThreadClosure* tc) {
}
}
void Threads::java_threads_and_vm_thread_do(ThreadClosure* tc) {
assert_locked_or_safepoint(Threads_lock);
java_threads_do(tc);
tc->do_thread(VMThread::vm_thread());
}
// All JavaThreads + all non-JavaThreads (i.e., every thread in the system).
void Threads::threads_do(ThreadClosure* tc) {
assert_locked_or_safepoint(Threads_lock);

1
src/hotspot/share/runtime/threads.hpp
View File

@ -66,7 +66,6 @@ class Threads: AllStatic {
static void remove(JavaThread* p, bool is_daemon);
static void non_java_threads_do(ThreadClosure* tc);
static void java_threads_do(ThreadClosure* tc);
static void java_threads_and_vm_thread_do(ThreadClosure* tc);
static void threads_do(ThreadClosure* tc);
static void possibly_parallel_threads_do(bool is_par, ThreadClosure* tc);

1
src/hotspot/share/runtime/timer.hpp
View File

@ -55,7 +55,6 @@ class TimeStamp {
jlong _counter;
public:
TimeStamp() { _counter = 0; }
void clear() { _counter = 0; }
// has the timestamp been updated since being created or cleared?
bool is_updated() const { return _counter != 0; }
// update to current elapsed time

8
src/hotspot/share/runtime/timerTrace.hpp
View File

@ -67,14 +67,6 @@ class TraceTime: public StackObj {
TraceTimerLogPrintFunc ttlpf);
~TraceTime();
// Accessors
void set_verbose(bool verbose) { _verbose = verbose; }
bool verbose() const { return _verbose; }
// Activation
void suspend() { if (_active) _t.stop(); }
void resume() { if (_active) _t.start(); }
};

92
src/hotspot/share/runtime/vframe.cpp
View File

@ -62,25 +62,6 @@ vframe::vframe(const frame* fr, const RegisterMap* reg_map, JavaThread* thread)
_fr = *fr;
}
vframe::vframe(const frame* fr, JavaThread* thread)
: _reg_map(thread,
RegisterMap::UpdateMap::include,
RegisterMap::ProcessFrames::include,
RegisterMap::WalkContinuation::skip),
_thread(thread), _chunk() {
assert(fr != NULL, "must have frame");
_fr = *fr;
assert(!_reg_map.in_cont(), "");
}
vframe* vframe::new_vframe(StackFrameStream& fst, JavaThread* thread) {
if (fst.current()->is_runtime_frame()) {
fst.next();
}
guarantee(!fst.is_done(), "missing caller");
return new_vframe(fst.current(), fst.register_map(), thread);
}
vframe* vframe::new_vframe(const frame* f, const RegisterMap* reg_map, JavaThread* thread) {
// Interpreter frame
if (f->is_interpreted_frame()) {
@ -126,13 +107,6 @@ bool vframe::is_vthread_entry() const {
return _fr.is_first_vthread_frame(register_map()->thread());
}
vframe* vframe::top() const {
vframe* vf = (vframe*) this;
while (!vf->is_top()) vf = vf->sender();
return vf;
}
javaVFrame* vframe::java_sender() const {
vframe* f = sender();
while (f != NULL) {
@ -295,18 +269,12 @@ u_char* interpretedVFrame::bcp() const {
return stack_chunk() == NULL ? fr().interpreter_frame_bcp() : stack_chunk()->interpreter_frame_bcp(fr());
}
void interpretedVFrame::set_bcp(u_char* bcp) {
assert(stack_chunk() == NULL, "Not supported for heap frames"); // unsupported for now because seems to be unused
fr().interpreter_frame_set_bcp(bcp);
}
intptr_t* interpretedVFrame::locals_addr_at(int offset) const {
assert(stack_chunk() == NULL, "Not supported for heap frames"); // unsupported for now because seems to be unused
assert(fr().is_interpreted_frame(), "frame should be an interpreted frame");
return fr().interpreter_frame_local_at(offset);
}
GrowableArray<MonitorInfo*>* interpretedVFrame::monitors() const {
GrowableArray<MonitorInfo*>* result = new GrowableArray<MonitorInfo*>(5);
if (stack_chunk() == NULL) { // no monitors in continuations
@ -520,22 +488,6 @@ void vframeStreamCommon::found_bad_method_frame() const {
}
#endif
// top-frame will be skipped
vframeStream::vframeStream(JavaThread* thread, frame top_frame,
bool stop_at_java_call_stub) :
vframeStreamCommon(RegisterMap(thread,
RegisterMap::UpdateMap::include,
RegisterMap::ProcessFrames::include,
RegisterMap::WalkContinuation::include)) {
_stop_at_java_call_stub = stop_at_java_call_stub;
// skip top frame, as it may not be at safepoint
_frame = top_frame.sender(&_reg_map);
while (!fill_from_frame()) {
_frame = _frame.sender(&_reg_map);
}
}
vframeStream::vframeStream(JavaThread* thread, Handle continuation_scope, bool stop_at_java_call_stub)
: vframeStreamCommon(RegisterMap(thread,
RegisterMap::UpdateMap::include,
@ -767,40 +719,6 @@ void javaVFrame::print_value() const {
}
}
bool javaVFrame::structural_compare(javaVFrame* other) {
// Check static part
if (method() != other->method()) return false;
if (bci() != other->bci()) return false;
// Check locals
StackValueCollection *locs = locals();
StackValueCollection *other_locs = other->locals();
assert(locs->size() == other_locs->size(), "sanity check");
int i;
for(i = 0; i < locs->size(); i++) {
// it might happen the compiler reports a conflict and
// the interpreter reports a bogus int.
if ( is_compiled_frame() && locs->at(i)->type() == T_CONFLICT) continue;
if (other->is_compiled_frame() && other_locs->at(i)->type() == T_CONFLICT) continue;
if (!locs->at(i)->equal(other_locs->at(i)))
return false;
}
// Check expressions
StackValueCollection* exprs = expressions();
StackValueCollection* other_exprs = other->expressions();
assert(exprs->size() == other_exprs->size(), "sanity check");
for(i = 0; i < exprs->size(); i++) {
if (!exprs->at(i)->equal(other_exprs->at(i)))
return false;
}
return true;
}
void javaVFrame::print_activation(int index) const {
// frame number and method
tty->print("%2d - ", index);
@ -813,22 +731,12 @@ void javaVFrame::print_activation(int index) const {
}
}
void javaVFrame::verify() const {
}
void interpretedVFrame::verify() const {
}
// ------------- externalVFrame --------------
void externalVFrame::print() {
_fr.print_value_on(tty,NULL);
}
void externalVFrame::print_value() const {
((vframe*)this)->print();
}

36
src/hotspot/share/runtime/vframe.hpp
View File

@ -63,20 +63,14 @@ class vframe: public ResourceObj {
stackChunkHandle _chunk;
vframe(const frame* fr, const RegisterMap* reg_map, JavaThread* thread);
vframe(const frame* fr, JavaThread* thread);
public:
// Factory methods for creating vframes
static vframe* new_vframe(const frame* f, const RegisterMap *reg_map, JavaThread* thread);
static vframe* new_vframe(StackFrameStream& fst, JavaThread* thread);
// Accessors
frame fr() const { return _fr; }
CodeBlob* cb() const { return _fr.cb(); }
CompiledMethod* nm() const {
assert( cb() != NULL && cb()->is_compiled(), "usage");
return (CompiledMethod*) cb();
}
// ???? Does this need to be a copy?
frame* frame_pointer() { return &_fr; }
@ -97,9 +91,6 @@ class vframe: public ResourceObj {
// is in the caller frame
virtual bool is_top() const { return true; }
// Returns top vframe within same frame (see is_top())
virtual vframe* top() const;
// Type testing operations
virtual bool is_entry_frame() const { return false; }
virtual bool is_java_frame() const { return false; }
@ -135,7 +126,6 @@ class javaVFrame: public vframe {
protected:
javaVFrame(const frame* fr, const RegisterMap* reg_map, JavaThread* thread) : vframe(fr, reg_map, thread) {}
javaVFrame(const frame* fr, JavaThread* thread) : vframe(fr, thread) {}
public:
// casting
@ -158,12 +148,6 @@ class javaVFrame: public vframe {
void print();
void print_value() const;
void print_activation(int index) const;
// verify operations
virtual void verify() const;
// Structural compare
bool structural_compare(javaVFrame* other);
#endif
friend class vframe;
};
@ -188,7 +172,6 @@ class interpretedVFrame: public javaVFrame {
public:
// Accessors for Byte Code Pointer
u_char* bcp() const;
void set_bcp(u_char* bcp);
// casting
static interpretedVFrame* cast(vframe* vf) {
@ -200,14 +183,7 @@ class interpretedVFrame: public javaVFrame {
static const int bcp_offset;
intptr_t* locals_addr_at(int offset) const;
StackValueCollection* stack_data(bool expressions) const;
// returns where the parameters starts relative to the frame pointer
int start_of_parameters() const;
#ifndef PRODUCT
public:
// verify operations
void verify() const;
#endif
friend class vframe;
};
@ -232,13 +208,6 @@ class entryVFrame: public externalVFrame {
protected:
entryVFrame(const frame* fr, const RegisterMap* reg_map, JavaThread* thread);
public:
// casting
static entryVFrame* cast(vframe* vf) {
assert(vf == NULL || vf->is_entry_frame(), "must be entry frame");
return (entryVFrame*) vf;
}
#ifndef PRODUCT
public:
// printing
@ -330,13 +299,11 @@ class vframeStreamCommon : StackObj {
}
const RegisterMap* reg_map() { return &_reg_map; }
void dont_walk_cont() { _reg_map.set_walk_cont(false); }
javaVFrame* asJavaVFrame();
// Frame type
inline bool is_interpreted_frame() const;
inline bool is_entry_frame() const;
// Iteration
inline void next();
@ -356,9 +323,6 @@ class vframeStream : public vframeStreamCommon {
vframeStream(JavaThread* thread, Handle continuation_scope, bool stop_at_java_call_stub = false);
// top_frame may not be at safepoint, start with sender
vframeStream(JavaThread* thread, frame top_frame, bool stop_at_java_call_stub = false);
vframeStream(oop continuation, Handle continuation_scope = Handle());
};

2
src/hotspot/share/runtime/vframe.inline.hpp
View File

@ -70,8 +70,6 @@ inline int vframeStreamCommon::decode_offset() const {
inline bool vframeStreamCommon::is_interpreted_frame() const { return _frame.is_interpreted_frame(); }
inline bool vframeStreamCommon::is_entry_frame() const { return _frame.is_entry_frame(); }
inline void vframeStreamCommon::next() {
// handle frames with inlining
if (_mode == compiled_mode && fill_in_compiled_inlined_sender()) return;

5
src/hotspot/share/runtime/vframeArray.cpp
View File

@ -547,10 +547,7 @@ void vframeArray::fill_in(JavaThread* thread,
jint* src = (jint*) reg_map->location(VMRegImpl::as_VMReg(i), _caller.sp());
_callee_registers[i] = src != NULL ? *src : NULL_WORD;
#endif
if (src == NULL) {
set_location_valid(i, false);
} else {
set_location_valid(i, true);
if (src != NULL) {
jint* dst = (jint*) register_location(i);
*dst = *src;
}

15
src/hotspot/share/runtime/vframeArray.hpp
View File

@ -141,7 +141,6 @@ class vframeArray: public CHeapObj<mtCompiler> {
*/
JavaThread* _owner_thread;
vframeArray* _next;
frame _original; // the original frame of the deoptee
frame _caller; // caller of root frame in vframeArray
frame _sender;
@ -152,15 +151,9 @@ class vframeArray: public CHeapObj<mtCompiler> {
int _frames; // number of javavframes in the array (does not count any adapter)
intptr_t _callee_registers[RegisterMap::reg_count];
unsigned char _valid[RegisterMap::reg_count];
vframeArrayElement _elements[1]; // First variable section.
void fill_in_element(int index, compiledVFrame* vf);
bool is_location_valid(int i) const { return _valid[i] != 0; }
void set_location_valid(int i, bool valid) { _valid[i] = valid; }
public:
@ -183,21 +176,13 @@ class vframeArray: public CHeapObj<mtCompiler> {
// Returns the owner of this vframeArray
JavaThread* owner_thread() const { return _owner_thread; }
// Accessors for next
vframeArray* next() const { return _next; }
void set_next(vframeArray* value) { _next = value; }
// Accessors for sp
intptr_t* sp() const { return _original.sp(); }
intptr_t* unextended_sp() const;
address original_pc() const { return _original.pc(); }
frame original() const { return _original; }
frame caller() const { return _caller; }
frame sender() const { return _sender; }
// Accessors for unroll block

7
src/hotspot/share/runtime/vframe_hp.cpp
View File

@ -535,10 +535,3 @@ jvmtiDeferredLocalVariable::jvmtiDeferredLocalVariable(int index, BasicType type
_type = type;
_value = value;
}
#ifndef PRODUCT
void compiledVFrame::verify() const {
Unimplemented();
}
#endif // PRODUCT

5
src/hotspot/share/runtime/vframe_hp.hpp
View File

@ -98,11 +98,6 @@ class compiledVFrame: public javaVFrame {
private:
compiledVFrame(const frame* fr, const RegisterMap* reg_map, JavaThread* thread, ScopeDesc* scope, int vframe_id);
#ifndef PRODUCT
public:
void verify() const;
#endif
};
#endif // SHARE_RUNTIME_VFRAME_HP_HPP

1
src/hotspot/share/runtime/vmOperations.cpp
View File

@ -117,7 +117,6 @@ void VM_DeoptimizeFrame::doit() {
#ifndef PRODUCT
void VM_DeoptimizeAll::doit() {
DeoptimizationMarker dm;
JavaThreadIteratorWithHandle jtiwh;
// deoptimize all java threads in the system
if (DeoptimizeALot) {

1
src/hotspot/share/runtime/vmStructs.cpp
View File

@ -1071,7 +1071,6 @@
nonstatic_field(CompileTask, _next, CompileTask*) \
nonstatic_field(CompileTask, _prev, CompileTask*) \
\
nonstatic_field(vframeArray, _next, vframeArray*) \
nonstatic_field(vframeArray, _original, frame) \
nonstatic_field(vframeArray, _caller, frame) \
nonstatic_field(vframeArray, _frames, int) \