--- a/hotspot/.hgtags Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/.hgtags Tue Sep 24 10:14:02 2013 +0200
@@ -377,3 +377,5 @@
50794d8ac11c9579b41dec4de23b808fef9f34a1 hs25-b49
5b7f90aab3ad25a25b75b7b2bb18d5ae23d8231c jdk8-b107
a09fe9d1e016c285307507a5793bc4fa6215e9c9 hs25-b50
+85072013aad46050a362d10ab78e963121c8014c jdk8-b108
+566db1b0e6efca31f181456e54c8911d0192410d hs25-b51
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/CommandProcessor.java Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/CommandProcessor.java Tue Sep 24 10:14:02 2013 +0200
@@ -1213,6 +1213,7 @@
}
HotSpotTypeDataBase db = (HotSpotTypeDataBase)agent.getTypeDataBase();
if (t.countTokens() == 1) {
+ String name = t.nextToken();
out.println("intConstant " + name + " " + db.lookupIntConstant(name));
} else if (t.countTokens() == 0) {
Iterator i = db.getIntConstants();
@@ -1235,6 +1236,7 @@
}
HotSpotTypeDataBase db = (HotSpotTypeDataBase)agent.getTypeDataBase();
if (t.countTokens() == 1) {
+ String name = t.nextToken();
out.println("longConstant " + name + " " + db.lookupLongConstant(name));
} else if (t.countTokens() == 0) {
Iterator i = db.getLongConstants();
--- a/hotspot/make/bsd/makefiles/gcc.make Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/make/bsd/makefiles/gcc.make Tue Sep 24 10:14:02 2013 +0200
@@ -80,7 +80,7 @@
HOSTCC = $(CC)
endif
- AS = $(CC) -c -x assembler-with-cpp
+ AS = $(CC) -c
endif
@@ -347,6 +347,13 @@
LDFLAGS += -mmacosx-version-min=$(MACOSX_VERSION_MIN)
endif
+
+#------------------------------------------------------------------------
+# Assembler flags
+
+# Enforce prerpocessing of .s files
+ASFLAGS += -x assembler-with-cpp
+
#------------------------------------------------------------------------
# Linker flags
--- a/hotspot/make/excludeSrc.make Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/make/excludeSrc.make Tue Sep 24 10:14:02 2013 +0200
@@ -99,7 +99,7 @@
psTasks.cpp psVirtualspace.cpp psYoungGen.cpp vmPSOperations.cpp asParNewGeneration.cpp \
parCardTableModRefBS.cpp parGCAllocBuffer.cpp parNewGeneration.cpp mutableSpace.cpp \
gSpaceCounters.cpp allocationStats.cpp spaceCounters.cpp gcAdaptivePolicyCounters.cpp \
- mutableNUMASpace.cpp immutableSpace.cpp yieldingWorkGroup.cpp
+ mutableNUMASpace.cpp immutableSpace.cpp yieldingWorkGroup.cpp hSpaceCounters.cpp
endif
ifeq ($(INCLUDE_NMT), false)
--- a/hotspot/make/hotspot_version Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/make/hotspot_version Tue Sep 24 10:14:02 2013 +0200
@@ -35,7 +35,7 @@
HS_MAJOR_VER=25
HS_MINOR_VER=0
-HS_BUILD_NUMBER=51
+HS_BUILD_NUMBER=52
JDK_MAJOR_VER=1
JDK_MINOR_VER=8
--- a/hotspot/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -1724,14 +1724,6 @@
}
assert_different_registers(obj, k_RInfo, klass_RInfo);
- if (!k->is_loaded()) {
- klass2reg_with_patching(k_RInfo, op->info_for_patch());
- } else {
-#ifdef _LP64
- __ mov_metadata(k_RInfo, k->constant_encoding());
-#endif // _LP64
- }
- assert(obj != k_RInfo, "must be different");
__ cmpptr(obj, (int32_t)NULL_WORD);
if (op->should_profile()) {
@@ -1748,6 +1740,14 @@
} else {
__ jcc(Assembler::equal, *obj_is_null);
}
+
+ if (!k->is_loaded()) {
+ klass2reg_with_patching(k_RInfo, op->info_for_patch());
+ } else {
+#ifdef _LP64
+ __ mov_metadata(k_RInfo, k->constant_encoding());
+#endif // _LP64
+ }
__ verify_oop(obj);
if (op->fast_check()) {
--- a/hotspot/src/cpu/x86/vm/templateInterpreter_x86.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/cpu/x86/vm/templateInterpreter_x86.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -34,9 +34,9 @@
// Run with +PrintInterpreter to get the VM to print out the size.
// Max size with JVMTI
#ifdef AMD64
- const static int InterpreterCodeSize = 200 * 1024;
+ const static int InterpreterCodeSize = 208 * 1024;
#else
- const static int InterpreterCodeSize = 168 * 1024;
+ const static int InterpreterCodeSize = 176 * 1024;
#endif // AMD64
#endif // CPU_X86_VM_TEMPLATEINTERPRETER_X86_HPP
--- a/hotspot/src/os/linux/vm/os_linux.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/os/linux/vm/os_linux.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -131,6 +131,7 @@
bool os::Linux::_supports_fast_thread_cpu_time = false;
const char * os::Linux::_glibc_version = NULL;
const char * os::Linux::_libpthread_version = NULL;
+pthread_condattr_t os::Linux::_condattr[1];
static jlong initial_time_count=0;
@@ -1399,12 +1400,15 @@
clock_gettime_func(CLOCK_MONOTONIC, &tp) == 0) {
// yes, monotonic clock is supported
_clock_gettime = clock_gettime_func;
+ return;
} else {
// close librt if there is no monotonic clock
dlclose(handle);
}
}
}
+ warning("No monotonic clock was available - timed services may " \
+ "be adversely affected if the time-of-day clock changes");
}
#ifndef SYS_clock_getres
@@ -2165,23 +2169,49 @@
}
// Try to identify popular distros.
-// Most Linux distributions have /etc/XXX-release file, which contains
-// the OS version string. Some have more than one /etc/XXX-release file
-// (e.g. Mandrake has both /etc/mandrake-release and /etc/redhat-release.),
-// so the order is important.
+// Most Linux distributions have a /etc/XXX-release file, which contains
+// the OS version string. Newer Linux distributions have a /etc/lsb-release
+// file that also contains the OS version string. Some have more than one
+// /etc/XXX-release file (e.g. Mandrake has both /etc/mandrake-release and
+// /etc/redhat-release.), so the order is important.
+// Any Linux that is based on Redhat (i.e. Oracle, Mandrake, Sun JDS...) have
+// their own specific XXX-release file as well as a redhat-release file.
+// Because of this the XXX-release file needs to be searched for before the
+// redhat-release file.
+// Since Red Hat has a lsb-release file that is not very descriptive the
+// search for redhat-release needs to be before lsb-release.
+// Since the lsb-release file is the new standard it needs to be searched
+// before the older style release files.
+// Searching system-release (Red Hat) and os-release (other Linuxes) are a
+// next to last resort. The os-release file is a new standard that contains
+// distribution information and the system-release file seems to be an old
+// standard that has been replaced by the lsb-release and os-release files.
+// Searching for the debian_version file is the last resort. It contains
+// an informative string like "6.0.6" or "wheezy/sid". Because of this
+// "Debian " is printed before the contents of the debian_version file.
void os::Linux::print_distro_info(outputStream* st) {
- if (!_print_ascii_file("/etc/mandrake-release", st) &&
- !_print_ascii_file("/etc/sun-release", st) &&
- !_print_ascii_file("/etc/redhat-release", st) &&
- !_print_ascii_file("/etc/SuSE-release", st) &&
- !_print_ascii_file("/etc/turbolinux-release", st) &&
- !_print_ascii_file("/etc/gentoo-release", st) &&
- !_print_ascii_file("/etc/debian_version", st) &&
- !_print_ascii_file("/etc/ltib-release", st) &&
- !_print_ascii_file("/etc/angstrom-version", st)) {
- st->print("Linux");
- }
- st->cr();
+ if (!_print_ascii_file("/etc/oracle-release", st) &&
+ !_print_ascii_file("/etc/mandriva-release", st) &&
+ !_print_ascii_file("/etc/mandrake-release", st) &&
+ !_print_ascii_file("/etc/sun-release", st) &&
+ !_print_ascii_file("/etc/redhat-release", st) &&
+ !_print_ascii_file("/etc/lsb-release", st) &&
+ !_print_ascii_file("/etc/SuSE-release", st) &&
+ !_print_ascii_file("/etc/turbolinux-release", st) &&
+ !_print_ascii_file("/etc/gentoo-release", st) &&
+ !_print_ascii_file("/etc/ltib-release", st) &&
+ !_print_ascii_file("/etc/angstrom-version", st) &&
+ !_print_ascii_file("/etc/system-release", st) &&
+ !_print_ascii_file("/etc/os-release", st)) {
+
+ if (file_exists("/etc/debian_version")) {
+ st->print("Debian ");
+ _print_ascii_file("/etc/debian_version", st);
+ } else {
+ st->print("Linux");
+ }
+ }
+ st->cr();
}
void os::Linux::print_libversion_info(outputStream* st) {
@@ -4709,6 +4739,26 @@
Linux::clock_init();
initial_time_count = os::elapsed_counter();
+
+ // pthread_condattr initialization for monotonic clock
+ int status;
+ pthread_condattr_t* _condattr = os::Linux::condAttr();
+ if ((status = pthread_condattr_init(_condattr)) != 0) {
+ fatal(err_msg("pthread_condattr_init: %s", strerror(status)));
+ }
+ // Only set the clock if CLOCK_MONOTONIC is available
+ if (Linux::supports_monotonic_clock()) {
+ if ((status = pthread_condattr_setclock(_condattr, CLOCK_MONOTONIC)) != 0) {
+ if (status == EINVAL) {
+ warning("Unable to use monotonic clock with relative timed-waits" \
+ " - changes to the time-of-day clock may have adverse affects");
+ } else {
+ fatal(err_msg("pthread_condattr_setclock: %s", strerror(status)));
+ }
+ }
+ }
+ // else it defaults to CLOCK_REALTIME
+
pthread_mutex_init(&dl_mutex, NULL);
// If the pagesize of the VM is greater than 8K determine the appropriate
@@ -5517,21 +5567,36 @@
static struct timespec* compute_abstime(timespec* abstime, jlong millis) {
if (millis < 0) millis = 0;
- struct timeval now;
- int status = gettimeofday(&now, NULL);
- assert(status == 0, "gettimeofday");
+
jlong seconds = millis / 1000;
millis %= 1000;
if (seconds > 50000000) { // see man cond_timedwait(3T)
seconds = 50000000;
}
- abstime->tv_sec = now.tv_sec + seconds;
- long usec = now.tv_usec + millis * 1000;
- if (usec >= 1000000) {
- abstime->tv_sec += 1;
- usec -= 1000000;
- }
- abstime->tv_nsec = usec * 1000;
+
+ if (os::Linux::supports_monotonic_clock()) {
+ struct timespec now;
+ int status = os::Linux::clock_gettime(CLOCK_MONOTONIC, &now);
+ assert_status(status == 0, status, "clock_gettime");
+ abstime->tv_sec = now.tv_sec + seconds;
+ long nanos = now.tv_nsec + millis * NANOSECS_PER_MILLISEC;
+ if (nanos >= NANOSECS_PER_SEC) {
+ abstime->tv_sec += 1;
+ nanos -= NANOSECS_PER_SEC;
+ }
+ abstime->tv_nsec = nanos;
+ } else {
+ struct timeval now;
+ int status = gettimeofday(&now, NULL);
+ assert(status == 0, "gettimeofday");
+ abstime->tv_sec = now.tv_sec + seconds;
+ long usec = now.tv_usec + millis * 1000;
+ if (usec >= 1000000) {
+ abstime->tv_sec += 1;
+ usec -= 1000000;
+ }
+ abstime->tv_nsec = usec * 1000;
+ }
return abstime;
}
@@ -5623,7 +5688,7 @@
status = os::Linux::safe_cond_timedwait(_cond, _mutex, &abst);
if (status != 0 && WorkAroundNPTLTimedWaitHang) {
pthread_cond_destroy (_cond);
- pthread_cond_init (_cond, NULL) ;
+ pthread_cond_init (_cond, os::Linux::condAttr()) ;
}
assert_status(status == 0 || status == EINTR ||
status == ETIME || status == ETIMEDOUT,
@@ -5724,32 +5789,50 @@
static void unpackTime(timespec* absTime, bool isAbsolute, jlong time) {
assert (time > 0, "convertTime");
-
- struct timeval now;
- int status = gettimeofday(&now, NULL);
- assert(status == 0, "gettimeofday");
-
- time_t max_secs = now.tv_sec + MAX_SECS;
-
- if (isAbsolute) {
- jlong secs = time / 1000;
- if (secs > max_secs) {
- absTime->tv_sec = max_secs;
+ time_t max_secs = 0;
+
+ if (!os::Linux::supports_monotonic_clock() || isAbsolute) {
+ struct timeval now;
+ int status = gettimeofday(&now, NULL);
+ assert(status == 0, "gettimeofday");
+
+ max_secs = now.tv_sec + MAX_SECS;
+
+ if (isAbsolute) {
+ jlong secs = time / 1000;
+ if (secs > max_secs) {
+ absTime->tv_sec = max_secs;
+ } else {
+ absTime->tv_sec = secs;
+ }
+ absTime->tv_nsec = (time % 1000) * NANOSECS_PER_MILLISEC;
+ } else {
+ jlong secs = time / NANOSECS_PER_SEC;
+ if (secs >= MAX_SECS) {
+ absTime->tv_sec = max_secs;
+ absTime->tv_nsec = 0;
+ } else {
+ absTime->tv_sec = now.tv_sec + secs;
+ absTime->tv_nsec = (time % NANOSECS_PER_SEC) + now.tv_usec*1000;
+ if (absTime->tv_nsec >= NANOSECS_PER_SEC) {
+ absTime->tv_nsec -= NANOSECS_PER_SEC;
+ ++absTime->tv_sec; // note: this must be <= max_secs
+ }
+ }
}
- else {
- absTime->tv_sec = secs;
- }
- absTime->tv_nsec = (time % 1000) * NANOSECS_PER_MILLISEC;
- }
- else {
+ } else {
+ // must be relative using monotonic clock
+ struct timespec now;
+ int status = os::Linux::clock_gettime(CLOCK_MONOTONIC, &now);
+ assert_status(status == 0, status, "clock_gettime");
+ max_secs = now.tv_sec + MAX_SECS;
jlong secs = time / NANOSECS_PER_SEC;
if (secs >= MAX_SECS) {
absTime->tv_sec = max_secs;
absTime->tv_nsec = 0;
- }
- else {
+ } else {
absTime->tv_sec = now.tv_sec + secs;
- absTime->tv_nsec = (time % NANOSECS_PER_SEC) + now.tv_usec*1000;
+ absTime->tv_nsec = (time % NANOSECS_PER_SEC) + now.tv_nsec;
if (absTime->tv_nsec >= NANOSECS_PER_SEC) {
absTime->tv_nsec -= NANOSECS_PER_SEC;
++absTime->tv_sec; // note: this must be <= max_secs
@@ -5829,15 +5912,19 @@
jt->set_suspend_equivalent();
// cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
+ assert(_cur_index == -1, "invariant");
if (time == 0) {
- status = pthread_cond_wait (_cond, _mutex) ;
+ _cur_index = REL_INDEX; // arbitrary choice when not timed
+ status = pthread_cond_wait (&_cond[_cur_index], _mutex) ;
} else {
- status = os::Linux::safe_cond_timedwait (_cond, _mutex, &absTime) ;
+ _cur_index = isAbsolute ? ABS_INDEX : REL_INDEX;
+ status = os::Linux::safe_cond_timedwait (&_cond[_cur_index], _mutex, &absTime) ;
if (status != 0 && WorkAroundNPTLTimedWaitHang) {
- pthread_cond_destroy (_cond) ;
- pthread_cond_init (_cond, NULL);
+ pthread_cond_destroy (&_cond[_cur_index]) ;
+ pthread_cond_init (&_cond[_cur_index], isAbsolute ? NULL : os::Linux::condAttr());
}
}
+ _cur_index = -1;
assert_status(status == 0 || status == EINTR ||
status == ETIME || status == ETIMEDOUT,
status, "cond_timedwait");
@@ -5866,17 +5953,24 @@
s = _counter;
_counter = 1;
if (s < 1) {
- if (WorkAroundNPTLTimedWaitHang) {
- status = pthread_cond_signal (_cond) ;
- assert (status == 0, "invariant") ;
+ // thread might be parked
+ if (_cur_index != -1) {
+ // thread is definitely parked
+ if (WorkAroundNPTLTimedWaitHang) {
+ status = pthread_cond_signal (&_cond[_cur_index]);
+ assert (status == 0, "invariant");
status = pthread_mutex_unlock(_mutex);
- assert (status == 0, "invariant") ;
- } else {
+ assert (status == 0, "invariant");
+ } else {
status = pthread_mutex_unlock(_mutex);
- assert (status == 0, "invariant") ;
- status = pthread_cond_signal (_cond) ;
- assert (status == 0, "invariant") ;
- }
+ assert (status == 0, "invariant");
+ status = pthread_cond_signal (&_cond[_cur_index]);
+ assert (status == 0, "invariant");
+ }
+ } else {
+ pthread_mutex_unlock(_mutex);
+ assert (status == 0, "invariant") ;
+ }
} else {
pthread_mutex_unlock(_mutex);
assert (status == 0, "invariant") ;
--- a/hotspot/src/os/linux/vm/os_linux.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/os/linux/vm/os_linux.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -221,6 +221,13 @@
static jlong fast_thread_cpu_time(clockid_t clockid);
+ // pthread_cond clock suppport
+ private:
+ static pthread_condattr_t _condattr[1];
+
+ public:
+ static pthread_condattr_t* condAttr() { return _condattr; }
+
// Stack repair handling
// none present
@@ -295,7 +302,7 @@
public:
PlatformEvent() {
int status;
- status = pthread_cond_init (_cond, NULL);
+ status = pthread_cond_init (_cond, os::Linux::condAttr());
assert_status(status == 0, status, "cond_init");
status = pthread_mutex_init (_mutex, NULL);
assert_status(status == 0, status, "mutex_init");
@@ -310,14 +317,19 @@
void park () ;
void unpark () ;
int TryPark () ;
- int park (jlong millis) ;
+ int park (jlong millis) ; // relative timed-wait only
void SetAssociation (Thread * a) { _Assoc = a ; }
} ;
class PlatformParker : public CHeapObj<mtInternal> {
protected:
+ enum {
+ REL_INDEX = 0,
+ ABS_INDEX = 1
+ };
+ int _cur_index; // which cond is in use: -1, 0, 1
pthread_mutex_t _mutex [1] ;
- pthread_cond_t _cond [1] ;
+ pthread_cond_t _cond [2] ; // one for relative times and one for abs.
public: // TODO-FIXME: make dtor private
~PlatformParker() { guarantee (0, "invariant") ; }
@@ -325,10 +337,13 @@
public:
PlatformParker() {
int status;
- status = pthread_cond_init (_cond, NULL);
- assert_status(status == 0, status, "cond_init");
+ status = pthread_cond_init (&_cond[REL_INDEX], os::Linux::condAttr());
+ assert_status(status == 0, status, "cond_init rel");
+ status = pthread_cond_init (&_cond[ABS_INDEX], NULL);
+ assert_status(status == 0, status, "cond_init abs");
status = pthread_mutex_init (_mutex, NULL);
assert_status(status == 0, status, "mutex_init");
+ _cur_index = -1; // mark as unused
}
};
--- a/hotspot/src/os/windows/vm/decoder_windows.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/os/windows/vm/decoder_windows.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -32,7 +32,11 @@
_can_decode_in_vm = false;
_pfnSymGetSymFromAddr64 = NULL;
_pfnUndecorateSymbolName = NULL;
-
+#ifdef AMD64
+ _pfnStackWalk64 = NULL;
+ _pfnSymFunctionTableAccess64 = NULL;
+ _pfnSymGetModuleBase64 = NULL;
+#endif
_decoder_status = no_error;
initialize();
}
@@ -53,14 +57,24 @@
_pfnUndecorateSymbolName = (pfn_UndecorateSymbolName)::GetProcAddress(handle, "UnDecorateSymbolName");
if (_pfnSymSetOptions == NULL || _pfnSymInitialize == NULL || _pfnSymGetSymFromAddr64 == NULL) {
- _pfnSymGetSymFromAddr64 = NULL;
- _pfnUndecorateSymbolName = NULL;
- ::FreeLibrary(handle);
- _dbghelp_handle = NULL;
+ uninitialize();
_decoder_status = helper_func_error;
return;
}
+#ifdef AMD64
+ _pfnStackWalk64 = (pfn_StackWalk64)::GetProcAddress(handle, "StackWalk64");
+ _pfnSymFunctionTableAccess64 = (pfn_SymFunctionTableAccess64)::GetProcAddress(handle, "SymFunctionTableAccess64");
+ _pfnSymGetModuleBase64 = (pfn_SymGetModuleBase64)::GetProcAddress(handle, "SymGetModuleBase64");
+ if (_pfnStackWalk64 == NULL || _pfnSymFunctionTableAccess64 == NULL || _pfnSymGetModuleBase64 == NULL) {
+ // We can't call StackWalk64 to walk the stack, but we are still
+ // able to decode the symbols. Let's limp on.
+ _pfnStackWalk64 = NULL;
+ _pfnSymFunctionTableAccess64 = NULL;
+ _pfnSymGetModuleBase64 = NULL;
+ }
+#endif
+
HANDLE hProcess = ::GetCurrentProcess();
_pfnSymSetOptions(SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS | SYMOPT_EXACT_SYMBOLS);
if (!_pfnSymInitialize(hProcess, NULL, TRUE)) {
@@ -156,6 +170,11 @@
void WindowsDecoder::uninitialize() {
_pfnSymGetSymFromAddr64 = NULL;
_pfnUndecorateSymbolName = NULL;
+#ifdef AMD64
+ _pfnStackWalk64 = NULL;
+ _pfnSymFunctionTableAccess64 = NULL;
+ _pfnSymGetModuleBase64 = NULL;
+#endif
if (_dbghelp_handle != NULL) {
::FreeLibrary(_dbghelp_handle);
}
@@ -195,3 +214,65 @@
_pfnUndecorateSymbolName(symbol, buf, buflen, UNDNAME_COMPLETE);
}
+#ifdef AMD64
+BOOL WindowsDbgHelp::StackWalk64(DWORD MachineType,
+ HANDLE hProcess,
+ HANDLE hThread,
+ LPSTACKFRAME64 StackFrame,
+ PVOID ContextRecord,
+ PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,
+ PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,
+ PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,
+ PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress) {
+ DecoderLocker locker;
+ WindowsDecoder* wd = (WindowsDecoder*)locker.decoder();
+
+ if (!wd->has_error() && wd->_pfnStackWalk64) {
+ return wd->_pfnStackWalk64(MachineType,
+ hProcess,
+ hThread,
+ StackFrame,
+ ContextRecord,
+ ReadMemoryRoutine,
+ FunctionTableAccessRoutine,
+ GetModuleBaseRoutine,
+ TranslateAddress);
+ } else {
+ return false;
+ }
+}
+
+PVOID WindowsDbgHelp::SymFunctionTableAccess64(HANDLE hProcess, DWORD64 AddrBase) {
+ DecoderLocker locker;
+ WindowsDecoder* wd = (WindowsDecoder*)locker.decoder();
+
+ if (!wd->has_error() && wd->_pfnSymFunctionTableAccess64) {
+ return wd->_pfnSymFunctionTableAccess64(hProcess, AddrBase);
+ } else {
+ return NULL;
+ }
+}
+
+pfn_SymFunctionTableAccess64 WindowsDbgHelp::pfnSymFunctionTableAccess64() {
+ DecoderLocker locker;
+ WindowsDecoder* wd = (WindowsDecoder*)locker.decoder();
+
+ if (!wd->has_error()) {
+ return wd->_pfnSymFunctionTableAccess64;
+ } else {
+ return NULL;
+ }
+}
+
+pfn_SymGetModuleBase64 WindowsDbgHelp::pfnSymGetModuleBase64() {
+ DecoderLocker locker;
+ WindowsDecoder* wd = (WindowsDecoder*)locker.decoder();
+
+ if (!wd->has_error()) {
+ return wd->_pfnSymGetModuleBase64;
+ } else {
+ return NULL;
+ }
+}
+
+#endif // AMD64
--- a/hotspot/src/os/windows/vm/decoder_windows.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/os/windows/vm/decoder_windows.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -38,6 +38,20 @@
typedef BOOL (WINAPI *pfn_SymSetSearchPath)(HANDLE, PCTSTR);
typedef BOOL (WINAPI *pfn_SymGetSearchPath)(HANDLE, PTSTR, int);
+#ifdef AMD64
+typedef BOOL (WINAPI *pfn_StackWalk64)(DWORD MachineType,
+ HANDLE hProcess,
+ HANDLE hThread,
+ LPSTACKFRAME64 StackFrame,
+ PVOID ContextRecord,
+ PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,
+ PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,
+ PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,
+ PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress);
+typedef PVOID (WINAPI *pfn_SymFunctionTableAccess64)(HANDLE hProcess, DWORD64 AddrBase);
+typedef DWORD64 (WINAPI *pfn_SymGetModuleBase64)(HANDLE hProcess, DWORD64 dwAddr);
+#endif
+
class WindowsDecoder : public AbstractDecoder {
public:
@@ -61,7 +75,34 @@
bool _can_decode_in_vm;
pfn_SymGetSymFromAddr64 _pfnSymGetSymFromAddr64;
pfn_UndecorateSymbolName _pfnUndecorateSymbolName;
+#ifdef AMD64
+ pfn_StackWalk64 _pfnStackWalk64;
+ pfn_SymFunctionTableAccess64 _pfnSymFunctionTableAccess64;
+ pfn_SymGetModuleBase64 _pfnSymGetModuleBase64;
+
+ friend class WindowsDbgHelp;
+#endif
};
+#ifdef AMD64
+// TODO: refactor and move the handling of dbghelp.dll outside of Decoder
+class WindowsDbgHelp : public Decoder {
+public:
+ static BOOL StackWalk64(DWORD MachineType,
+ HANDLE hProcess,
+ HANDLE hThread,
+ LPSTACKFRAME64 StackFrame,
+ PVOID ContextRecord,
+ PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,
+ PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,
+ PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,
+ PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress);
+ static PVOID SymFunctionTableAccess64(HANDLE hProcess, DWORD64 AddrBase);
+
+ static pfn_SymFunctionTableAccess64 pfnSymFunctionTableAccess64();
+ static pfn_SymGetModuleBase64 pfnSymGetModuleBase64();
+};
+#endif
+
#endif // OS_WINDOWS_VM_DECODER_WINDOWS_HPP
--- a/hotspot/src/os/windows/vm/os_windows.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/os/windows/vm/os_windows.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -5430,7 +5430,7 @@
if ((start = strrchr(lib_name, *os::file_separator())) != NULL) {
lib_name = ++start;
} else {
- // Need to check for C:
+ // Need to check for drive prefix
if ((start = strchr(lib_name, ':')) != NULL) {
lib_name = ++start;
}
--- a/hotspot/src/os_cpu/windows_x86/vm/os_windows_x86.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/os_cpu/windows_x86/vm/os_windows_x86.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -29,6 +29,7 @@
#include "classfile/vmSymbols.hpp"
#include "code/icBuffer.hpp"
#include "code/vtableStubs.hpp"
+#include "decoder_windows.hpp"
#include "interpreter/interpreter.hpp"
#include "jvm_windows.h"
#include "memory/allocation.inline.hpp"
@@ -327,6 +328,94 @@
cmpxchg_long_func_t* os::atomic_cmpxchg_long_func = os::atomic_cmpxchg_long_bootstrap;
+#ifdef AMD64
+/*
+ * Windows/x64 does not use stack frames the way expected by Java:
+ * [1] in most cases, there is no frame pointer. All locals are addressed via RSP
+ * [2] in rare cases, when alloca() is used, a frame pointer is used, but this may
+ * not be RBP.
+ * See http://msdn.microsoft.com/en-us/library/ew5tede7.aspx
+ *
+ * So it's not possible to print the native stack using the
+ * while (...) {... fr = os::get_sender_for_C_frame(&fr); }
+ * loop in vmError.cpp. We need to roll our own loop.
+ */
+bool os::platform_print_native_stack(outputStream* st, void* context,
+ char *buf, int buf_size)
+{
+ CONTEXT ctx;
+ if (context != NULL) {
+ memcpy(&ctx, context, sizeof(ctx));
+ } else {
+ RtlCaptureContext(&ctx);
+ }
+
+ st->print_cr("Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)");
+
+ STACKFRAME stk;
+ memset(&stk, 0, sizeof(stk));
+ stk.AddrStack.Offset = ctx.Rsp;
+ stk.AddrStack.Mode = AddrModeFlat;
+ stk.AddrFrame.Offset = ctx.Rbp;
+ stk.AddrFrame.Mode = AddrModeFlat;
+ stk.AddrPC.Offset = ctx.Rip;
+ stk.AddrPC.Mode = AddrModeFlat;
+
+ int count = 0;
+ address lastpc = 0;
+ while (count++ < StackPrintLimit) {
+ intptr_t* sp = (intptr_t*)stk.AddrStack.Offset;
+ intptr_t* fp = (intptr_t*)stk.AddrFrame.Offset; // NOT necessarily the same as ctx.Rbp!
+ address pc = (address)stk.AddrPC.Offset;
+
+ if (pc != NULL && sp != NULL && fp != NULL) {
+ if (count == 2 && lastpc == pc) {
+ // Skip it -- StackWalk64() may return the same PC
+ // (but different SP) on the first try.
+ } else {
+ // Don't try to create a frame(sp, fp, pc) -- on WinX64, stk.AddrFrame
+ // may not contain what Java expects, and may cause the frame() constructor
+ // to crash. Let's just print out the symbolic address.
+ frame::print_C_frame(st, buf, buf_size, pc);
+ st->cr();
+ }
+ lastpc = pc;
+ } else {
+ break;
+ }
+
+ PVOID p = WindowsDbgHelp::SymFunctionTableAccess64(GetCurrentProcess(), stk.AddrPC.Offset);
+ if (!p) {
+ // StackWalk64() can't handle this PC. Calling StackWalk64 again may cause crash.
+ break;
+ }
+
+ BOOL result = WindowsDbgHelp::StackWalk64(
+ IMAGE_FILE_MACHINE_AMD64, // __in DWORD MachineType,
+ GetCurrentProcess(), // __in HANDLE hProcess,
+ GetCurrentThread(), // __in HANDLE hThread,
+ &stk, // __inout LP STACKFRAME64 StackFrame,
+ &ctx, // __inout PVOID ContextRecord,
+ NULL, // __in_opt PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,
+ WindowsDbgHelp::pfnSymFunctionTableAccess64(),
+ // __in_opt PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,
+ WindowsDbgHelp::pfnSymGetModuleBase64(),
+ // __in_opt PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,
+ NULL); // __in_opt PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress
+
+ if (!result) {
+ break;
+ }
+ }
+ if (count > StackPrintLimit) {
+ st->print_cr("...<more frames>...");
+ }
+ st->cr();
+
+ return true;
+}
+#endif // AMD64
+
ExtendedPC os::fetch_frame_from_context(void* ucVoid,
intptr_t** ret_sp, intptr_t** ret_fp) {
@@ -401,6 +490,9 @@
StubRoutines::x86::get_previous_fp_entry());
if (func == NULL) return frame();
intptr_t* fp = (*func)();
+ if (fp == NULL) {
+ return frame();
+ }
#else
intptr_t* fp = _get_previous_fp();
#endif // AMD64
--- a/hotspot/src/os_cpu/windows_x86/vm/os_windows_x86.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/os_cpu/windows_x86/vm/os_windows_x86.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -62,4 +62,10 @@
static bool register_code_area(char *low, char *high);
+#ifdef AMD64
+#define PLATFORM_PRINT_NATIVE_STACK 1
+static bool platform_print_native_stack(outputStream* st, void* context,
+ char *buf, int buf_size);
+#endif
+
#endif // OS_CPU_WINDOWS_X86_VM_OS_WINDOWS_X86_HPP
--- a/hotspot/src/share/tools/LogCompilation/README Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/tools/LogCompilation/README Tue Sep 24 10:14:02 2013 +0200
@@ -4,14 +4,14 @@
requires a 1.5 JDK to build and simply typing make should build it.
It produces a jar file, logc.jar, that can be run on the
-hotspot.log from LogCompilation output like this:
+HotSpot log (by default, hotspot_pid{pid}.log) from LogCompilation output like this:
- java -jar logc.jar hotspot.log
+ java -jar logc.jar hotspot_pid1234.log
This will produce something like the normal PrintCompilation output.
Adding the -i option with also report inlining like PrintInlining.
-More information about the LogCompilation output can be found at
+More information about the LogCompilation output can be found at
https://wikis.oracle.com/display/HotSpotInternals/LogCompilation+overview
https://wikis.oracle.com/display/HotSpotInternals/PrintCompilation
--- a/hotspot/src/share/vm/c1/c1_Runtime1.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/c1/c1_Runtime1.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -709,10 +709,10 @@
Bytecodes::Code code = field_access.code();
// We must load class, initialize class and resolvethe field
- FieldAccessInfo result; // initialize class if needed
+ fieldDescriptor result; // initialize class if needed
constantPoolHandle constants(THREAD, caller->constants());
- LinkResolver::resolve_field(result, constants, field_access.index(), Bytecodes::java_code(code), false, CHECK_NULL);
- return result.klass()();
+ LinkResolver::resolve_field_access(result, constants, field_access.index(), Bytecodes::java_code(code), CHECK_NULL);
+ return result.field_holder();
}
@@ -826,11 +826,11 @@
if (stub_id == Runtime1::access_field_patching_id) {
Bytecode_field field_access(caller_method, bci);
- FieldAccessInfo result; // initialize class if needed
+ fieldDescriptor result; // initialize class if needed
Bytecodes::Code code = field_access.code();
constantPoolHandle constants(THREAD, caller_method->constants());
- LinkResolver::resolve_field(result, constants, field_access.index(), Bytecodes::java_code(code), false, CHECK);
- patch_field_offset = result.field_offset();
+ LinkResolver::resolve_field_access(result, constants, field_access.index(), Bytecodes::java_code(code), CHECK);
+ patch_field_offset = result.offset();
// If we're patching a field which is volatile then at compile it
// must not have been know to be volatile, so the generated code
--- a/hotspot/src/share/vm/ci/ciField.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/ci/ciField.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -75,7 +75,6 @@
assert(klass->get_instanceKlass()->is_linked(), "must be linked before using its constan-pool");
- _cp_index = index;
constantPoolHandle cpool(thread, klass->get_instanceKlass()->constants());
// Get the field's name, signature, and type.
@@ -116,7 +115,7 @@
// The declared holder of this field may not have been loaded.
// Bail out with partial field information.
if (!holder_is_accessible) {
- // _cp_index and _type have already been set.
+ // _type has already been set.
// The default values for _flags and _constant_value will suffice.
// We need values for _holder, _offset, and _is_constant,
_holder = declared_holder;
@@ -146,8 +145,6 @@
ciField::ciField(fieldDescriptor *fd): _known_to_link_with_put(NULL), _known_to_link_with_get(NULL) {
ASSERT_IN_VM;
- _cp_index = -1;
-
// Get the field's name, signature, and type.
ciEnv* env = CURRENT_ENV;
_name = env->get_symbol(fd->name());
@@ -351,12 +348,11 @@
}
}
- FieldAccessInfo result;
- constantPoolHandle c_pool(THREAD,
- accessing_klass->get_instanceKlass()->constants());
- LinkResolver::resolve_field(result, c_pool, _cp_index,
- Bytecodes::java_code(bc),
- true, false, KILL_COMPILE_ON_FATAL_(false));
+ fieldDescriptor result;
+ LinkResolver::resolve_field(result, _holder->get_instanceKlass(),
+ _name->get_symbol(), _signature->get_symbol(),
+ accessing_klass->get_Klass(), bc, true, false,
+ KILL_COMPILE_ON_FATAL_(false));
// update the hit-cache, unless there is a problem with memory scoping:
if (accessing_klass->is_shared() || !is_shared()) {
--- a/hotspot/src/share/vm/ci/ciField.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/ci/ciField.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -53,9 +53,6 @@
ciInstanceKlass* _known_to_link_with_get;
ciConstant _constant_value;
- // Used for will_link
- int _cp_index;
-
ciType* compute_type();
ciType* compute_type_impl();
--- a/hotspot/src/share/vm/ci/ciInstanceKlass.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/ci/ciInstanceKlass.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -522,8 +522,7 @@
for (JavaFieldStream fs(k); !fs.done(); fs.next()) {
if (fs.access_flags().is_static()) continue;
- fieldDescriptor fd;
- fd.initialize(k, fs.index());
+ fieldDescriptor& fd = fs.field_descriptor();
ciField* field = new (arena) ciField(&fd);
fields->append(field);
}
--- a/hotspot/src/share/vm/ci/ciMethod.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/ci/ciMethod.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -286,7 +286,10 @@
check_is_loaded();
assert(holder()->is_linked(), "must be linked");
VM_ENTRY_MARK;
- return klassItable::compute_itable_index(get_Method());
+ Method* m = get_Method();
+ if (!m->has_itable_index())
+ return Method::nonvirtual_vtable_index;
+ return m->itable_index();
}
#endif // SHARK
@@ -1137,6 +1140,10 @@
// ------------------------------------------------------------------
// ciMethod::check_call
bool ciMethod::check_call(int refinfo_index, bool is_static) const {
+ // This method is used only in C2 from InlineTree::ok_to_inline,
+ // and is only used under -Xcomp or -XX:CompileTheWorld.
+ // It appears to fail when applied to an invokeinterface call site.
+ // FIXME: Remove this method and resolve_method_statically; refactor to use the other LinkResolver entry points.
VM_ENTRY_MARK;
{
EXCEPTION_MARK;
--- a/hotspot/src/share/vm/ci/ciSymbol.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/ci/ciSymbol.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -44,6 +44,7 @@
friend class ciInstanceKlass;
friend class ciSignature;
friend class ciMethod;
+ friend class ciField;
friend class ciObjArrayKlass;
private:
--- a/hotspot/src/share/vm/classfile/classFileParser.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/classfile/classFileParser.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -888,6 +888,7 @@
int runtime_visible_type_annotations_length = 0;
u1* runtime_invisible_type_annotations = NULL;
int runtime_invisible_type_annotations_length = 0;
+ bool runtime_invisible_type_annotations_exists = false;
while (attributes_count--) {
cfs->guarantee_more(6, CHECK); // attribute_name_index, attribute_length
u2 attribute_name_index = cfs->get_u2_fast();
@@ -946,15 +947,27 @@
assert(runtime_invisible_annotations != NULL, "null invisible annotations");
cfs->skip_u1(runtime_invisible_annotations_length, CHECK);
} else if (attribute_name == vmSymbols::tag_runtime_visible_type_annotations()) {
+ if (runtime_visible_type_annotations != NULL) {
+ classfile_parse_error(
+ "Multiple RuntimeVisibleTypeAnnotations attributes for field in class file %s", CHECK);
+ }
runtime_visible_type_annotations_length = attribute_length;
runtime_visible_type_annotations = cfs->get_u1_buffer();
assert(runtime_visible_type_annotations != NULL, "null visible type annotations");
cfs->skip_u1(runtime_visible_type_annotations_length, CHECK);
- } else if (PreserveAllAnnotations && attribute_name == vmSymbols::tag_runtime_invisible_type_annotations()) {
- runtime_invisible_type_annotations_length = attribute_length;
- runtime_invisible_type_annotations = cfs->get_u1_buffer();
- assert(runtime_invisible_type_annotations != NULL, "null invisible type annotations");
- cfs->skip_u1(runtime_invisible_type_annotations_length, CHECK);
+ } else if (attribute_name == vmSymbols::tag_runtime_invisible_type_annotations()) {
+ if (runtime_invisible_type_annotations_exists) {
+ classfile_parse_error(
+ "Multiple RuntimeInvisibleTypeAnnotations attributes for field in class file %s", CHECK);
+ } else {
+ runtime_invisible_type_annotations_exists = true;
+ }
+ if (PreserveAllAnnotations) {
+ runtime_invisible_type_annotations_length = attribute_length;
+ runtime_invisible_type_annotations = cfs->get_u1_buffer();
+ assert(runtime_invisible_type_annotations != NULL, "null invisible type annotations");
+ }
+ cfs->skip_u1(attribute_length, CHECK);
} else {
cfs->skip_u1(attribute_length, CHECK); // Skip unknown attributes
}
@@ -2066,6 +2079,7 @@
int runtime_visible_type_annotations_length = 0;
u1* runtime_invisible_type_annotations = NULL;
int runtime_invisible_type_annotations_length = 0;
+ bool runtime_invisible_type_annotations_exists = false;
u1* annotation_default = NULL;
int annotation_default_length = 0;
@@ -2322,16 +2336,30 @@
assert(annotation_default != NULL, "null annotation default");
cfs->skip_u1(annotation_default_length, CHECK_(nullHandle));
} else if (method_attribute_name == vmSymbols::tag_runtime_visible_type_annotations()) {
+ if (runtime_visible_type_annotations != NULL) {
+ classfile_parse_error(
+ "Multiple RuntimeVisibleTypeAnnotations attributes for method in class file %s",
+ CHECK_(nullHandle));
+ }
runtime_visible_type_annotations_length = method_attribute_length;
runtime_visible_type_annotations = cfs->get_u1_buffer();
assert(runtime_visible_type_annotations != NULL, "null visible type annotations");
// No need for the VM to parse Type annotations
cfs->skip_u1(runtime_visible_type_annotations_length, CHECK_(nullHandle));
- } else if (PreserveAllAnnotations && method_attribute_name == vmSymbols::tag_runtime_invisible_type_annotations()) {
- runtime_invisible_type_annotations_length = method_attribute_length;
- runtime_invisible_type_annotations = cfs->get_u1_buffer();
- assert(runtime_invisible_type_annotations != NULL, "null invisible type annotations");
- cfs->skip_u1(runtime_invisible_type_annotations_length, CHECK_(nullHandle));
+ } else if (method_attribute_name == vmSymbols::tag_runtime_invisible_type_annotations()) {
+ if (runtime_invisible_type_annotations_exists) {
+ classfile_parse_error(
+ "Multiple RuntimeInvisibleTypeAnnotations attributes for method in class file %s",
+ CHECK_(nullHandle));
+ } else {
+ runtime_invisible_type_annotations_exists = true;
+ }
+ if (PreserveAllAnnotations) {
+ runtime_invisible_type_annotations_length = method_attribute_length;
+ runtime_invisible_type_annotations = cfs->get_u1_buffer();
+ assert(runtime_invisible_type_annotations != NULL, "null invisible type annotations");
+ }
+ cfs->skip_u1(method_attribute_length, CHECK_(nullHandle));
} else {
// Skip unknown attributes
cfs->skip_u1(method_attribute_length, CHECK_(nullHandle));
@@ -2824,6 +2852,7 @@
int runtime_visible_type_annotations_length = 0;
u1* runtime_invisible_type_annotations = NULL;
int runtime_invisible_type_annotations_length = 0;
+ bool runtime_invisible_type_annotations_exists = false;
u1* inner_classes_attribute_start = NULL;
u4 inner_classes_attribute_length = 0;
u2 enclosing_method_class_index = 0;
@@ -2927,16 +2956,28 @@
parsed_bootstrap_methods_attribute = true;
parse_classfile_bootstrap_methods_attribute(attribute_length, CHECK);
} else if (tag == vmSymbols::tag_runtime_visible_type_annotations()) {
+ if (runtime_visible_type_annotations != NULL) {
+ classfile_parse_error(
+ "Multiple RuntimeVisibleTypeAnnotations attributes in class file %s", CHECK);
+ }
runtime_visible_type_annotations_length = attribute_length;
runtime_visible_type_annotations = cfs->get_u1_buffer();
assert(runtime_visible_type_annotations != NULL, "null visible type annotations");
// No need for the VM to parse Type annotations
cfs->skip_u1(runtime_visible_type_annotations_length, CHECK);
- } else if (PreserveAllAnnotations && tag == vmSymbols::tag_runtime_invisible_type_annotations()) {
- runtime_invisible_type_annotations_length = attribute_length;
- runtime_invisible_type_annotations = cfs->get_u1_buffer();
- assert(runtime_invisible_type_annotations != NULL, "null invisible type annotations");
- cfs->skip_u1(runtime_invisible_type_annotations_length, CHECK);
+ } else if (tag == vmSymbols::tag_runtime_invisible_type_annotations()) {
+ if (runtime_invisible_type_annotations_exists) {
+ classfile_parse_error(
+ "Multiple RuntimeInvisibleTypeAnnotations attributes in class file %s", CHECK);
+ } else {
+ runtime_invisible_type_annotations_exists = true;
+ }
+ if (PreserveAllAnnotations) {
+ runtime_invisible_type_annotations_length = attribute_length;
+ runtime_invisible_type_annotations = cfs->get_u1_buffer();
+ assert(runtime_invisible_type_annotations != NULL, "null invisible type annotations");
+ }
+ cfs->skip_u1(attribute_length, CHECK);
} else {
// Unknown attribute
cfs->skip_u1(attribute_length, CHECK);
@@ -3954,9 +3995,8 @@
this_klass->set_has_final_method();
}
this_klass->copy_method_ordering(method_ordering, CHECK_NULL);
- // The InstanceKlass::_methods_jmethod_ids cache and the
- // InstanceKlass::_methods_cached_itable_indices cache are
- // both managed on the assumption that the initial cache
+ // The InstanceKlass::_methods_jmethod_ids cache
+ // is managed on the assumption that the initial cache
// size is equal to the number of methods in the class. If
// that changes, then InstanceKlass::idnum_can_increment()
// has to be changed accordingly.
--- a/hotspot/src/share/vm/classfile/classLoader.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/classfile/classLoader.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -1319,6 +1319,25 @@
// The CHECK at the caller will propagate the exception out
}
+/**
+ * Returns if the given method should be compiled when doing compile-the-world.
+ *
+ * TODO: This should be a private method in a CompileTheWorld class.
+ */
+static bool can_be_compiled(methodHandle m, int comp_level) {
+ assert(CompileTheWorld, "must be");
+
+ // It's not valid to compile a native wrapper for MethodHandle methods
+ // that take a MemberName appendix since the bytecode signature is not
+ // correct.
+ vmIntrinsics::ID iid = m->intrinsic_id();
+ if (MethodHandles::is_signature_polymorphic(iid) && MethodHandles::has_member_arg(iid)) {
+ return false;
+ }
+
+ return CompilationPolicy::can_be_compiled(m, comp_level);
+}
+
void ClassLoader::compile_the_world_in(char* name, Handle loader, TRAPS) {
int len = (int)strlen(name);
if (len > 6 && strcmp(".class", name + len - 6) == 0) {
@@ -1362,8 +1381,7 @@
int comp_level = CompilationPolicy::policy()->initial_compile_level();
for (int n = 0; n < k->methods()->length(); n++) {
methodHandle m (THREAD, k->methods()->at(n));
- if (CompilationPolicy::can_be_compiled(m, comp_level)) {
-
+ if (can_be_compiled(m, comp_level)) {
if (++_codecache_sweep_counter == CompileTheWorldSafepointInterval) {
// Give sweeper a chance to keep up with CTW
VM_ForceSafepoint op;
@@ -1375,7 +1393,7 @@
methodHandle(), 0, "CTW", THREAD);
if (HAS_PENDING_EXCEPTION) {
clear_pending_exception_if_not_oom(CHECK);
- tty->print_cr("CompileTheWorld (%d) : Skipping method: %s", _compile_the_world_class_counter, m->name()->as_C_string());
+ tty->print_cr("CompileTheWorld (%d) : Skipping method: %s", _compile_the_world_class_counter, m->name_and_sig_as_C_string());
} else {
_compile_the_world_method_counter++;
}
@@ -1391,11 +1409,13 @@
methodHandle(), 0, "CTW", THREAD);
if (HAS_PENDING_EXCEPTION) {
clear_pending_exception_if_not_oom(CHECK);
- tty->print_cr("CompileTheWorld (%d) : Skipping method: %s", _compile_the_world_class_counter, m->name()->as_C_string());
+ tty->print_cr("CompileTheWorld (%d) : Skipping method: %s", _compile_the_world_class_counter, m->name_and_sig_as_C_string());
} else {
_compile_the_world_method_counter++;
}
}
+ } else {
+ tty->print_cr("CompileTheWorld (%d) : Skipping method: %s", _compile_the_world_class_counter, m->name_and_sig_as_C_string());
}
nmethod* nm = m->code();
--- a/hotspot/src/share/vm/classfile/defaultMethods.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/classfile/defaultMethods.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -450,6 +450,10 @@
streamIndentor si(str, indent * 2);
str->indent().print("Selected method: ");
print_method(str, _selected_target);
+ Klass* method_holder = _selected_target->method_holder();
+ if (!method_holder->is_interface()) {
+ tty->print(" : in superclass");
+ }
str->print_cr("");
}
@@ -1141,19 +1145,23 @@
#endif // ndef PRODUCT
if (method->has_target()) {
Method* selected = method->get_selected_target();
- max_stack = assemble_redirect(
+ if (selected->method_holder()->is_interface()) {
+ max_stack = assemble_redirect(
&bpool, &buffer, slot->signature(), selected, CHECK);
+ }
} else if (method->throws_exception()) {
max_stack = assemble_abstract_method_error(
&bpool, &buffer, method->get_exception_message(), CHECK);
}
- AccessFlags flags = accessFlags_from(
+ if (max_stack != 0) {
+ AccessFlags flags = accessFlags_from(
JVM_ACC_PUBLIC | JVM_ACC_SYNTHETIC | JVM_ACC_BRIDGE);
- Method* m = new_method(&bpool, &buffer, slot->name(), slot->signature(),
+ Method* m = new_method(&bpool, &buffer, slot->name(), slot->signature(),
flags, max_stack, slot->size_of_parameters(),
ConstMethod::OVERPASS, CHECK);
- if (m != NULL) {
- overpasses.push(m);
+ if (m != NULL) {
+ overpasses.push(m);
+ }
}
}
}
--- a/hotspot/src/share/vm/code/compiledIC.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/code/compiledIC.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -161,31 +161,36 @@
void CompiledIC::set_to_megamorphic(CallInfo* call_info, Bytecodes::Code bytecode, TRAPS) {
- methodHandle method = call_info->selected_method();
- bool is_invoke_interface = (bytecode == Bytecodes::_invokeinterface && !call_info->has_vtable_index());
assert(CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "");
assert(!is_optimized(), "cannot set an optimized virtual call to megamorphic");
assert(is_call_to_compiled() || is_call_to_interpreted(), "going directly to megamorphic?");
address entry;
- if (is_invoke_interface) {
- int index = klassItable::compute_itable_index(call_info->resolved_method()());
- entry = VtableStubs::create_stub(false, index, method());
+ if (call_info->call_kind() == CallInfo::itable_call) {
+ assert(bytecode == Bytecodes::_invokeinterface, "");
+ int itable_index = call_info->itable_index();
+ entry = VtableStubs::find_itable_stub(itable_index);
+#ifdef ASSERT
assert(entry != NULL, "entry not computed");
+ int index = call_info->resolved_method()->itable_index();
+ assert(index == itable_index, "CallInfo pre-computes this");
+#endif //ASSERT
InstanceKlass* k = call_info->resolved_method()->method_holder();
- assert(k->is_interface(), "sanity check");
+ assert(k->verify_itable_index(itable_index), "sanity check");
InlineCacheBuffer::create_transition_stub(this, k, entry);
} else {
- // Can be different than method->vtable_index(), due to package-private etc.
+ assert(call_info->call_kind() == CallInfo::vtable_call, "either itable or vtable");
+ // Can be different than selected_method->vtable_index(), due to package-private etc.
int vtable_index = call_info->vtable_index();
- entry = VtableStubs::create_stub(true, vtable_index, method());
- InlineCacheBuffer::create_transition_stub(this, method(), entry);
+ assert(call_info->resolved_klass()->verify_vtable_index(vtable_index), "sanity check");
+ entry = VtableStubs::find_vtable_stub(vtable_index);
+ InlineCacheBuffer::create_transition_stub(this, NULL, entry);
}
if (TraceICs) {
ResourceMark rm;
tty->print_cr ("IC@" INTPTR_FORMAT ": to megamorphic %s entry: " INTPTR_FORMAT,
- instruction_address(), method->print_value_string(), entry);
+ instruction_address(), call_info->selected_method()->print_value_string(), entry);
}
// We can't check this anymore. With lazy deopt we could have already
--- a/hotspot/src/share/vm/code/vtableStubs.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/code/vtableStubs.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -111,7 +111,7 @@
}
-address VtableStubs::create_stub(bool is_vtable_stub, int vtable_index, Method* method) {
+address VtableStubs::find_stub(bool is_vtable_stub, int vtable_index) {
assert(vtable_index >= 0, "must be positive");
VtableStub* s = ShareVtableStubs ? lookup(is_vtable_stub, vtable_index) : NULL;
--- a/hotspot/src/share/vm/code/vtableStubs.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/code/vtableStubs.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -121,9 +121,11 @@
static VtableStub* lookup (bool is_vtable_stub, int vtable_index);
static void enter (bool is_vtable_stub, int vtable_index, VtableStub* s);
static inline uint hash (bool is_vtable_stub, int vtable_index);
+ static address find_stub (bool is_vtable_stub, int vtable_index);
public:
- static address create_stub(bool is_vtable_stub, int vtable_index, Method* method); // return the entry point of a stub for this call
+ static address find_vtable_stub(int vtable_index) { return find_stub(true, vtable_index); }
+ static address find_itable_stub(int itable_index) { return find_stub(false, itable_index); }
static bool is_entry_point(address pc); // is pc a vtable stub entry point?
static bool contains(address pc); // is pc within any stub?
static VtableStub* stub_containing(address pc); // stub containing pc or NULL
--- a/hotspot/src/share/vm/gc_implementation/g1/ptrQueue.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/gc_implementation/g1/ptrQueue.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -38,6 +38,7 @@
class PtrQueueSet;
class PtrQueue VALUE_OBJ_CLASS_SPEC {
+ friend class VMStructs;
protected:
// The ptr queue set to which this queue belongs.
--- a/hotspot/src/share/vm/gc_implementation/g1/vmStructs_g1.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/gc_implementation/g1/vmStructs_g1.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -31,7 +31,8 @@
#define VM_STRUCTS_G1(nonstatic_field, static_field) \
\
- static_field(HeapRegion, GrainBytes, size_t) \
+ static_field(HeapRegion, GrainBytes, size_t) \
+ static_field(HeapRegion, LogOfHRGrainBytes, int) \
\
nonstatic_field(HeapRegionSeq, _regions, HeapRegion**) \
nonstatic_field(HeapRegionSeq, _length, uint) \
--- a/hotspot/src/share/vm/gc_implementation/shared/allocationStats.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/gc_implementation/shared/allocationStats.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -26,11 +26,9 @@
#define SHARE_VM_GC_IMPLEMENTATION_SHARED_ALLOCATIONSTATS_HPP
#include "utilities/macros.hpp"
-#if INCLUDE_ALL_GCS
-#include "gc_implementation/shared/gcUtil.hpp"
#include "memory/allocation.hpp"
#include "utilities/globalDefinitions.hpp"
-#endif // INCLUDE_ALL_GCS
+#include "gc_implementation/shared/gcUtil.hpp"
class AllocationStats VALUE_OBJ_CLASS_SPEC {
// A duration threshold (in ms) used to filter
--- a/hotspot/src/share/vm/gc_implementation/shared/hSpaceCounters.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/gc_implementation/shared/hSpaceCounters.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -26,11 +26,9 @@
#define SHARE_VM_GC_IMPLEMENTATION_SHARED_HSPACECOUNTERS_HPP
#include "utilities/macros.hpp"
-#if INCLUDE_ALL_GCS
#include "gc_implementation/shared/generationCounters.hpp"
#include "memory/generation.hpp"
#include "runtime/perfData.hpp"
-#endif // INCLUDE_ALL_GCS
// A HSpaceCounter is a holder class for performance counters
// that track a collections (logical spaces) in a heap;
--- a/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -496,15 +496,15 @@
IRT_ENTRY(void, InterpreterRuntime::resolve_get_put(JavaThread* thread, Bytecodes::Code bytecode))
// resolve field
- FieldAccessInfo info;
+ fieldDescriptor info;
constantPoolHandle pool(thread, method(thread)->constants());
bool is_put = (bytecode == Bytecodes::_putfield || bytecode == Bytecodes::_putstatic);
bool is_static = (bytecode == Bytecodes::_getstatic || bytecode == Bytecodes::_putstatic);
{
JvmtiHideSingleStepping jhss(thread);
- LinkResolver::resolve_field(info, pool, get_index_u2_cpcache(thread, bytecode),
- bytecode, false, CHECK);
+ LinkResolver::resolve_field_access(info, pool, get_index_u2_cpcache(thread, bytecode),
+ bytecode, CHECK);
} // end JvmtiHideSingleStepping
// check if link resolution caused cpCache to be updated
@@ -524,7 +524,7 @@
// class is intitialized. This is required so that access to the static
// field will call the initialization function every time until the class
// is completely initialized ala. in 2.17.5 in JVM Specification.
- InstanceKlass *klass = InstanceKlass::cast(info.klass()());
+ InstanceKlass* klass = InstanceKlass::cast(info.field_holder());
bool uninitialized_static = ((bytecode == Bytecodes::_getstatic || bytecode == Bytecodes::_putstatic) &&
!klass->is_initialized());
Bytecodes::Code get_code = (Bytecodes::Code)0;
@@ -539,9 +539,9 @@
cache_entry(thread)->set_field(
get_code,
put_code,
- info.klass(),
- info.field_index(),
- info.field_offset(),
+ info.field_holder(),
+ info.index(),
+ info.offset(),
state,
info.access_flags().is_final(),
info.access_flags().is_volatile(),
@@ -686,29 +686,55 @@
if (already_resolved(thread)) return;
if (bytecode == Bytecodes::_invokeinterface) {
-
if (TraceItables && Verbose) {
ResourceMark rm(thread);
tty->print_cr("Resolving: klass: %s to method: %s", info.resolved_klass()->name()->as_C_string(), info.resolved_method()->name()->as_C_string());
}
+ }
+#ifdef ASSERT
+ if (bytecode == Bytecodes::_invokeinterface) {
if (info.resolved_method()->method_holder() ==
SystemDictionary::Object_klass()) {
// NOTE: THIS IS A FIX FOR A CORNER CASE in the JVM spec
- // (see also cpCacheOop.cpp for details)
+ // (see also CallInfo::set_interface for details)
+ assert(info.call_kind() == CallInfo::vtable_call ||
+ info.call_kind() == CallInfo::direct_call, "");
methodHandle rm = info.resolved_method();
assert(rm->is_final() || info.has_vtable_index(),
"should have been set already");
- cache_entry(thread)->set_method(bytecode, rm, info.vtable_index());
+ } else if (!info.resolved_method()->has_itable_index()) {
+ // Resolved something like CharSequence.toString. Use vtable not itable.
+ assert(info.call_kind() != CallInfo::itable_call, "");
} else {
// Setup itable entry
- int index = klassItable::compute_itable_index(info.resolved_method()());
- cache_entry(thread)->set_interface_call(info.resolved_method(), index);
+ assert(info.call_kind() == CallInfo::itable_call, "");
+ int index = info.resolved_method()->itable_index();
+ assert(info.itable_index() == index, "");
}
} else {
- cache_entry(thread)->set_method(
+ assert(info.call_kind() == CallInfo::direct_call ||
+ info.call_kind() == CallInfo::vtable_call, "");
+ }
+#endif
+ switch (info.call_kind()) {
+ case CallInfo::direct_call:
+ cache_entry(thread)->set_direct_call(
+ bytecode,
+ info.resolved_method());
+ break;
+ case CallInfo::vtable_call:
+ cache_entry(thread)->set_vtable_call(
bytecode,
info.resolved_method(),
info.vtable_index());
+ break;
+ case CallInfo::itable_call:
+ cache_entry(thread)->set_itable_call(
+ bytecode,
+ info.resolved_method(),
+ info.itable_index());
+ break;
+ default: ShouldNotReachHere();
}
}
IRT_END
--- a/hotspot/src/share/vm/interpreter/linkResolver.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/interpreter/linkResolver.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -46,19 +46,6 @@
#include "runtime/thread.inline.hpp"
#include "runtime/vmThread.hpp"
-//------------------------------------------------------------------------------------------------------------------------
-// Implementation of FieldAccessInfo
-
-void FieldAccessInfo::set(KlassHandle klass, Symbol* name, int field_index, int field_offset,
-BasicType field_type, AccessFlags access_flags) {
- _klass = klass;
- _name = name;
- _field_index = field_index;
- _field_offset = field_offset;
- _field_type = field_type;
- _access_flags = access_flags;
-}
-
//------------------------------------------------------------------------------------------------------------------------
// Implementation of CallInfo
@@ -66,26 +53,25 @@
void CallInfo::set_static(KlassHandle resolved_klass, methodHandle resolved_method, TRAPS) {
int vtable_index = Method::nonvirtual_vtable_index;
- set_common(resolved_klass, resolved_klass, resolved_method, resolved_method, vtable_index, CHECK);
+ set_common(resolved_klass, resolved_klass, resolved_method, resolved_method, CallInfo::direct_call, vtable_index, CHECK);
}
-void CallInfo::set_interface(KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method, TRAPS) {
+void CallInfo::set_interface(KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method, int itable_index, TRAPS) {
// This is only called for interface methods. If the resolved_method
// comes from java/lang/Object, it can be the subject of a virtual call, so
// we should pick the vtable index from the resolved method.
- // Other than that case, there is no valid vtable index to specify.
- int vtable_index = Method::invalid_vtable_index;
- if (resolved_method->method_holder() == SystemDictionary::Object_klass()) {
- assert(resolved_method->vtable_index() == selected_method->vtable_index(), "sanity check");
- vtable_index = resolved_method->vtable_index();
- }
- set_common(resolved_klass, selected_klass, resolved_method, selected_method, vtable_index, CHECK);
+ // In that case, the caller must call set_virtual instead of set_interface.
+ assert(resolved_method->method_holder()->is_interface(), "");
+ assert(itable_index == resolved_method()->itable_index(), "");
+ set_common(resolved_klass, selected_klass, resolved_method, selected_method, CallInfo::itable_call, itable_index, CHECK);
}
void CallInfo::set_virtual(KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method, int vtable_index, TRAPS) {
assert(vtable_index >= 0 || vtable_index == Method::nonvirtual_vtable_index, "valid index");
- set_common(resolved_klass, selected_klass, resolved_method, selected_method, vtable_index, CHECK);
+ assert(vtable_index < 0 || !resolved_method->has_vtable_index() || vtable_index == resolved_method->vtable_index(), "");
+ CallKind kind = (vtable_index >= 0 && !resolved_method->can_be_statically_bound() ? CallInfo::vtable_call : CallInfo::direct_call);
+ set_common(resolved_klass, selected_klass, resolved_method, selected_method, kind, vtable_index, CHECK);
assert(!resolved_method->is_compiled_lambda_form(), "these must be handled via an invokehandle call");
}
@@ -98,20 +84,29 @@
resolved_method->is_compiled_lambda_form(),
"linkMethod must return one of these");
int vtable_index = Method::nonvirtual_vtable_index;
- assert(resolved_method->vtable_index() == vtable_index, "");
- set_common(resolved_klass, resolved_klass, resolved_method, resolved_method, vtable_index, CHECK);
+ assert(!resolved_method->has_vtable_index(), "");
+ set_common(resolved_klass, resolved_klass, resolved_method, resolved_method, CallInfo::direct_call, vtable_index, CHECK);
_resolved_appendix = resolved_appendix;
_resolved_method_type = resolved_method_type;
}
-void CallInfo::set_common(KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method, int vtable_index, TRAPS) {
+void CallInfo::set_common(KlassHandle resolved_klass,
+ KlassHandle selected_klass,
+ methodHandle resolved_method,
+ methodHandle selected_method,
+ CallKind kind,
+ int index,
+ TRAPS) {
assert(resolved_method->signature() == selected_method->signature(), "signatures must correspond");
_resolved_klass = resolved_klass;
_selected_klass = selected_klass;
_resolved_method = resolved_method;
_selected_method = selected_method;
- _vtable_index = vtable_index;
+ _call_kind = kind;
+ _call_index = index;
_resolved_appendix = Handle();
+ DEBUG_ONLY(verify()); // verify before making side effects
+
if (CompilationPolicy::must_be_compiled(selected_method)) {
// This path is unusual, mostly used by the '-Xcomp' stress test mode.
@@ -138,6 +133,65 @@
}
}
+// utility query for unreflecting a method
+CallInfo::CallInfo(Method* resolved_method, Klass* resolved_klass) {
+ Klass* resolved_method_holder = resolved_method->method_holder();
+ if (resolved_klass == NULL) { // 2nd argument defaults to holder of 1st
+ resolved_klass = resolved_method_holder;
+ }
+ _resolved_klass = resolved_klass;
+ _selected_klass = resolved_klass;
+ _resolved_method = resolved_method;
+ _selected_method = resolved_method;
+ // classify:
+ CallKind kind = CallInfo::unknown_kind;
+ int index = resolved_method->vtable_index();
+ if (resolved_method->can_be_statically_bound()) {
+ kind = CallInfo::direct_call;
+ } else if (!resolved_method_holder->is_interface()) {
+ // Could be an Object method inherited into an interface, but still a vtable call.
+ kind = CallInfo::vtable_call;
+ } else if (!resolved_klass->is_interface()) {
+ // A miranda method. Compute the vtable index.
+ ResourceMark rm;
+ klassVtable* vt = InstanceKlass::cast(resolved_klass)->vtable();
+ index = vt->index_of_miranda(resolved_method->name(),
+ resolved_method->signature());
+ kind = CallInfo::vtable_call;
+ } else {
+ // A regular interface call.
+ kind = CallInfo::itable_call;
+ index = resolved_method->itable_index();
+ }
+ assert(index == Method::nonvirtual_vtable_index || index >= 0, err_msg("bad index %d", index));
+ _call_kind = kind;
+ _call_index = index;
+ _resolved_appendix = Handle();
+ DEBUG_ONLY(verify());
+}
+
+#ifdef ASSERT
+void CallInfo::verify() {
+ switch (call_kind()) { // the meaning and allowed value of index depends on kind
+ case CallInfo::direct_call:
+ if (_call_index == Method::nonvirtual_vtable_index) break;
+ // else fall through to check vtable index:
+ case CallInfo::vtable_call:
+ assert(resolved_klass()->verify_vtable_index(_call_index), "");
+ break;
+ case CallInfo::itable_call:
+ assert(resolved_method()->method_holder()->verify_itable_index(_call_index), "");
+ break;
+ case CallInfo::unknown_kind:
+ assert(call_kind() != CallInfo::unknown_kind, "CallInfo must be set");
+ break;
+ default:
+ fatal(err_msg_res("Unexpected call kind %d", call_kind()));
+ }
+}
+#endif //ASSERT
+
+
//------------------------------------------------------------------------------------------------------------------------
// Klass resolution
@@ -163,13 +217,6 @@
result = KlassHandle(THREAD, result_oop);
}
-void LinkResolver::resolve_klass_no_update(KlassHandle& result, constantPoolHandle pool, int index, TRAPS) {
- Klass* result_oop =
- ConstantPool::klass_ref_at_if_loaded_check(pool, index, CHECK);
- result = KlassHandle(THREAD, result_oop);
-}
-
-
//------------------------------------------------------------------------------------------------------------------------
// Method resolution
//
@@ -360,7 +407,12 @@
void LinkResolver::resolve_method_statically(methodHandle& resolved_method, KlassHandle& resolved_klass,
Bytecodes::Code code, constantPoolHandle pool, int index, TRAPS) {
-
+ // This method is used only
+ // (1) in C2 from InlineTree::ok_to_inline (via ciMethod::check_call),
+ // and
+ // (2) in Bytecode_invoke::static_target
+ // It appears to fail when applied to an invokeinterface call site.
+ // FIXME: Remove this method and ciMethod::check_call; refactor to use the other LinkResolver entry points.
// resolve klass
if (code == Bytecodes::_invokedynamic) {
resolved_klass = SystemDictionary::MethodHandle_klass();
@@ -580,45 +632,49 @@
}
}
-void LinkResolver::resolve_field(FieldAccessInfo& result, constantPoolHandle pool, int index, Bytecodes::Code byte, bool check_only, TRAPS) {
- resolve_field(result, pool, index, byte, check_only, true, CHECK);
+void LinkResolver::resolve_field_access(fieldDescriptor& result, constantPoolHandle pool, int index, Bytecodes::Code byte, TRAPS) {
+ // Load these early in case the resolve of the containing klass fails
+ Symbol* field = pool->name_ref_at(index);
+ Symbol* sig = pool->signature_ref_at(index);
+
+ // resolve specified klass
+ KlassHandle resolved_klass;
+ resolve_klass(resolved_klass, pool, index, CHECK);
+
+ KlassHandle current_klass(THREAD, pool->pool_holder());
+ resolve_field(result, resolved_klass, field, sig, current_klass, byte, true, true, CHECK);
}
-void LinkResolver::resolve_field(FieldAccessInfo& result, constantPoolHandle pool, int index, Bytecodes::Code byte, bool check_only, bool update_pool, TRAPS) {
+void LinkResolver::resolve_field(fieldDescriptor& fd, KlassHandle resolved_klass, Symbol* field, Symbol* sig,
+ KlassHandle current_klass, Bytecodes::Code byte, bool check_access, bool initialize_class,
+ TRAPS) {
assert(byte == Bytecodes::_getstatic || byte == Bytecodes::_putstatic ||
- byte == Bytecodes::_getfield || byte == Bytecodes::_putfield, "bad bytecode");
+ byte == Bytecodes::_getfield || byte == Bytecodes::_putfield ||
+ (byte == Bytecodes::_nop && !check_access), "bad field access bytecode");
bool is_static = (byte == Bytecodes::_getstatic || byte == Bytecodes::_putstatic);
bool is_put = (byte == Bytecodes::_putfield || byte == Bytecodes::_putstatic);
- // resolve specified klass
- KlassHandle resolved_klass;
- if (update_pool) {
- resolve_klass(resolved_klass, pool, index, CHECK);
- } else {
- resolve_klass_no_update(resolved_klass, pool, index, CHECK);
- }
- // Load these early in case the resolve of the containing klass fails
- Symbol* field = pool->name_ref_at(index);
- Symbol* sig = pool->signature_ref_at(index);
// Check if there's a resolved klass containing the field
- if( resolved_klass.is_null() ) {
+ if (resolved_klass.is_null()) {
ResourceMark rm(THREAD);
THROW_MSG(vmSymbols::java_lang_NoSuchFieldError(), field->as_C_string());
}
// Resolve instance field
- fieldDescriptor fd; // find_field initializes fd if found
KlassHandle sel_klass(THREAD, InstanceKlass::cast(resolved_klass())->find_field(field, sig, &fd));
// check if field exists; i.e., if a klass containing the field def has been selected
- if (sel_klass.is_null()){
+ if (sel_klass.is_null()) {
ResourceMark rm(THREAD);
THROW_MSG(vmSymbols::java_lang_NoSuchFieldError(), field->as_C_string());
}
+ if (!check_access)
+ // Access checking may be turned off when calling from within the VM.
+ return;
+
// check access
- KlassHandle ref_klass(THREAD, pool->pool_holder());
- check_field_accessability(ref_klass, resolved_klass, sel_klass, fd, CHECK);
+ check_field_accessability(current_klass, resolved_klass, sel_klass, fd, CHECK);
// check for errors
if (is_static != fd.is_static()) {
@@ -629,7 +685,7 @@
}
// Final fields can only be accessed from its own class.
- if (is_put && fd.access_flags().is_final() && sel_klass() != pool->pool_holder()) {
+ if (is_put && fd.access_flags().is_final() && sel_klass() != current_klass()) {
THROW(vmSymbols::java_lang_IllegalAccessError());
}
@@ -639,19 +695,18 @@
//
// note 2: we don't want to force initialization if we are just checking
// if the field access is legal; e.g., during compilation
- if (is_static && !check_only) {
+ if (is_static && initialize_class) {
sel_klass->initialize(CHECK);
}
- {
+ if (sel_klass() != current_klass()) {
HandleMark hm(THREAD);
- Handle ref_loader (THREAD, InstanceKlass::cast(ref_klass())->class_loader());
+ Handle ref_loader (THREAD, InstanceKlass::cast(current_klass())->class_loader());
Handle sel_loader (THREAD, InstanceKlass::cast(sel_klass())->class_loader());
- Symbol* signature_ref = pool->signature_ref_at(index);
{
ResourceMark rm(THREAD);
Symbol* failed_type_symbol =
- SystemDictionary::check_signature_loaders(signature_ref,
+ SystemDictionary::check_signature_loaders(sig,
ref_loader, sel_loader,
false,
CHECK);
@@ -677,9 +732,6 @@
// return information. note that the klass is set to the actual klass containing the
// field, otherwise access of static fields in superclasses will not work.
- KlassHandle holder (THREAD, fd.field_holder());
- Symbol* name = fd.name();
- result.set(holder, name, fd.index(), fd.offset(), fd.field_type(), fd.access_flags());
}
@@ -907,10 +959,6 @@
}
// Virtual methods cannot be resolved before its klass has been linked, for otherwise the Method*'s
- // has not been rewritten, and the vtable initialized.
- assert(resolved_method->method_holder()->is_linked(), "must be linked");
-
- // Virtual methods cannot be resolved before its klass has been linked, for otherwise the Method*'s
// has not been rewritten, and the vtable initialized. Make sure to do this after the nullcheck, since
// a missing receiver might result in a bogus lookup.
assert(resolved_method->method_holder()->is_linked(), "must be linked");
@@ -920,6 +968,7 @@
vtable_index = vtable_index_of_miranda_method(resolved_klass,
resolved_method->name(),
resolved_method->signature(), CHECK);
+
assert(vtable_index >= 0 , "we should have valid vtable index at this point");
InstanceKlass* inst = InstanceKlass::cast(recv_klass());
@@ -927,6 +976,7 @@
} else {
// at this point we are sure that resolved_method is virtual and not
// a miranda method; therefore, it must have a valid vtable index.
+ assert(!resolved_method->has_itable_index(), "");
vtable_index = resolved_method->vtable_index();
// We could get a negative vtable_index for final methods,
// because as an optimization they are they are never put in the vtable,
@@ -1006,6 +1056,12 @@
lookup_instance_method_in_klasses(sel_method, recv_klass,
resolved_method->name(),
resolved_method->signature(), CHECK);
+ if (sel_method.is_null() && !check_null_and_abstract) {
+ // In theory this is a harmless placeholder value, but
+ // in practice leaving in null affects the nsk default method tests.
+ // This needs further study.
+ sel_method = resolved_method;
+ }
// check if method exists
if (sel_method.is_null()) {
ResourceMark rm(THREAD);
@@ -1046,7 +1102,14 @@
sel_method->signature()));
}
// setup result
- result.set_interface(resolved_klass, recv_klass, resolved_method, sel_method, CHECK);
+ if (!resolved_method->has_itable_index()) {
+ int vtable_index = resolved_method->vtable_index();
+ assert(vtable_index == sel_method->vtable_index(), "sanity check");
+ result.set_virtual(resolved_klass, recv_klass, resolved_method, sel_method, vtable_index, CHECK);
+ return;
+ }
+ int itable_index = resolved_method()->itable_index();
+ result.set_interface(resolved_klass, recv_klass, resolved_method, sel_method, itable_index, CHECK);
}
@@ -1293,7 +1356,8 @@
}
if (TraceMethodHandles) {
- tty->print_cr("resolve_invokedynamic #%d %s %s",
+ ResourceMark rm(THREAD);
+ tty->print_cr("resolve_invokedynamic #%d %s %s",
ConstantPool::decode_invokedynamic_index(index),
method_name->as_C_string(), method_signature->as_C_string());
tty->print(" BSM info: "); bootstrap_specifier->print();
@@ -1342,9 +1406,16 @@
//------------------------------------------------------------------------------------------------------------------------
#ifndef PRODUCT
-void FieldAccessInfo::print() {
+void CallInfo::print() {
ResourceMark rm;
- tty->print_cr("Field %s@%d", name()->as_C_string(), field_offset());
+ const char* kindstr = "unknown";
+ switch (_call_kind) {
+ case direct_call: kindstr = "direct"; break;
+ case vtable_call: kindstr = "vtable"; break;
+ case itable_call: kindstr = "itable"; break;
+ }
+ tty->print_cr("Call %s@%d %s", kindstr, _call_index,
+ _resolved_method.is_null() ? "(none)" : _resolved_method->name_and_sig_as_C_string());
}
#endif
--- a/hotspot/src/share/vm/interpreter/linkResolver.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/interpreter/linkResolver.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -30,63 +30,54 @@
// All the necessary definitions for run-time link resolution.
-// LinkInfo & its subclasses provide all the information gathered
-// for a particular link after resolving it. A link is any reference
+// CallInfo provides all the information gathered for a particular
+// linked call site after resolving it. A link is any reference
// made from within the bytecodes of a method to an object outside of
// that method. If the info is invalid, the link has not been resolved
// successfully.
-class LinkInfo VALUE_OBJ_CLASS_SPEC {
-};
-
-
-// Link information for getfield/putfield & getstatic/putstatic bytecodes.
-
-class FieldAccessInfo: public LinkInfo {
- protected:
- KlassHandle _klass;
- Symbol* _name;
- AccessFlags _access_flags;
- int _field_index; // original index in the klass
- int _field_offset;
- BasicType _field_type;
-
+class CallInfo VALUE_OBJ_CLASS_SPEC {
public:
- void set(KlassHandle klass, Symbol* name, int field_index, int field_offset,
- BasicType field_type, AccessFlags access_flags);
- KlassHandle klass() const { return _klass; }
- Symbol* name() const { return _name; }
- int field_index() const { return _field_index; }
- int field_offset() const { return _field_offset; }
- BasicType field_type() const { return _field_type; }
- AccessFlags access_flags() const { return _access_flags; }
-
- // debugging
- void print() PRODUCT_RETURN;
-};
-
-
-// Link information for all calls.
-
-class CallInfo: public LinkInfo {
+ // Ways that a method call might be selected (or not) based on receiver type.
+ // Note that an invokevirtual instruction might be linked with no_dispatch,
+ // and an invokeinterface instruction might be linked with any of the three options
+ enum CallKind {
+ direct_call, // jump into resolved_method (must be concrete)
+ vtable_call, // select recv.klass.method_at_vtable(index)
+ itable_call, // select recv.klass.method_at_itable(resolved_method.holder, index)
+ unknown_kind = -1
+ };
private:
- KlassHandle _resolved_klass; // static receiver klass
+ KlassHandle _resolved_klass; // static receiver klass, resolved from a symbolic reference
KlassHandle _selected_klass; // dynamic receiver class (same as static, or subklass)
methodHandle _resolved_method; // static target method
methodHandle _selected_method; // dynamic (actual) target method
- int _vtable_index; // vtable index of selected method
+ CallKind _call_kind; // kind of call (static(=bytecode static/special +
+ // others inferred), vtable, itable)
+ int _call_index; // vtable or itable index of selected class method (if any)
Handle _resolved_appendix; // extra argument in constant pool (if CPCE::has_appendix)
Handle _resolved_method_type; // MethodType (for invokedynamic and invokehandle call sites)
void set_static( KlassHandle resolved_klass, methodHandle resolved_method , TRAPS);
- void set_interface(KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method , TRAPS);
+ void set_interface(KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method, int itable_index , TRAPS);
void set_virtual( KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method, int vtable_index , TRAPS);
void set_handle( methodHandle resolved_method, Handle resolved_appendix, Handle resolved_method_type, TRAPS);
- void set_common( KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method, int vtable_index , TRAPS);
+ void set_common( KlassHandle resolved_klass, KlassHandle selected_klass, methodHandle resolved_method, methodHandle selected_method, CallKind kind, int index, TRAPS);
friend class LinkResolver;
public:
+ CallInfo() {
+#ifndef PRODUCT
+ _call_kind = CallInfo::unknown_kind;
+ _call_index = Method::garbage_vtable_index;
+#endif //PRODUCT
+ }
+
+ // utility to extract an effective CallInfo from a method and an optional receiver limit
+ // does not queue the method for compilation
+ CallInfo(Method* resolved_method, Klass* resolved_klass = NULL);
+
KlassHandle resolved_klass() const { return _resolved_klass; }
KlassHandle selected_klass() const { return _selected_klass; }
methodHandle resolved_method() const { return _resolved_method; }
@@ -95,21 +86,43 @@
Handle resolved_method_type() const { return _resolved_method_type; }
BasicType result_type() const { return selected_method()->result_type(); }
- bool has_vtable_index() const { return _vtable_index >= 0; }
- bool is_statically_bound() const { return _vtable_index == Method::nonvirtual_vtable_index; }
+ CallKind call_kind() const { return _call_kind; }
+ int call_index() const { return _call_index; }
int vtable_index() const {
// Even for interface calls the vtable index could be non-negative.
// See CallInfo::set_interface.
assert(has_vtable_index() || is_statically_bound(), "");
- return _vtable_index;
+ assert(call_kind() == vtable_call || call_kind() == direct_call, "");
+ // The returned value is < 0 if the call is statically bound.
+ // But, the returned value may be >= 0 even if the kind is direct_call.
+ // It is up to the caller to decide which way to go.
+ return _call_index;
}
+ int itable_index() const {
+ assert(call_kind() == itable_call, "");
+ // The returned value is always >= 0, a valid itable index.
+ return _call_index;
+ }
+
+ // debugging
+#ifdef ASSERT
+ bool has_vtable_index() const { return _call_index >= 0 && _call_kind != CallInfo::itable_call; }
+ bool is_statically_bound() const { return _call_index == Method::nonvirtual_vtable_index; }
+#endif //ASSERT
+ void verify() PRODUCT_RETURN;
+ void print() PRODUCT_RETURN;
};
+// Link information for getfield/putfield & getstatic/putstatic bytecodes
+// is represented using a fieldDescriptor.
// The LinkResolver is used to resolve constant-pool references at run-time.
// It does all necessary link-time checks & throws exceptions if necessary.
class LinkResolver: AllStatic {
+ friend class klassVtable;
+ friend class klassItable;
+
private:
static void lookup_method_in_klasses (methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS);
static void lookup_instance_method_in_klasses (methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS);
@@ -120,7 +133,6 @@
static int vtable_index_of_miranda_method(KlassHandle klass, Symbol* name, Symbol* signature, TRAPS);
static void resolve_klass (KlassHandle& result, constantPoolHandle pool, int index, TRAPS);
- static void resolve_klass_no_update (KlassHandle& result, constantPoolHandle pool, int index, TRAPS); // no update of constantPool entry
static void resolve_pool (KlassHandle& resolved_klass, Symbol*& method_name, Symbol*& method_signature, KlassHandle& current_klass, constantPoolHandle pool, int index, TRAPS);
@@ -148,9 +160,16 @@
Bytecodes::Code code, constantPoolHandle pool, int index, TRAPS);
// runtime/static resolving for fields
- static void resolve_field(FieldAccessInfo& result, constantPoolHandle pool, int index, Bytecodes::Code byte, bool check_only, TRAPS);
- // takes an extra bool argument "update_pool" to decide whether to update the constantPool during klass resolution.
- static void resolve_field(FieldAccessInfo& result, constantPoolHandle pool, int index, Bytecodes::Code byte, bool check_only, bool update_pool, TRAPS);
+ static void resolve_field_access(fieldDescriptor& result, constantPoolHandle pool, int index, Bytecodes::Code byte, TRAPS);
+ static void resolve_field(fieldDescriptor& result, KlassHandle resolved_klass, Symbol* field_name, Symbol* field_signature,
+ KlassHandle current_klass, Bytecodes::Code access_kind, bool check_access, bool initialize_class, TRAPS);
+
+ // source of access_kind codes:
+ static Bytecodes::Code field_access_kind(bool is_static, bool is_put) {
+ return (is_static
+ ? (is_put ? Bytecodes::_putstatic : Bytecodes::_getstatic)
+ : (is_put ? Bytecodes::_putfield : Bytecodes::_getfield ));
+ }
// runtime resolving:
// resolved_klass = specified class (i.e., static receiver class)
--- a/hotspot/src/share/vm/memory/binaryTreeDictionary.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/memory/binaryTreeDictionary.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -33,10 +33,10 @@
#include "runtime/globals.hpp"
#include "utilities/ostream.hpp"
#include "utilities/macros.hpp"
+#include "gc_implementation/shared/spaceDecorator.hpp"
#if INCLUDE_ALL_GCS
#include "gc_implementation/concurrentMarkSweep/adaptiveFreeList.hpp"
#include "gc_implementation/concurrentMarkSweep/freeChunk.hpp"
-#include "gc_implementation/shared/spaceDecorator.hpp"
#include "gc_implementation/concurrentMarkSweep/freeChunk.hpp"
#endif // INCLUDE_ALL_GCS
--- a/hotspot/src/share/vm/memory/universe.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/memory/universe.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -602,7 +602,7 @@
}
}
-static intptr_t non_oop_bits = 0;
+intptr_t Universe::_non_oop_bits = 0;
void* Universe::non_oop_word() {
// Neither the high bits nor the low bits of this value is allowed
@@ -616,11 +616,11 @@
// Using the OS-supplied non-memory-address word (usually 0 or -1)
// will take care of the high bits, however many there are.
- if (non_oop_bits == 0) {
- non_oop_bits = (intptr_t)os::non_memory_address_word() | 1;
+ if (_non_oop_bits == 0) {
+ _non_oop_bits = (intptr_t)os::non_memory_address_word() | 1;
}
- return (void*)non_oop_bits;
+ return (void*)_non_oop_bits;
}
jint universe_init() {
--- a/hotspot/src/share/vm/memory/universe.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/memory/universe.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -179,6 +179,8 @@
// The particular choice of collected heap.
static CollectedHeap* _collectedHeap;
+ static intptr_t _non_oop_bits;
+
// For UseCompressedOops.
static struct NarrowPtrStruct _narrow_oop;
// For UseCompressedClassPointers.
--- a/hotspot/src/share/vm/oops/constantPool.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/oops/constantPool.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -396,32 +396,6 @@
}
-// This is an interface for the compiler that allows accessing non-resolved entries
-// in the constant pool - but still performs the validations tests. Must be used
-// in a pre-parse of the compiler - to determine what it can do and not do.
-// Note: We cannot update the ConstantPool from the vm_thread.
-Klass* ConstantPool::klass_ref_at_if_loaded_check(constantPoolHandle this_oop, int index, TRAPS) {
- int which = this_oop->klass_ref_index_at(index);
- CPSlot entry = this_oop->slot_at(which);
- if (entry.is_resolved()) {
- assert(entry.get_klass()->is_klass(), "must be");
- return entry.get_klass();
- } else {
- assert(entry.is_unresolved(), "must be either symbol or klass");
- Symbol* name = entry.get_symbol();
- oop loader = this_oop->pool_holder()->class_loader();
- oop protection_domain = this_oop->pool_holder()->protection_domain();
- Handle h_loader(THREAD, loader);
- Handle h_prot (THREAD, protection_domain);
- KlassHandle k(THREAD, SystemDictionary::find(name, h_loader, h_prot, THREAD));
-
- // Do access check for klasses
- if( k.not_null() ) verify_constant_pool_resolve(this_oop, k, CHECK_NULL);
- return k();
- }
-}
-
-
Method* ConstantPool::method_at_if_loaded(constantPoolHandle cpool,
int which) {
if (cpool->cache() == NULL) return NULL; // nothing to load yet
--- a/hotspot/src/share/vm/oops/constantPool.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/oops/constantPool.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -730,8 +730,6 @@
static oop method_type_at_if_loaded (constantPoolHandle this_oop, int which);
static Klass* klass_at_if_loaded (constantPoolHandle this_oop, int which);
static Klass* klass_ref_at_if_loaded (constantPoolHandle this_oop, int which);
- // Same as above - but does LinkResolving.
- static Klass* klass_ref_at_if_loaded_check(constantPoolHandle this_oop, int which, TRAPS);
// Routines currently used for annotations (only called by jvm.cpp) but which might be used in the
// future by other Java code. These take constant pool indices rather than
--- a/hotspot/src/share/vm/oops/cpCache.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/oops/cpCache.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -140,9 +140,10 @@
err_msg("size must not change: parameter_size=%d, value=%d", parameter_size(), value));
}
-void ConstantPoolCacheEntry::set_method(Bytecodes::Code invoke_code,
- methodHandle method,
- int vtable_index) {
+void ConstantPoolCacheEntry::set_direct_or_vtable_call(Bytecodes::Code invoke_code,
+ methodHandle method,
+ int vtable_index) {
+ bool is_vtable_call = (vtable_index >= 0); // FIXME: split this method on this boolean
assert(method->interpreter_entry() != NULL, "should have been set at this point");
assert(!method->is_obsolete(), "attempt to write obsolete method to cpCache");
@@ -160,7 +161,8 @@
// ...and fall through as if we were handling invokevirtual:
case Bytecodes::_invokevirtual:
{
- if (method->can_be_statically_bound()) {
+ if (!is_vtable_call) {
+ assert(method->can_be_statically_bound(), "");
// set_f2_as_vfinal_method checks if is_vfinal flag is true.
set_method_flags(as_TosState(method->result_type()),
( 1 << is_vfinal_shift) |
@@ -169,6 +171,7 @@
method()->size_of_parameters());
set_f2_as_vfinal_method(method());
} else {
+ assert(!method->can_be_statically_bound(), "");
assert(vtable_index >= 0, "valid index");
assert(!method->is_final_method(), "sanity");
set_method_flags(as_TosState(method->result_type()),
@@ -182,6 +185,7 @@
case Bytecodes::_invokespecial:
case Bytecodes::_invokestatic:
+ assert(!is_vtable_call, "");
// Note: Read and preserve the value of the is_vfinal flag on any
// invokevirtual bytecode shared with this constant pool cache entry.
// It is cheap and safe to consult is_vfinal() at all times.
@@ -232,8 +236,22 @@
NOT_PRODUCT(verify(tty));
}
+void ConstantPoolCacheEntry::set_direct_call(Bytecodes::Code invoke_code, methodHandle method) {
+ int index = Method::nonvirtual_vtable_index;
+ // index < 0; FIXME: inline and customize set_direct_or_vtable_call
+ set_direct_or_vtable_call(invoke_code, method, index);
+}
-void ConstantPoolCacheEntry::set_interface_call(methodHandle method, int index) {
+void ConstantPoolCacheEntry::set_vtable_call(Bytecodes::Code invoke_code, methodHandle method, int index) {
+ // either the method is a miranda or its holder should accept the given index
+ assert(method->method_holder()->is_interface() || method->method_holder()->verify_vtable_index(index), "");
+ // index >= 0; FIXME: inline and customize set_direct_or_vtable_call
+ set_direct_or_vtable_call(invoke_code, method, index);
+}
+
+void ConstantPoolCacheEntry::set_itable_call(Bytecodes::Code invoke_code, methodHandle method, int index) {
+ assert(method->method_holder()->verify_itable_index(index), "");
+ assert(invoke_code == Bytecodes::_invokeinterface, "");
InstanceKlass* interf = method->method_holder();
assert(interf->is_interface(), "must be an interface");
assert(!method->is_final_method(), "interfaces do not have final methods; cannot link to one here");
--- a/hotspot/src/share/vm/oops/cpCache.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/oops/cpCache.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -219,15 +219,29 @@
Klass* root_klass // needed by the GC to dirty the klass
);
- void set_method( // sets entry to resolved method entry
+ private:
+ void set_direct_or_vtable_call(
Bytecodes::Code invoke_code, // the bytecode used for invoking the method
methodHandle method, // the method/prototype if any (NULL, otherwise)
int vtable_index // the vtable index if any, else negative
);
- void set_interface_call(
- methodHandle method, // Resolved method
- int index // Method index into interface
+ public:
+ void set_direct_call( // sets entry to exact concrete method entry
+ Bytecodes::Code invoke_code, // the bytecode used for invoking the method
+ methodHandle method // the method to call
+ );
+
+ void set_vtable_call( // sets entry to vtable index
+ Bytecodes::Code invoke_code, // the bytecode used for invoking the method
+ methodHandle method, // resolved method which declares the vtable index
+ int vtable_index // the vtable index
+ );
+
+ void set_itable_call(
+ Bytecodes::Code invoke_code, // the bytecode used; must be invokeinterface
+ methodHandle method, // the resolved interface method
+ int itable_index // index into itable for the method
);
void set_method_handle(
--- a/hotspot/src/share/vm/oops/fieldStreams.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/oops/fieldStreams.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -27,6 +27,7 @@
#include "oops/instanceKlass.hpp"
#include "oops/fieldInfo.hpp"
+#include "runtime/fieldDescriptor.hpp"
// The is the base class for iteration over the fields array
// describing the declared fields in the class. Several subclasses
@@ -43,8 +44,10 @@
int _index;
int _limit;
int _generic_signature_slot;
+ fieldDescriptor _fd_buf;
FieldInfo* field() const { return FieldInfo::from_field_array(_fields, _index); }
+ InstanceKlass* field_holder() const { return _constants->pool_holder(); }
int init_generic_signature_start_slot() {
int length = _fields->length();
@@ -102,6 +105,7 @@
_index = 0;
_limit = klass->java_fields_count();
init_generic_signature_start_slot();
+ assert(klass == field_holder(), "");
}
FieldStreamBase(instanceKlassHandle klass) {
_fields = klass->fields();
@@ -109,6 +113,7 @@
_index = 0;
_limit = klass->java_fields_count();
init_generic_signature_start_slot();
+ assert(klass == field_holder(), "");
}
// accessors
@@ -180,6 +185,12 @@
return field()->contended_group();
}
+ // bridge to a heavier API:
+ fieldDescriptor& field_descriptor() const {
+ fieldDescriptor& field = const_cast<fieldDescriptor&>(_fd_buf);
+ field.reinitialize(field_holder(), _index);
+ return field;
+ }
};
// Iterate over only the internal fields
--- a/hotspot/src/share/vm/oops/instanceKlass.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/oops/instanceKlass.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -286,7 +286,6 @@
init_previous_versions();
set_generic_signature_index(0);
release_set_methods_jmethod_ids(NULL);
- release_set_methods_cached_itable_indices(NULL);
set_annotations(NULL);
set_jvmti_cached_class_field_map(NULL);
set_initial_method_idnum(0);
@@ -1149,7 +1148,7 @@
Symbol* f_name = fs.name();
Symbol* f_sig = fs.signature();
if (f_name == name && f_sig == sig) {
- fd->initialize(const_cast<InstanceKlass*>(this), fs.index());
+ fd->reinitialize(const_cast<InstanceKlass*>(this), fs.index());
return true;
}
}
@@ -1218,7 +1217,7 @@
bool InstanceKlass::find_local_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const {
for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
if (fs.offset() == offset) {
- fd->initialize(const_cast<InstanceKlass*>(this), fs.index());
+ fd->reinitialize(const_cast<InstanceKlass*>(this), fs.index());
if (fd->is_static() == is_static) return true;
}
}
@@ -1251,8 +1250,7 @@
void InstanceKlass::do_local_static_fields(FieldClosure* cl) {
for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
if (fs.access_flags().is_static()) {
- fieldDescriptor fd;
- fd.initialize(this, fs.index());
+ fieldDescriptor& fd = fs.field_descriptor();
cl->do_field(&fd);
}
}
@@ -1268,8 +1266,7 @@
void InstanceKlass::do_local_static_fields_impl(instanceKlassHandle this_oop, void f(fieldDescriptor* fd, TRAPS), TRAPS) {
for (JavaFieldStream fs(this_oop()); !fs.done(); fs.next()) {
if (fs.access_flags().is_static()) {
- fieldDescriptor fd;
- fd.initialize(this_oop(), fs.index());
+ fieldDescriptor& fd = fs.field_descriptor();
f(&fd, CHECK);
}
}
@@ -1291,7 +1288,7 @@
int* fields_sorted = NEW_C_HEAP_ARRAY(int, 2*(length+1), mtClass);
int j = 0;
for (int i = 0; i < length; i += 1) {
- fd.initialize(this, i);
+ fd.reinitialize(this, i);
if (!fd.is_static()) {
fields_sorted[j + 0] = fd.offset();
fields_sorted[j + 1] = i;
@@ -1303,7 +1300,7 @@
// _sort_Fn is defined in growableArray.hpp.
qsort(fields_sorted, length/2, 2*sizeof(int), (_sort_Fn)compare_fields_by_offset);
for (int i = 0; i < length; i += 2) {
- fd.initialize(this, fields_sorted[i + 1]);
+ fd.reinitialize(this, fields_sorted[i + 1]);
assert(!fd.is_static() && fd.offset() == fields_sorted[i], "only nonstatic fields");
cl->do_field(&fd);
}
@@ -1686,87 +1683,6 @@
}
-// Cache an itable index
-void InstanceKlass::set_cached_itable_index(size_t idnum, int index) {
- int* indices = methods_cached_itable_indices_acquire();
- int* to_dealloc_indices = NULL;
-
- // We use a double-check locking idiom here because this cache is
- // performance sensitive. In the normal system, this cache only
- // transitions from NULL to non-NULL which is safe because we use
- // release_set_methods_cached_itable_indices() to advertise the
- // new cache. A partially constructed cache should never be seen
- // by a racing thread. Cache reads and writes proceed without a
- // lock, but creation of the cache itself requires no leaks so a
- // lock is generally acquired in that case.
- //
- // If the RedefineClasses() API has been used, then this cache can
- // grow and we'll have transitions from non-NULL to bigger non-NULL.
- // Cache creation requires no leaks and we require safety between all
- // cache accesses and freeing of the old cache so a lock is generally
- // acquired when the RedefineClasses() API has been used.
-
- if (indices == NULL || idnum_can_increment()) {
- // we need a cache or the cache can grow
- MutexLocker ml(JNICachedItableIndex_lock);
- // reacquire the cache to see if another thread already did the work
- indices = methods_cached_itable_indices_acquire();
- size_t length = 0;
- // cache size is stored in element[0], other elements offset by one
- if (indices == NULL || (length = (size_t)indices[0]) <= idnum) {
- size_t size = MAX2(idnum+1, (size_t)idnum_allocated_count());
- int* new_indices = NEW_C_HEAP_ARRAY(int, size+1, mtClass);
- new_indices[0] = (int)size;
- // copy any existing entries
- size_t i;
- for (i = 0; i < length; i++) {
- new_indices[i+1] = indices[i+1];
- }
- // Set all the rest to -1
- for (i = length; i < size; i++) {
- new_indices[i+1] = -1;
- }
- if (indices != NULL) {
- // We have an old cache to delete so save it for after we
- // drop the lock.
- to_dealloc_indices = indices;
- }
- release_set_methods_cached_itable_indices(indices = new_indices);
- }
-
- if (idnum_can_increment()) {
- // this cache can grow so we have to write to it safely
- indices[idnum+1] = index;
- }
- } else {
- CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
- }
-
- if (!idnum_can_increment()) {
- // The cache cannot grow and this JNI itable index value does not
- // have to be unique like a jmethodID. If there is a race to set it,
- // it doesn't matter.
- indices[idnum+1] = index;
- }
-
- if (to_dealloc_indices != NULL) {
- // we allocated a new cache so free the old one
- FreeHeap(to_dealloc_indices);
- }
-}
-
-
-// Retrieve a cached itable index
-int InstanceKlass::cached_itable_index(size_t idnum) {
- int* indices = methods_cached_itable_indices_acquire();
- if (indices != NULL && ((size_t)indices[0]) > idnum) {
- // indices exist and are long enough, retrieve possible cached
- return indices[idnum+1];
- }
- return -1;
-}
-
-
//
// Walk the list of dependent nmethods searching for nmethods which
// are dependent on the changes that were passed in and mark them for
@@ -2326,12 +2242,6 @@
}
}
- int* indices = methods_cached_itable_indices_acquire();
- if (indices != (int*)NULL) {
- release_set_methods_cached_itable_indices(NULL);
- FreeHeap(indices);
- }
-
// release dependencies
nmethodBucket* b = _dependencies;
_dependencies = NULL;
@@ -2782,6 +2692,18 @@
"allocated", "loaded", "linked", "being_initialized", "fully_initialized", "initialization_error"
};
+static void print_vtable(intptr_t* start, int len, outputStream* st) {
+ for (int i = 0; i < len; i++) {
+ intptr_t e = start[i];
+ st->print("%d : " INTPTR_FORMAT, i, e);
+ if (e != 0 && ((Metadata*)e)->is_metaspace_object()) {
+ st->print(" ");
+ ((Metadata*)e)->print_value_on(st);
+ }
+ st->cr();
+ }
+}
+
void InstanceKlass::print_on(outputStream* st) const {
assert(is_klass(), "must be klass");
Klass::print_on(st);
@@ -2816,7 +2738,7 @@
st->print(BULLET"arrays: "); array_klasses()->print_value_on_maybe_null(st); st->cr();
st->print(BULLET"methods: "); methods()->print_value_on(st); st->cr();
- if (Verbose) {
+ if (Verbose || WizardMode) {
Array<Method*>* method_array = methods();
for(int i = 0; i < method_array->length(); i++) {
st->print("%d : ", i); method_array->at(i)->print_value(); st->cr();
@@ -2874,7 +2796,9 @@
st->print(BULLET"inner classes: "); inner_classes()->print_value_on(st); st->cr();
st->print(BULLET"java mirror: "); java_mirror()->print_value_on(st); st->cr();
st->print(BULLET"vtable length %d (start addr: " INTPTR_FORMAT ")", vtable_length(), start_of_vtable()); st->cr();
+ if (vtable_length() > 0 && (Verbose || WizardMode)) print_vtable(start_of_vtable(), vtable_length(), st);
st->print(BULLET"itable length %d (start addr: " INTPTR_FORMAT ")", itable_length(), start_of_itable()); st->cr();
+ if (itable_length() > 0 && (Verbose || WizardMode)) print_vtable(start_of_itable(), itable_length(), st);
st->print_cr(BULLET"---- static fields (%d words):", static_field_size());
FieldPrinter print_static_field(st);
((InstanceKlass*)this)->do_local_static_fields(&print_static_field);
@@ -2896,6 +2820,7 @@
void InstanceKlass::print_value_on(outputStream* st) const {
assert(is_klass(), "must be klass");
+ if (Verbose || WizardMode) access_flags().print_on(st);
name()->print_value_on(st);
}
--- a/hotspot/src/share/vm/oops/instanceKlass.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/oops/instanceKlass.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -245,7 +245,6 @@
MemberNameTable* _member_names; // Member names
JNIid* _jni_ids; // First JNI identifier for static fields in this class
jmethodID* _methods_jmethod_ids; // jmethodIDs corresponding to method_idnum, or NULL if none
- int* _methods_cached_itable_indices; // itable_index cache for JNI invoke corresponding to methods idnum, or NULL
nmethodBucket* _dependencies; // list of dependent nmethods
nmethod* _osr_nmethods_head; // Head of list of on-stack replacement nmethods for this class
BreakpointInfo* _breakpoints; // bpt lists, managed by Method*
@@ -690,10 +689,6 @@
size_t *length_p, jmethodID* id_p);
jmethodID jmethod_id_or_null(Method* method);
- // cached itable index support
- void set_cached_itable_index(size_t idnum, int index);
- int cached_itable_index(size_t idnum);
-
// annotations support
Annotations* annotations() const { return _annotations; }
void set_annotations(Annotations* anno) { _annotations = anno; }
@@ -994,11 +989,6 @@
void release_set_methods_jmethod_ids(jmethodID* jmeths)
{ OrderAccess::release_store_ptr(&_methods_jmethod_ids, jmeths); }
- int* methods_cached_itable_indices_acquire() const
- { return (int*)OrderAccess::load_ptr_acquire(&_methods_cached_itable_indices); }
- void release_set_methods_cached_itable_indices(int* indices)
- { OrderAccess::release_store_ptr(&_methods_cached_itable_indices, indices); }
-
// Lock during initialization
public:
// Lock for (1) initialization; (2) access to the ConstantPool of this class.
--- a/hotspot/src/share/vm/oops/klass.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/oops/klass.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -674,13 +674,23 @@
#ifndef PRODUCT
-void Klass::verify_vtable_index(int i) {
+bool Klass::verify_vtable_index(int i) {
if (oop_is_instance()) {
- assert(i>=0 && i<((InstanceKlass*)this)->vtable_length()/vtableEntry::size(), "index out of bounds");
+ int limit = ((InstanceKlass*)this)->vtable_length()/vtableEntry::size();
+ assert(i >= 0 && i < limit, err_msg("index %d out of bounds %d", i, limit));
} else {
assert(oop_is_array(), "Must be");
- assert(i>=0 && i<((ArrayKlass*)this)->vtable_length()/vtableEntry::size(), "index out of bounds");
+ int limit = ((ArrayKlass*)this)->vtable_length()/vtableEntry::size();
+ assert(i >= 0 && i < limit, err_msg("index %d out of bounds %d", i, limit));
}
+ return true;
+}
+
+bool Klass::verify_itable_index(int i) {
+ assert(oop_is_instance(), "");
+ int method_count = klassItable::method_count_for_interface(this);
+ assert(i >= 0 && i < method_count, "index out of bounds");
+ return true;
}
#endif
--- a/hotspot/src/share/vm/oops/klass.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/oops/klass.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -699,7 +699,8 @@
void verify(bool check_dictionary = true) { verify_on(tty, check_dictionary); }
#ifndef PRODUCT
- void verify_vtable_index(int index);
+ bool verify_vtable_index(int index);
+ bool verify_itable_index(int index);
#endif
virtual void oop_verify_on(oop obj, outputStream* st);
--- a/hotspot/src/share/vm/oops/klassVtable.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/oops/klassVtable.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -47,11 +47,12 @@
// this function computes the vtable size (including the size needed for miranda
-// methods) and the number of miranda methods in this class
+// methods) and the number of miranda methods in this class.
// Note on Miranda methods: Let's say there is a class C that implements
-// interface I. Let's say there is a method m in I that neither C nor any
-// of its super classes implement (i.e there is no method of any access, with
-// the same name and signature as m), then m is a Miranda method which is
+// interface I, and none of C's superclasses implements I.
+// Let's say there is an abstract method m in I that neither C
+// nor any of its super classes implement (i.e there is no method of any access,
+// with the same name and signature as m), then m is a Miranda method which is
// entered as a public abstract method in C's vtable. From then on it should
// treated as any other public method in C for method over-ride purposes.
void klassVtable::compute_vtable_size_and_num_mirandas(
@@ -111,10 +112,13 @@
}
int klassVtable::index_of(Method* m, int len) const {
- assert(m->vtable_index() >= 0, "do not ask this of non-vtable methods");
+ assert(m->has_vtable_index(), "do not ask this of non-vtable methods");
return m->vtable_index();
}
+// Copy super class's vtable to the first part (prefix) of this class's vtable,
+// and return the number of entries copied. Expects that 'super' is the Java
+// super class (arrays can have "array" super classes that must be skipped).
int klassVtable::initialize_from_super(KlassHandle super) {
if (super.is_null()) {
return 0;
@@ -139,14 +143,14 @@
}
}
-// Revised lookup semantics introduced 1.3 (Kestral beta)
+//
+// Revised lookup semantics introduced 1.3 (Kestrel beta)
void klassVtable::initialize_vtable(bool checkconstraints, TRAPS) {
// Note: Arrays can have intermediate array supers. Use java_super to skip them.
KlassHandle super (THREAD, klass()->java_super());
int nofNewEntries = 0;
-
if (PrintVtables && !klass()->oop_is_array()) {
ResourceMark rm(THREAD);
tty->print_cr("Initializing: %s", _klass->name()->as_C_string());
@@ -174,8 +178,10 @@
int len = methods->length();
int initialized = super_vtable_len;
- // update_inherited_vtable can stop for gc - ensure using handles
+ // Check each of this class's methods against super;
+ // if override, replace in copy of super vtable, otherwise append to end
for (int i = 0; i < len; i++) {
+ // update_inherited_vtable can stop for gc - ensure using handles
HandleMark hm(THREAD);
assert(methods->at(i)->is_method(), "must be a Method*");
methodHandle mh(THREAD, methods->at(i));
@@ -189,11 +195,11 @@
}
}
- // add miranda methods; it will also update the value of initialized
- fill_in_mirandas(&initialized);
+ // add miranda methods to end of vtable.
+ initialized = fill_in_mirandas(initialized);
// In class hierarchies where the accessibility is not increasing (i.e., going from private ->
- // package_private -> publicprotected), the vtable might actually be smaller than our initial
+ // package_private -> public/protected), the vtable might actually be smaller than our initial
// calculation.
assert(initialized <= _length, "vtable initialization failed");
for(;initialized < _length; initialized++) {
@@ -248,14 +254,8 @@
return superk;
}
-// Methods that are "effectively" final don't need vtable entries.
-bool method_is_effectively_final(
- AccessFlags klass_flags, methodHandle target) {
- return target->is_final() || klass_flags.is_final() && !target->is_overpass();
-}
-
// Update child's copy of super vtable for overrides
-// OR return true if a new vtable entry is required
+// OR return true if a new vtable entry is required.
// Only called for InstanceKlass's, i.e. not for arrays
// If that changed, could not use _klass as handle for klass
bool klassVtable::update_inherited_vtable(InstanceKlass* klass, methodHandle target_method, int super_vtable_len,
@@ -263,6 +263,7 @@
ResourceMark rm;
bool allocate_new = true;
assert(klass->oop_is_instance(), "must be InstanceKlass");
+ assert(klass == target_method()->method_holder(), "caller resp.");
// Initialize the method's vtable index to "nonvirtual".
// If we allocate a vtable entry, we will update it to a non-negative number.
@@ -273,11 +274,17 @@
return false;
}
- if (method_is_effectively_final(klass->access_flags(), target_method)) {
+ if (target_method->is_final_method(klass->access_flags())) {
// a final method never needs a new entry; final methods can be statically
// resolved and they have to be present in the vtable only if they override
// a super's method, in which case they re-use its entry
allocate_new = false;
+ } else if (klass->is_interface()) {
+ allocate_new = false; // see note below in needs_new_vtable_entry
+ // An interface never allocates new vtable slots, only inherits old ones.
+ // This method will either be assigned its own itable index later,
+ // or be assigned an inherited vtable index in the loop below.
+ target_method()->set_vtable_index(Method::pending_itable_index);
}
// we need a new entry if there is no superclass
@@ -411,8 +418,14 @@
Symbol* classname,
AccessFlags class_flags,
TRAPS) {
+ if (class_flags.is_interface()) {
+ // Interfaces do not use vtables, so there is no point to assigning
+ // a vtable index to any of their methods. If we refrain from doing this,
+ // we can use Method::_vtable_index to hold the itable index
+ return false;
+ }
- if (method_is_effectively_final(class_flags, target_method) ||
+ if (target_method->is_final_method(class_flags) ||
// a final method never needs a new entry; final methods can be statically
// resolved and they have to be present in the vtable only if they override
// a super's method, in which case they re-use its entry
@@ -500,7 +513,8 @@
return Method::invalid_vtable_index;
}
-// check if an entry is miranda
+// check if an entry at an index is miranda
+// requires that method m at entry be declared ("held") by an interface.
bool klassVtable::is_miranda_entry_at(int i) {
Method* m = method_at(i);
Klass* method_holder = m->method_holder();
@@ -516,7 +530,9 @@
return false;
}
-// check if a method is a miranda method, given a class's methods table and it's super
+// check if a method is a miranda method, given a class's methods table and its super
+// "miranda" means not static, not defined by this class, and not defined
+// in super unless it is private and therefore inaccessible to this class.
// the caller must make sure that the method belongs to an interface implemented by the class
bool klassVtable::is_miranda(Method* m, Array<Method*>* class_methods, Klass* super) {
if (m->is_static()) {
@@ -541,6 +557,14 @@
return false;
}
+// Scans current_interface_methods for miranda methods that do not
+// already appear in new_mirandas and are also not defined-and-non-private
+// in super (superclass). These mirandas are added to all_mirandas if it is
+// not null; in addition, those that are not duplicates of miranda methods
+// inherited by super from its interfaces are added to new_mirandas.
+// Thus, new_mirandas will be the set of mirandas that this class introduces,
+// all_mirandas will be the set of all mirandas applicable to this class
+// including all defined in superclasses.
void klassVtable::add_new_mirandas_to_lists(
GrowableArray<Method*>* new_mirandas, GrowableArray<Method*>* all_mirandas,
Array<Method*>* current_interface_methods, Array<Method*>* class_methods,
@@ -599,17 +623,22 @@
}
}
-// fill in mirandas
-void klassVtable::fill_in_mirandas(int* initialized) {
+// Discover miranda methods ("miranda" = "interface abstract, no binding"),
+// and append them into the vtable starting at index initialized,
+// return the new value of initialized.
+int klassVtable::fill_in_mirandas(int initialized) {
GrowableArray<Method*> mirandas(20);
get_mirandas(&mirandas, NULL, ik()->super(), ik()->methods(),
ik()->local_interfaces());
for (int i = 0; i < mirandas.length(); i++) {
- put_method_at(mirandas.at(i), *initialized);
- ++(*initialized);
+ put_method_at(mirandas.at(i), initialized);
+ ++initialized;
}
+ return initialized;
}
+// Copy this class's vtable to the vtable beginning at start.
+// Used to copy superclass vtable to prefix of subclass's vtable.
void klassVtable::copy_vtable_to(vtableEntry* start) {
Copy::disjoint_words((HeapWord*)table(), (HeapWord*)start, _length * vtableEntry::size());
}
@@ -723,6 +752,12 @@
// Initialization
void klassItable::initialize_itable(bool checkconstraints, TRAPS) {
+ if (_klass->is_interface()) {
+ // This needs to go after vtable indexes are assigned but
+ // before implementors need to know the number of itable indexes.
+ assign_itable_indexes_for_interface(_klass());
+ }
+
// Cannot be setup doing bootstrapping, interfaces don't have
// itables, and klass with only ones entry have empty itables
if (Universe::is_bootstrapping() ||
@@ -754,45 +789,89 @@
}
+inline bool interface_method_needs_itable_index(Method* m) {
+ if (m->is_static()) return false; // e.g., Stream.empty
+ if (m->is_initializer()) return false; // <init> or <clinit>
+ // If an interface redeclares a method from java.lang.Object,
+ // it should already have a vtable index, don't touch it.
+ // e.g., CharSequence.toString (from initialize_vtable)
+ // if (m->has_vtable_index()) return false; // NO!
+ return true;
+}
+
+int klassItable::assign_itable_indexes_for_interface(Klass* klass) {
+ // an interface does not have an itable, but its methods need to be numbered
+ if (TraceItables) tty->print_cr("%3d: Initializing itable for interface %s", ++initialize_count,
+ klass->name()->as_C_string());
+ Array<Method*>* methods = InstanceKlass::cast(klass)->methods();
+ int nof_methods = methods->length();
+ int ime_num = 0;
+ for (int i = 0; i < nof_methods; i++) {
+ Method* m = methods->at(i);
+ if (interface_method_needs_itable_index(m)) {
+ assert(!m->is_final_method(), "no final interface methods");
+ // If m is already assigned a vtable index, do not disturb it.
+ if (!m->has_vtable_index()) {
+ assert(m->vtable_index() == Method::pending_itable_index, "set by initialize_vtable");
+ m->set_itable_index(ime_num);
+ // Progress to next itable entry
+ ime_num++;
+ }
+ }
+ }
+ assert(ime_num == method_count_for_interface(klass), "proper sizing");
+ return ime_num;
+}
+
+int klassItable::method_count_for_interface(Klass* interf) {
+ assert(interf->oop_is_instance(), "must be");
+ assert(interf->is_interface(), "must be");
+ Array<Method*>* methods = InstanceKlass::cast(interf)->methods();
+ int nof_methods = methods->length();
+ while (nof_methods > 0) {
+ Method* m = methods->at(nof_methods-1);
+ if (m->has_itable_index()) {
+ int length = m->itable_index() + 1;
+#ifdef ASSERT
+ while (nof_methods = 0) {
+ m = methods->at(--nof_methods);
+ assert(!m->has_itable_index() || m->itable_index() < length, "");
+ }
+#endif //ASSERT
+ return length; // return the rightmost itable index, plus one
+ }
+ nof_methods -= 1;
+ }
+ // no methods have itable indexes
+ return 0;
+}
+
+
void klassItable::initialize_itable_for_interface(int method_table_offset, KlassHandle interf_h, bool checkconstraints, TRAPS) {
Array<Method*>* methods = InstanceKlass::cast(interf_h())->methods();
int nof_methods = methods->length();
HandleMark hm;
- KlassHandle klass = _klass;
assert(nof_methods > 0, "at least one method must exist for interface to be in vtable");
Handle interface_loader (THREAD, InstanceKlass::cast(interf_h())->class_loader());
- int ime_num = 0;
- // Skip first Method* if it is a class initializer
- int i = methods->at(0)->is_static_initializer() ? 1 : 0;
-
- // m, method_name, method_signature, klass reset each loop so they
- // don't need preserving across check_signature_loaders call
- // methods needs a handle in case of gc from check_signature_loaders
- for(; i < nof_methods; i++) {
+ int ime_count = method_count_for_interface(interf_h());
+ for (int i = 0; i < nof_methods; i++) {
Method* m = methods->at(i);
- Symbol* method_name = m->name();
- Symbol* method_signature = m->signature();
-
- // This is same code as in Linkresolver::lookup_instance_method_in_klasses
- Method* target = klass->uncached_lookup_method(method_name, method_signature);
- while (target != NULL && target->is_static()) {
- // continue with recursive lookup through the superclass
- Klass* super = target->method_holder()->super();
- target = (super == NULL) ? (Method*)NULL : super->uncached_lookup_method(method_name, method_signature);
+ methodHandle target;
+ if (m->has_itable_index()) {
+ LinkResolver::lookup_instance_method_in_klasses(target, _klass, m->name(), m->signature(), CHECK);
}
if (target == NULL || !target->is_public() || target->is_abstract()) {
// Entry do not resolve. Leave it empty
} else {
// Entry did resolve, check loader constraints before initializing
// if checkconstraints requested
- methodHandle target_h (THREAD, target); // preserve across gc
if (checkconstraints) {
Handle method_holder_loader (THREAD, target->method_holder()->class_loader());
if (method_holder_loader() != interface_loader()) {
ResourceMark rm(THREAD);
Symbol* failed_type_symbol =
- SystemDictionary::check_signature_loaders(method_signature,
+ SystemDictionary::check_signature_loaders(m->signature(),
method_holder_loader,
interface_loader,
true, CHECK);
@@ -803,9 +882,9 @@
"and the class loader (instance of %s) for interface "
"%s have different Class objects for the type %s "
"used in the signature";
- char* sig = target_h()->name_and_sig_as_C_string();
+ char* sig = target()->name_and_sig_as_C_string();
const char* loader1 = SystemDictionary::loader_name(method_holder_loader());
- char* current = klass->name()->as_C_string();
+ char* current = _klass->name()->as_C_string();
const char* loader2 = SystemDictionary::loader_name(interface_loader());
char* iface = InstanceKlass::cast(interf_h())->name()->as_C_string();
char* failed_type_name = failed_type_symbol->as_C_string();
@@ -821,10 +900,10 @@
}
// ime may have moved during GC so recalculate address
- itableOffsetEntry::method_entry(_klass(), method_table_offset)[ime_num].initialize(target_h());
+ int ime_num = m->itable_index();
+ assert(ime_num < ime_count, "oob");
+ itableOffsetEntry::method_entry(_klass(), method_table_offset)[ime_num].initialize(target());
}
- // Progress to next entry
- ime_num++;
}
}
@@ -913,20 +992,22 @@
virtual void doit(Klass* intf, int method_count) = 0;
};
-// Visit all interfaces with at-least one method (excluding <clinit>)
+// Visit all interfaces with at least one itable method
void visit_all_interfaces(Array<Klass*>* transitive_intf, InterfaceVisiterClosure *blk) {
// Handle array argument
for(int i = 0; i < transitive_intf->length(); i++) {
Klass* intf = transitive_intf->at(i);
assert(intf->is_interface(), "sanity check");
- // Find no. of methods excluding a <clinit>
- int method_count = InstanceKlass::cast(intf)->methods()->length();
- if (method_count > 0) {
- Method* m = InstanceKlass::cast(intf)->methods()->at(0);
- assert(m != NULL && m->is_method(), "sanity check");
- if (m->name() == vmSymbols::object_initializer_name()) {
- method_count--;
+ // Find no. of itable methods
+ int method_count = 0;
+ // method_count = klassItable::method_count_for_interface(intf);
+ Array<Method*>* methods = InstanceKlass::cast(intf)->methods();
+ if (methods->length() > 0) {
+ for (int i = methods->length(); --i >= 0; ) {
+ if (interface_method_needs_itable_index(methods->at(i))) {
+ method_count++;
+ }
}
}
@@ -1024,40 +1105,26 @@
}
-// m must be a method in an interface
-int klassItable::compute_itable_index(Method* m) {
- InstanceKlass* intf = m->method_holder();
- assert(intf->is_interface(), "sanity check");
- Array<Method*>* methods = intf->methods();
- int index = 0;
- while(methods->at(index) != m) {
- index++;
- assert(index < methods->length(), "should find index for resolve_invoke");
- }
- // Adjust for <clinit>, which is left out of table if first method
- if (methods->length() > 0 && methods->at(0)->is_static_initializer()) {
- index--;
- }
- return index;
-}
-
-
-// inverse to compute_itable_index
+// inverse to itable_index
Method* klassItable::method_for_itable_index(Klass* intf, int itable_index) {
assert(InstanceKlass::cast(intf)->is_interface(), "sanity check");
+ assert(intf->verify_itable_index(itable_index), "");
Array<Method*>* methods = InstanceKlass::cast(intf)->methods();
+ if (itable_index < 0 || itable_index >= method_count_for_interface(intf))
+ return NULL; // help caller defend against bad indexes
+
int index = itable_index;
- // Adjust for <clinit>, which is left out of table if first method
- if (methods->length() > 0 && methods->at(0)->is_static_initializer()) {
- index++;
+ Method* m = methods->at(index);
+ int index2 = -1;
+ while (!m->has_itable_index() ||
+ (index2 = m->itable_index()) != itable_index) {
+ assert(index2 < itable_index, "monotonic");
+ if (++index == methods->length())
+ return NULL;
+ m = methods->at(index);
}
-
- if (itable_index < 0 || index >= methods->length())
- return NULL; // help caller defend against bad indexes
-
- Method* m = methods->at(index);
- assert(compute_itable_index(m) == itable_index, "correct inverse");
+ assert(m->itable_index() == itable_index, "correct inverse");
return m;
}
--- a/hotspot/src/share/vm/oops/klassVtable.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/oops/klassVtable.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -124,7 +124,7 @@
// support for miranda methods
bool is_miranda_entry_at(int i);
- void fill_in_mirandas(int* initialized);
+ int fill_in_mirandas(int initialized);
static bool is_miranda(Method* m, Array<Method*>* class_methods, Klass* super);
static void add_new_mirandas_to_lists(
GrowableArray<Method*>* new_mirandas,
@@ -150,6 +150,8 @@
// from_compiled_code_entry_point -> nmethod entry point
// from_interpreter_entry_point -> i2cadapter
class vtableEntry VALUE_OBJ_CLASS_SPEC {
+ friend class VMStructs;
+
public:
// size in words
static int size() {
@@ -288,12 +290,12 @@
#endif // INCLUDE_JVMTI
// Setup of itable
+ static int assign_itable_indexes_for_interface(Klass* klass);
+ static int method_count_for_interface(Klass* klass);
static int compute_itable_size(Array<Klass*>* transitive_interfaces);
static void setup_itable_offset_table(instanceKlassHandle klass);
// Resolving of method to index
- static int compute_itable_index(Method* m);
- // ...and back again:
static Method* method_for_itable_index(Klass* klass, int itable_index);
// Debugging/Statistics
--- a/hotspot/src/share/vm/oops/method.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/oops/method.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -509,24 +509,31 @@
return _access_flags.has_loops();
}
-
-bool Method::is_final_method() const {
- // %%% Should return true for private methods also,
- // since there is no way to override them.
- return is_final() || method_holder()->is_final();
+bool Method::is_final_method(AccessFlags class_access_flags) const {
+ // or "does_not_require_vtable_entry"
+ // overpass can occur, is not final (reuses vtable entry)
+ // private methods get vtable entries for backward class compatibility.
+ if (is_overpass()) return false;
+ return is_final() || class_access_flags.is_final();
}
-
-bool Method::is_strict_method() const {
- return is_strict();
+bool Method::is_final_method() const {
+ return is_final_method(method_holder()->access_flags());
}
-
-bool Method::can_be_statically_bound() const {
- if (is_final_method()) return true;
+bool Method::can_be_statically_bound(AccessFlags class_access_flags) const {
+ if (is_final_method(class_access_flags)) return true;
+#ifdef ASSERT
+ bool is_nonv = (vtable_index() == nonvirtual_vtable_index);
+ if (class_access_flags.is_interface()) assert(is_nonv == is_static(), err_msg("is_nonv=%s", is_nonv));
+#endif
+ assert(valid_vtable_index() || valid_itable_index(), "method must be linked before we ask this question");
return vtable_index() == nonvirtual_vtable_index;
}
+bool Method::can_be_statically_bound() const {
+ return can_be_statically_bound(method_holder()->access_flags());
+}
bool Method::is_accessor() const {
if (code_size() != 5) return false;
@@ -967,7 +974,7 @@
assert(ik->is_subclass_of(method_holder()), "should be subklass");
assert(ik->vtable() != NULL, "vtable should exist");
- if (vtable_index() == nonvirtual_vtable_index) {
+ if (!has_vtable_index()) {
return false;
} else {
Method* vt_m = ik->method_at_vtable(vtable_index());
@@ -1959,7 +1966,7 @@
void Method::print_value_on(outputStream* st) const {
assert(is_method(), "must be method");
- st->print_cr(internal_name());
+ st->print(internal_name());
print_address_on(st);
st->print(" ");
name()->print_value_on(st);
@@ -1967,6 +1974,7 @@
signature()->print_value_on(st);
st->print(" in ");
method_holder()->print_value_on(st);
+ if (WizardMode) st->print("#%d", _vtable_index);
if (WizardMode) st->print("[%d,%d]", size_of_parameters(), max_locals());
if (WizardMode && code() != NULL) st->print(" ((nmethod*)%p)", code());
}
--- a/hotspot/src/share/vm/oops/method.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/oops/method.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -448,16 +448,22 @@
enum VtableIndexFlag {
// Valid vtable indexes are non-negative (>= 0).
// These few negative values are used as sentinels.
- highest_unused_vtable_index_value = -5,
+ itable_index_max = -10, // first itable index, growing downward
+ pending_itable_index = -9, // itable index will be assigned
invalid_vtable_index = -4, // distinct from any valid vtable index
garbage_vtable_index = -3, // not yet linked; no vtable layout yet
nonvirtual_vtable_index = -2 // there is no need for vtable dispatch
// 6330203 Note: Do not use -1, which was overloaded with many meanings.
};
DEBUG_ONLY(bool valid_vtable_index() const { return _vtable_index >= nonvirtual_vtable_index; })
- int vtable_index() const { assert(valid_vtable_index(), "");
- return _vtable_index; }
+ bool has_vtable_index() const { return _vtable_index >= 0; }
+ int vtable_index() const { return _vtable_index; }
void set_vtable_index(int index) { _vtable_index = index; }
+ DEBUG_ONLY(bool valid_itable_index() const { return _vtable_index <= pending_itable_index; })
+ bool has_itable_index() const { return _vtable_index <= itable_index_max; }
+ int itable_index() const { assert(valid_itable_index(), "");
+ return itable_index_max - _vtable_index; }
+ void set_itable_index(int index) { _vtable_index = itable_index_max - index; assert(valid_itable_index(), ""); }
// interpreter entry
address interpreter_entry() const { return _i2i_entry; }
@@ -560,10 +566,11 @@
// checks method and its method holder
bool is_final_method() const;
- bool is_strict_method() const;
+ bool is_final_method(AccessFlags class_access_flags) const;
// true if method needs no dynamic dispatch (final and/or no vtable entry)
bool can_be_statically_bound() const;
+ bool can_be_statically_bound(AccessFlags class_access_flags) const;
// returns true if the method has any backward branches.
bool has_loops() {
@@ -740,10 +747,6 @@
// so handles are not used to avoid deadlock.
jmethodID find_jmethod_id_or_null() { return method_holder()->jmethod_id_or_null(this); }
- // JNI static invoke cached itable index accessors
- int cached_itable_index() { return method_holder()->cached_itable_index(method_idnum()); }
- void set_cached_itable_index(int index) { method_holder()->set_cached_itable_index(method_idnum(), index); }
-
// Support for inlining of intrinsic methods
vmIntrinsics::ID intrinsic_id() const { return (vmIntrinsics::ID) _intrinsic_id; }
void set_intrinsic_id(vmIntrinsics::ID id) { _intrinsic_id = (u1) id; }
--- a/hotspot/src/share/vm/oops/methodData.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/oops/methodData.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -72,6 +72,8 @@
//
// Overlay for generic profiling data.
class DataLayout VALUE_OBJ_CLASS_SPEC {
+ friend class VMStructs;
+
private:
// Every data layout begins with a header. This header
// contains a tag, which is used to indicate the size/layout
--- a/hotspot/src/share/vm/oops/symbol.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/oops/symbol.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -45,7 +45,7 @@
// in the SymbolTable bucket (the _literal field in HashtableEntry)
// that points to the Symbol. All other stores of a Symbol*
// to a field of a persistent variable (e.g., the _name filed in
-// FieldAccessInfo or _ptr in a CPSlot) is reference counted.
+// fieldDescriptor or _ptr in a CPSlot) is reference counted.
//
// 1) The lookup of a "name" in the SymbolTable either creates a Symbol F for
// "name" and returns a pointer to F or finds a pre-existing Symbol F for
--- a/hotspot/src/share/vm/opto/chaitin.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/opto/chaitin.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -122,40 +122,23 @@
return score;
}
-LRG_List::LRG_List( uint max ) : _cnt(max), _max(max), _lidxs(NEW_RESOURCE_ARRAY(uint,max)) {
- memset( _lidxs, 0, sizeof(uint)*max );
-}
-
-void LRG_List::extend( uint nidx, uint lidx ) {
- _nesting.check();
- if( nidx >= _max ) {
- uint size = 16;
- while( size <= nidx ) size <<=1;
- _lidxs = REALLOC_RESOURCE_ARRAY( uint, _lidxs, _max, size );
- _max = size;
- }
- while( _cnt <= nidx )
- _lidxs[_cnt++] = 0;
- _lidxs[nidx] = lidx;
-}
-
#define NUMBUCKS 3
// Straight out of Tarjan's union-find algorithm
uint LiveRangeMap::find_compress(uint lrg) {
uint cur = lrg;
- uint next = _uf_map[cur];
+ uint next = _uf_map.at(cur);
while (next != cur) { // Scan chain of equivalences
assert( next < cur, "always union smaller");
cur = next; // until find a fixed-point
- next = _uf_map[cur];
+ next = _uf_map.at(cur);
}
// Core of union-find algorithm: update chain of
// equivalences to be equal to the root.
while (lrg != next) {
- uint tmp = _uf_map[lrg];
- _uf_map.map(lrg, next);
+ uint tmp = _uf_map.at(lrg);
+ _uf_map.at_put(lrg, next);
lrg = tmp;
}
return lrg;
@@ -165,10 +148,10 @@
void LiveRangeMap::reset_uf_map(uint max_lrg_id) {
_max_lrg_id= max_lrg_id;
// Force the Union-Find mapping to be at least this large
- _uf_map.extend(_max_lrg_id, 0);
+ _uf_map.at_put_grow(_max_lrg_id, 0);
// Initialize it to be the ID mapping.
for (uint i = 0; i < _max_lrg_id; ++i) {
- _uf_map.map(i, i);
+ _uf_map.at_put(i, i);
}
}
@@ -176,12 +159,12 @@
// the Union-Find mapping after this call.
void LiveRangeMap::compress_uf_map_for_nodes() {
// For all Nodes, compress mapping
- uint unique = _names.Size();
+ uint unique = _names.length();
for (uint i = 0; i < unique; ++i) {
- uint lrg = _names[i];
+ uint lrg = _names.at(i);
uint compressed_lrg = find(lrg);
if (lrg != compressed_lrg) {
- _names.map(i, compressed_lrg);
+ _names.at_put(i, compressed_lrg);
}
}
}
@@ -198,11 +181,11 @@
return lrg;
}
- uint next = _uf_map[lrg];
+ uint next = _uf_map.at(lrg);
while (next != lrg) { // Scan chain of equivalences
assert(next < lrg, "always union smaller");
lrg = next; // until find a fixed-point
- next = _uf_map[lrg];
+ next = _uf_map.at(lrg);
}
return next;
}
@@ -215,7 +198,7 @@
NULL
#endif
)
- , _lrg_map(unique)
+ , _lrg_map(Thread::current()->resource_area(), unique)
, _live(0)
, _spilled_once(Thread::current()->resource_area())
, _spilled_twice(Thread::current()->resource_area())
@@ -692,6 +675,7 @@
_lrg_map.map(n->_idx, rm.is_NotEmpty() ? lr_counter++ : 0);
}
}
+
// Reset the Union-Find mapping to be identity
_lrg_map.reset_uf_map(lr_counter);
}
--- a/hotspot/src/share/vm/opto/chaitin.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/opto/chaitin.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -283,8 +283,8 @@
// Straight out of Tarjan's union-find algorithm
uint find_compress(const Node *node) {
- uint lrg_id = find_compress(_names[node->_idx]);
- _names.map(node->_idx, lrg_id);
+ uint lrg_id = find_compress(_names.at(node->_idx));
+ _names.at_put(node->_idx, lrg_id);
return lrg_id;
}
@@ -305,40 +305,40 @@
}
uint size() const {
- return _names.Size();
+ return _names.length();
}
uint live_range_id(uint idx) const {
- return _names[idx];
+ return _names.at(idx);
}
uint live_range_id(const Node *node) const {
- return _names[node->_idx];
+ return _names.at(node->_idx);
}
uint uf_live_range_id(uint lrg_id) const {
- return _uf_map[lrg_id];
+ return _uf_map.at(lrg_id);
}
void map(uint idx, uint lrg_id) {
- _names.map(idx, lrg_id);
+ _names.at_put(idx, lrg_id);
}
void uf_map(uint dst_lrg_id, uint src_lrg_id) {
- _uf_map.map(dst_lrg_id, src_lrg_id);
+ _uf_map.at_put(dst_lrg_id, src_lrg_id);
}
void extend(uint idx, uint lrg_id) {
- _names.extend(idx, lrg_id);
+ _names.at_put_grow(idx, lrg_id);
}
void uf_extend(uint dst_lrg_id, uint src_lrg_id) {
- _uf_map.extend(dst_lrg_id, src_lrg_id);
+ _uf_map.at_put_grow(dst_lrg_id, src_lrg_id);
}
- LiveRangeMap(uint unique)
- : _names(unique)
- , _uf_map(unique)
+ LiveRangeMap(Arena* arena, uint unique)
+ : _names(arena, unique, unique, 0)
+ , _uf_map(arena, unique, unique, 0)
, _max_lrg_id(0) {}
uint find_id( const Node *n ) {
@@ -355,14 +355,14 @@
void compress_uf_map_for_nodes();
uint find(uint lidx) {
- uint uf_lidx = _uf_map[lidx];
+ uint uf_lidx = _uf_map.at(lidx);
return (uf_lidx == lidx) ? uf_lidx : find_compress(lidx);
}
// Convert a Node into a Live Range Index - a lidx
uint find(const Node *node) {
uint lidx = live_range_id(node);
- uint uf_lidx = _uf_map[lidx];
+ uint uf_lidx = _uf_map.at(lidx);
return (uf_lidx == lidx) ? uf_lidx : find_compress(node);
}
@@ -371,10 +371,10 @@
// Like Find above, but no path compress, so bad asymptotic behavior
uint find_const(const Node *node) const {
- if(node->_idx >= _names.Size()) {
+ if(node->_idx >= (uint)_names.length()) {
return 0; // not mapped, usual for debug dump
}
- return find_const(_names[node->_idx]);
+ return find_const(_names.at(node->_idx));
}
};
--- a/hotspot/src/share/vm/opto/coalesce.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/opto/coalesce.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -29,7 +29,6 @@
class LoopTree;
class LRG;
-class LRG_List;
class Matcher;
class PhaseIFG;
class PhaseCFG;
--- a/hotspot/src/share/vm/opto/library_call.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/opto/library_call.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -3734,6 +3734,8 @@
RegionNode* slow_region) {
ciMethod* method = callee();
int vtable_index = method->vtable_index();
+ assert(vtable_index >= 0 || vtable_index == Method::nonvirtual_vtable_index,
+ err_msg_res("bad index %d", vtable_index));
// Get the Method* out of the appropriate vtable entry.
int entry_offset = (InstanceKlass::vtable_start_offset() +
vtable_index*vtableEntry::size()) * wordSize +
@@ -3784,6 +3786,8 @@
// so the vtable index is fixed.
// No need to use the linkResolver to get it.
vtable_index = method->vtable_index();
+ assert(vtable_index >= 0 || vtable_index == Method::nonvirtual_vtable_index,
+ err_msg_res("bad index %d", vtable_index));
}
slow_call = new(C) CallDynamicJavaNode(tf,
SharedRuntime::get_resolve_virtual_call_stub(),
--- a/hotspot/src/share/vm/opto/live.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/opto/live.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -91,7 +91,7 @@
break;
}
- uint r = _names[n->_idx];
+ uint r = _names.at(n->_idx);
assert(!def_outside->member(r), "Use of external LRG overlaps the same LRG defined in this block");
def->insert( r );
use->remove( r );
@@ -100,7 +100,7 @@
Node *nk = n->in(k);
uint nkidx = nk->_idx;
if (_cfg.get_block_for_node(nk) != block) {
- uint u = _names[nkidx];
+ uint u = _names.at(nkidx);
use->insert(u);
DEBUG_ONLY(def_outside->insert(u);)
}
@@ -112,7 +112,7 @@
#endif
// Remove anything defined by Phis and the block start instruction
for (uint k = i; k > 0; k--) {
- uint r = _names[block->get_node(k - 1)->_idx];
+ uint r = _names.at(block->get_node(k - 1)->_idx);
def->insert(r);
use->remove(r);
}
@@ -124,7 +124,7 @@
// PhiNode uses go in the live-out set of prior blocks.
for (uint k = i; k > 0; k--) {
- add_liveout(p, _names[block->get_node(k-1)->in(l)->_idx], first_pass);
+ add_liveout(p, _names.at(block->get_node(k-1)->in(l)->_idx), first_pass);
}
}
freeset(block);
@@ -256,7 +256,7 @@
tty->print("LiveOut: "); _live[b->_pre_order-1].dump();
uint cnt = b->number_of_nodes();
for( uint i=0; i<cnt; i++ ) {
- tty->print("L%d/", _names[b->get_node(i)->_idx] );
+ tty->print("L%d/", _names.at(b->get_node(i)->_idx));
b->get_node(i)->dump();
}
tty->print("\n");
--- a/hotspot/src/share/vm/opto/live.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/opto/live.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -40,27 +40,7 @@
//------------------------------LRG_List---------------------------------------
// Map Node indices to Live RanGe indices.
// Array lookup in the optimized case.
-class LRG_List : public ResourceObj {
- friend class VMStructs;
- uint _cnt, _max;
- uint* _lidxs;
- ReallocMark _nesting; // assertion check for reallocations
-public:
- LRG_List( uint max );
-
- uint lookup( uint nidx ) const {
- return _lidxs[nidx];
- }
- uint operator[] (uint nidx) const { return lookup(nidx); }
-
- void map( uint nidx, uint lidx ) {
- assert( nidx < _cnt, "oob" );
- _lidxs[nidx] = lidx;
- }
- void extend( uint nidx, uint lidx );
-
- uint Size() const { return _cnt; }
-};
+typedef GrowableArray<uint> LRG_List;
//------------------------------PhaseLive--------------------------------------
// Compute live-in/live-out
--- a/hotspot/src/share/vm/prims/jni.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/prims/jni.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -1336,6 +1336,7 @@
if (call_type == JNI_VIRTUAL) {
// jni_GetMethodID makes sure class is linked and initialized
// so m should have a valid vtable index.
+ assert(!m->has_itable_index(), "");
int vtbl_index = m->vtable_index();
if (vtbl_index != Method::nonvirtual_vtable_index) {
Klass* k = h_recv->klass();
@@ -1355,12 +1356,7 @@
// interface call
KlassHandle h_holder(THREAD, holder);
- int itbl_index = m->cached_itable_index();
- if (itbl_index == -1) {
- itbl_index = klassItable::compute_itable_index(m);
- m->set_cached_itable_index(itbl_index);
- // the above may have grabbed a lock, 'm' and anything non-handlized can't be used again
- }
+ int itbl_index = m->itable_index();
Klass* k = h_recv->klass();
selected_method = InstanceKlass::cast(k)->method_at_itable(h_holder(), itbl_index, CHECK);
}
@@ -5037,6 +5033,7 @@
#include "gc_implementation/g1/heapRegionRemSet.hpp"
#endif
#include "utilities/quickSort.hpp"
+#include "utilities/ostream.hpp"
#if INCLUDE_VM_STRUCTS
#include "runtime/vmStructs.hpp"
#endif
@@ -5064,6 +5061,7 @@
run_unit_test(CollectedHeap::test_is_in());
run_unit_test(QuickSort::test_quick_sort());
run_unit_test(AltHashing::test_alt_hash());
+ run_unit_test(test_loggc_filename());
#if INCLUDE_VM_STRUCTS
run_unit_test(VMStructs::test());
#endif
--- a/hotspot/src/share/vm/prims/jvm.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/prims/jvm.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -1824,7 +1824,7 @@
}
if (!publicOnly || fs.access_flags().is_public()) {
- fd.initialize(k(), fs.index());
+ fd.reinitialize(k(), fs.index());
oop field = Reflection::new_field(&fd, UseNewReflection, CHECK_NULL);
result->obj_at_put(out_idx, field);
++out_idx;
--- a/hotspot/src/share/vm/prims/jvmti.xml Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/prims/jvmti.xml Tue Sep 24 10:14:02 2013 +0200
@@ -458,8 +458,10 @@
the same name from being loaded dynamically.
<p/>
The VM will invoke the Agent_OnUnload_L function of the agent, if such
- a function is exported, at the same point during startup as it would
- have called the dynamic entry point Agent_OnUnLoad.
+ a function is exported, at the same point during VM execution as it would
+ have called the dynamic entry point Agent_OnUnLoad. A statically loaded
+ agent cannot be unloaded. The Agent_OnUnload_L function will still be
+ called to do any other agent shutdown related tasks.
If a <i>statically linked</i> agent L exports a function called
Agent_OnUnLoad_L and a function called Agent_OnUnLoad, the Agent_OnUnLoad
function will be ignored.
--- a/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -1072,8 +1072,17 @@
}
res = merge_cp_and_rewrite(the_class, scratch_class, THREAD);
- if (res != JVMTI_ERROR_NONE) {
- return res;
+ if (HAS_PENDING_EXCEPTION) {
+ Symbol* ex_name = PENDING_EXCEPTION->klass()->name();
+ // RC_TRACE_WITH_THREAD macro has an embedded ResourceMark
+ RC_TRACE_WITH_THREAD(0x00000002, THREAD,
+ ("merge_cp_and_rewrite exception: '%s'", ex_name->as_C_string()));
+ CLEAR_PENDING_EXCEPTION;
+ if (ex_name == vmSymbols::java_lang_OutOfMemoryError()) {
+ return JVMTI_ERROR_OUT_OF_MEMORY;
+ } else {
+ return JVMTI_ERROR_INTERNAL;
+ }
}
if (VerifyMergedCPBytecodes) {
@@ -1105,6 +1114,9 @@
}
if (HAS_PENDING_EXCEPTION) {
Symbol* ex_name = PENDING_EXCEPTION->klass()->name();
+ // RC_TRACE_WITH_THREAD macro has an embedded ResourceMark
+ RC_TRACE_WITH_THREAD(0x00000002, THREAD,
+ ("Rewriter::rewrite or link_methods exception: '%s'", ex_name->as_C_string()));
CLEAR_PENDING_EXCEPTION;
if (ex_name == vmSymbols::java_lang_OutOfMemoryError()) {
return JVMTI_ERROR_OUT_OF_MEMORY;
@@ -1395,8 +1407,8 @@
ClassLoaderData* loader_data = the_class->class_loader_data();
ConstantPool* merge_cp_oop =
ConstantPool::allocate(loader_data,
- merge_cp_length,
- THREAD);
+ merge_cp_length,
+ CHECK_(JVMTI_ERROR_OUT_OF_MEMORY));
MergeCPCleaner cp_cleaner(loader_data, merge_cp_oop);
HandleMark hm(THREAD); // make sure handles are cleared before
@@ -1472,7 +1484,8 @@
// Replace the new constant pool with a shrunken copy of the
// merged constant pool
- set_new_constant_pool(loader_data, scratch_class, merge_cp, merge_cp_length, THREAD);
+ set_new_constant_pool(loader_data, scratch_class, merge_cp, merge_cp_length,
+ CHECK_(JVMTI_ERROR_OUT_OF_MEMORY));
// The new constant pool replaces scratch_cp so have cleaner clean it up.
// It can't be cleaned up while there are handles to it.
cp_cleaner.add_scratch_cp(scratch_cp());
@@ -1502,7 +1515,8 @@
// merged constant pool so now the rewritten bytecodes have
// valid references; the previous new constant pool will get
// GCed.
- set_new_constant_pool(loader_data, scratch_class, merge_cp, merge_cp_length, THREAD);
+ set_new_constant_pool(loader_data, scratch_class, merge_cp, merge_cp_length,
+ CHECK_(JVMTI_ERROR_OUT_OF_MEMORY));
// The new constant pool replaces scratch_cp so have cleaner clean it up.
// It can't be cleaned up while there are handles to it.
cp_cleaner.add_scratch_cp(scratch_cp());
@@ -1590,11 +1604,23 @@
for (int i = methods->length() - 1; i >= 0; i--) {
methodHandle method(THREAD, methods->at(i));
methodHandle new_method;
- rewrite_cp_refs_in_method(method, &new_method, CHECK_false);
+ rewrite_cp_refs_in_method(method, &new_method, THREAD);
if (!new_method.is_null()) {
// the method has been replaced so save the new method version
+ // even in the case of an exception. original method is on the
+ // deallocation list.
methods->at_put(i, new_method());
}
+ if (HAS_PENDING_EXCEPTION) {
+ Symbol* ex_name = PENDING_EXCEPTION->klass()->name();
+ // RC_TRACE_WITH_THREAD macro has an embedded ResourceMark
+ RC_TRACE_WITH_THREAD(0x00000002, THREAD,
+ ("rewrite_cp_refs_in_method exception: '%s'", ex_name->as_C_string()));
+ // Need to clear pending exception here as the super caller sets
+ // the JVMTI_ERROR_INTERNAL if the returned value is false.
+ CLEAR_PENDING_EXCEPTION;
+ return false;
+ }
}
return true;
@@ -1674,10 +1700,7 @@
Pause_No_Safepoint_Verifier pnsv(&nsv);
// ldc is 2 bytes and ldc_w is 3 bytes
- m = rc.insert_space_at(bci, 3, inst_buffer, THREAD);
- if (m.is_null() || HAS_PENDING_EXCEPTION) {
- guarantee(false, "insert_space_at() failed");
- }
+ m = rc.insert_space_at(bci, 3, inst_buffer, CHECK);
}
// return the new method so that the caller can update
@@ -2487,8 +2510,8 @@
// scratch_cp is a merged constant pool and has enough space for a
// worst case merge situation. We want to associate the minimum
// sized constant pool with the klass to save space.
- constantPoolHandle smaller_cp(THREAD,
- ConstantPool::allocate(loader_data, scratch_cp_length, THREAD));
+ ConstantPool* cp = ConstantPool::allocate(loader_data, scratch_cp_length, CHECK);
+ constantPoolHandle smaller_cp(THREAD, cp);
// preserve version() value in the smaller copy
int version = scratch_cp->version();
@@ -2500,6 +2523,11 @@
smaller_cp->set_pool_holder(scratch_class());
scratch_cp->copy_cp_to(1, scratch_cp_length - 1, smaller_cp, 1, THREAD);
+ if (HAS_PENDING_EXCEPTION) {
+ // Exception is handled in the caller
+ loader_data->add_to_deallocate_list(smaller_cp());
+ return;
+ }
scratch_cp = smaller_cp;
// attach new constant pool to klass
@@ -2930,7 +2958,7 @@
for (int i = 0; i < _deleted_methods_length; ++i) {
Method* old_method = _deleted_methods[i];
- assert(old_method->vtable_index() < 0,
+ assert(!old_method->has_vtable_index(),
"cannot delete methods with vtable entries");;
// Mark all deleted methods as old and obsolete
--- a/hotspot/src/share/vm/prims/methodHandles.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/prims/methodHandles.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -127,25 +127,37 @@
}
oop MethodHandles::init_MemberName(Handle mname, Handle target) {
+ // This method is used from java.lang.invoke.MemberName constructors.
+ // It fills in the new MemberName from a java.lang.reflect.Member.
Thread* thread = Thread::current();
oop target_oop = target();
Klass* target_klass = target_oop->klass();
if (target_klass == SystemDictionary::reflect_Field_klass()) {
oop clazz = java_lang_reflect_Field::clazz(target_oop); // fd.field_holder()
int slot = java_lang_reflect_Field::slot(target_oop); // fd.index()
- int mods = java_lang_reflect_Field::modifiers(target_oop);
- oop type = java_lang_reflect_Field::type(target_oop);
- oop name = java_lang_reflect_Field::name(target_oop);
KlassHandle k(thread, java_lang_Class::as_Klass(clazz));
- intptr_t offset = InstanceKlass::cast(k())->field_offset(slot);
- return init_field_MemberName(mname, k, accessFlags_from(mods), type, name, offset);
+ if (!k.is_null() && k->oop_is_instance()) {
+ fieldDescriptor fd(InstanceKlass::cast(k()), slot);
+ oop mname2 = init_field_MemberName(mname, fd);
+ if (mname2 != NULL) {
+ // Since we have the reified name and type handy, add them to the result.
+ if (java_lang_invoke_MemberName::name(mname2) == NULL)
+ java_lang_invoke_MemberName::set_name(mname2, java_lang_reflect_Field::name(target_oop));
+ if (java_lang_invoke_MemberName::type(mname2) == NULL)
+ java_lang_invoke_MemberName::set_type(mname2, java_lang_reflect_Field::type(target_oop));
+ }
+ return mname2;
+ }
} else if (target_klass == SystemDictionary::reflect_Method_klass()) {
oop clazz = java_lang_reflect_Method::clazz(target_oop);
int slot = java_lang_reflect_Method::slot(target_oop);
KlassHandle k(thread, java_lang_Class::as_Klass(clazz));
if (!k.is_null() && k->oop_is_instance()) {
Method* m = InstanceKlass::cast(k())->method_with_idnum(slot);
- return init_method_MemberName(mname, m, true, k);
+ if (m == NULL || is_signature_polymorphic(m->intrinsic_id()))
+ return NULL; // do not resolve unless there is a concrete signature
+ CallInfo info(m, k());
+ return init_method_MemberName(mname, info);
}
} else if (target_klass == SystemDictionary::reflect_Constructor_klass()) {
oop clazz = java_lang_reflect_Constructor::clazz(target_oop);
@@ -153,65 +165,50 @@
KlassHandle k(thread, java_lang_Class::as_Klass(clazz));
if (!k.is_null() && k->oop_is_instance()) {
Method* m = InstanceKlass::cast(k())->method_with_idnum(slot);
- return init_method_MemberName(mname, m, false, k);
- }
- } else if (target_klass == SystemDictionary::MemberName_klass()) {
- // Note: This only works if the MemberName has already been resolved.
- oop clazz = java_lang_invoke_MemberName::clazz(target_oop);
- int flags = java_lang_invoke_MemberName::flags(target_oop);
- Metadata* vmtarget=java_lang_invoke_MemberName::vmtarget(target_oop);
- intptr_t vmindex = java_lang_invoke_MemberName::vmindex(target_oop);
- KlassHandle k(thread, java_lang_Class::as_Klass(clazz));
- int ref_kind = (flags >> REFERENCE_KIND_SHIFT) & REFERENCE_KIND_MASK;
- if (vmtarget == NULL) return NULL; // not resolved
- if ((flags & IS_FIELD) != 0) {
- assert(vmtarget->is_klass(), "field vmtarget is Klass*");
- int basic_mods = (ref_kind_is_static(ref_kind) ? JVM_ACC_STATIC : 0);
- // FIXME: how does k (receiver_limit) contribute?
- KlassHandle k_vmtarget(thread, (Klass*)vmtarget);
- return init_field_MemberName(mname, k_vmtarget, accessFlags_from(basic_mods), NULL, NULL, vmindex);
- } else if ((flags & (IS_METHOD | IS_CONSTRUCTOR)) != 0) {
- assert(vmtarget->is_method(), "method or constructor vmtarget is Method*");
- return init_method_MemberName(mname, (Method*)vmtarget, ref_kind_does_dispatch(ref_kind), k);
- } else {
- return NULL;
+ if (m == NULL) return NULL;
+ CallInfo info(m, k());
+ return init_method_MemberName(mname, info);
}
}
return NULL;
}
-oop MethodHandles::init_method_MemberName(Handle mname, Method* m, bool do_dispatch,
- KlassHandle receiver_limit_h) {
- Klass* receiver_limit = receiver_limit_h();
- AccessFlags mods = m->access_flags();
- int flags = (jushort)( mods.as_short() & JVM_RECOGNIZED_METHOD_MODIFIERS );
- int vmindex = Method::nonvirtual_vtable_index; // implies never any dispatch
- Klass* mklass = m->method_holder();
- if (receiver_limit == NULL)
- receiver_limit = mklass;
- if (m->is_initializer()) {
- flags |= IS_CONSTRUCTOR | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
- } else if (mods.is_static()) {
- flags |= IS_METHOD | (JVM_REF_invokeStatic << REFERENCE_KIND_SHIFT);
- } else if (receiver_limit != mklass &&
- !receiver_limit->is_subtype_of(mklass)) {
- return NULL; // bad receiver limit
- } else if (do_dispatch && receiver_limit->is_interface() &&
- mklass->is_interface()) {
+oop MethodHandles::init_method_MemberName(Handle mname, CallInfo& info) {
+ assert(info.resolved_appendix().is_null(), "only normal methods here");
+ KlassHandle receiver_limit = info.resolved_klass();
+ methodHandle m = info.resolved_method();
+ int flags = (jushort)( m->access_flags().as_short() & JVM_RECOGNIZED_METHOD_MODIFIERS );
+ int vmindex = Method::invalid_vtable_index;
+
+ switch (info.call_kind()) {
+ case CallInfo::itable_call:
+ vmindex = info.itable_index();
+ // More importantly, the itable index only works with the method holder.
+ receiver_limit = m->method_holder();
+ assert(receiver_limit->verify_itable_index(vmindex), "");
flags |= IS_METHOD | (JVM_REF_invokeInterface << REFERENCE_KIND_SHIFT);
- receiver_limit = mklass; // ignore passed-in limit; interfaces are interconvertible
- vmindex = klassItable::compute_itable_index(m);
- } else if (do_dispatch && mklass != receiver_limit && mklass->is_interface()) {
+ break;
+
+ case CallInfo::vtable_call:
+ vmindex = info.vtable_index();
flags |= IS_METHOD | (JVM_REF_invokeVirtual << REFERENCE_KIND_SHIFT);
- // it is a miranda method, so m->vtable_index is not what we want
- ResourceMark rm;
- klassVtable* vt = InstanceKlass::cast(receiver_limit)->vtable();
- vmindex = vt->index_of_miranda(m->name(), m->signature());
- } else if (!do_dispatch || m->can_be_statically_bound()) {
- flags |= IS_METHOD | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
- } else {
- flags |= IS_METHOD | (JVM_REF_invokeVirtual << REFERENCE_KIND_SHIFT);
- vmindex = m->vtable_index();
+ assert(receiver_limit->is_subtype_of(m->method_holder()), "virtual call must be type-safe");
+ break;
+
+ case CallInfo::direct_call:
+ vmindex = Method::nonvirtual_vtable_index;
+ if (m->is_static()) {
+ flags |= IS_METHOD | (JVM_REF_invokeStatic << REFERENCE_KIND_SHIFT);
+ } else if (m->is_initializer()) {
+ flags |= IS_CONSTRUCTOR | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
+ assert(receiver_limit == m->method_holder(), "constructor call must be exactly typed");
+ } else {
+ flags |= IS_METHOD | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
+ assert(receiver_limit->is_subtype_of(m->method_holder()), "special call must be type-safe");
+ }
+ break;
+
+ default: assert(false, "bad CallInfo"); return NULL;
}
// @CallerSensitive annotation detected
@@ -221,7 +218,7 @@
oop mname_oop = mname();
java_lang_invoke_MemberName::set_flags( mname_oop, flags);
- java_lang_invoke_MemberName::set_vmtarget(mname_oop, m);
+ java_lang_invoke_MemberName::set_vmtarget(mname_oop, m());
java_lang_invoke_MemberName::set_vmindex( mname_oop, vmindex); // vtable/itable index
java_lang_invoke_MemberName::set_clazz( mname_oop, receiver_limit->java_mirror());
// Note: name and type can be lazily computed by resolve_MemberName,
@@ -237,59 +234,19 @@
return mname();
}
-Handle MethodHandles::init_method_MemberName(Handle mname, CallInfo& info, TRAPS) {
- Handle empty;
- if (info.resolved_appendix().not_null()) {
- // The resolved MemberName must not be accompanied by an appendix argument,
- // since there is no way to bind this value into the MemberName.
- // Caller is responsible to prevent this from happening.
- THROW_MSG_(vmSymbols::java_lang_InternalError(), "appendix", empty);
- }
- methodHandle m = info.resolved_method();
- KlassHandle defc = info.resolved_klass();
- int vmindex = Method::invalid_vtable_index;
- if (defc->is_interface() && m->method_holder()->is_interface()) {
- // static interface methods do not reference vtable or itable
- if (m->is_static()) {
- vmindex = Method::nonvirtual_vtable_index;
- }
- // interface methods invoked via invokespecial also
- // do not reference vtable or itable.
- int ref_kind = ((java_lang_invoke_MemberName::flags(mname()) >>
- REFERENCE_KIND_SHIFT) & REFERENCE_KIND_MASK);
- if (ref_kind == JVM_REF_invokeSpecial) {
- vmindex = Method::nonvirtual_vtable_index;
- }
- // If neither m is static nor ref_kind is invokespecial,
- // set it to itable index.
- if (vmindex == Method::invalid_vtable_index) {
- // LinkResolver does not report itable indexes! (fix this?)
- vmindex = klassItable::compute_itable_index(m());
- }
- } else if (m->can_be_statically_bound()) {
- // LinkResolver reports vtable index even for final methods!
- vmindex = Method::nonvirtual_vtable_index;
- } else {
- vmindex = info.vtable_index();
- }
- oop res = init_method_MemberName(mname, m(), (vmindex >= 0), defc());
- assert(res == NULL || (java_lang_invoke_MemberName::vmindex(res) == vmindex), "");
- return Handle(THREAD, res);
-}
-
-oop MethodHandles::init_field_MemberName(Handle mname, KlassHandle field_holder,
- AccessFlags mods, oop type, oop name,
- intptr_t offset, bool is_setter) {
- int flags = (jushort)( mods.as_short() & JVM_RECOGNIZED_FIELD_MODIFIERS );
- flags |= IS_FIELD | ((mods.is_static() ? JVM_REF_getStatic : JVM_REF_getField) << REFERENCE_KIND_SHIFT);
+oop MethodHandles::init_field_MemberName(Handle mname, fieldDescriptor& fd, bool is_setter) {
+ int flags = (jushort)( fd.access_flags().as_short() & JVM_RECOGNIZED_FIELD_MODIFIERS );
+ flags |= IS_FIELD | ((fd.is_static() ? JVM_REF_getStatic : JVM_REF_getField) << REFERENCE_KIND_SHIFT);
if (is_setter) flags += ((JVM_REF_putField - JVM_REF_getField) << REFERENCE_KIND_SHIFT);
- Metadata* vmtarget = field_holder();
- int vmindex = offset; // determines the field uniquely when combined with static bit
+ Metadata* vmtarget = fd.field_holder();
+ int vmindex = fd.offset(); // determines the field uniquely when combined with static bit
oop mname_oop = mname();
java_lang_invoke_MemberName::set_flags(mname_oop, flags);
java_lang_invoke_MemberName::set_vmtarget(mname_oop, vmtarget);
java_lang_invoke_MemberName::set_vmindex(mname_oop, vmindex);
- java_lang_invoke_MemberName::set_clazz(mname_oop, field_holder->java_mirror());
+ java_lang_invoke_MemberName::set_clazz(mname_oop, fd.field_holder()->java_mirror());
+ oop type = field_signature_type_or_null(fd.signature());
+ oop name = field_name_or_null(fd.name());
if (name != NULL)
java_lang_invoke_MemberName::set_name(mname_oop, name);
if (type != NULL)
@@ -305,19 +262,6 @@
return mname();
}
-Handle MethodHandles::init_field_MemberName(Handle mname, FieldAccessInfo& info, TRAPS) {
- return Handle();
-#if 0 // FIXME
- KlassHandle field_holder = info.klass();
- intptr_t field_offset = info.field_offset();
- return init_field_MemberName(mname_oop, field_holder(),
- info.access_flags(),
- type, name,
- field_offset, false /*is_setter*/);
-#endif
-}
-
-
// JVM 2.9 Special Methods:
// A method is signature polymorphic if and only if all of the following conditions hold :
// * It is declared in the java.lang.invoke.MethodHandle class.
@@ -573,12 +517,12 @@
return SystemDictionary::Object_klass()->java_mirror();
}
-static oop field_name_or_null(Symbol* s) {
+oop MethodHandles::field_name_or_null(Symbol* s) {
if (s == NULL) return NULL;
return StringTable::lookup(s);
}
-static oop field_signature_type_or_null(Symbol* s) {
+oop MethodHandles::field_signature_type_or_null(Symbol* s) {
if (s == NULL) return NULL;
BasicType bt = FieldType::basic_type(s);
if (is_java_primitive(bt)) {
@@ -701,7 +645,14 @@
return empty;
}
}
- return init_method_MemberName(mname, result, THREAD);
+ if (result.resolved_appendix().not_null()) {
+ // The resolved MemberName must not be accompanied by an appendix argument,
+ // since there is no way to bind this value into the MemberName.
+ // Caller is responsible to prevent this from happening.
+ THROW_MSG_(vmSymbols::java_lang_InternalError(), "appendix", empty);
+ }
+ oop mname2 = init_method_MemberName(mname, result);
+ return Handle(THREAD, mname2);
}
case IS_CONSTRUCTOR:
{
@@ -719,22 +670,21 @@
}
}
assert(result.is_statically_bound(), "");
- return init_method_MemberName(mname, result, THREAD);
+ oop mname2 = init_method_MemberName(mname, result);
+ return Handle(THREAD, mname2);
}
case IS_FIELD:
{
- // This is taken from LinkResolver::resolve_field, sans access checks.
- fieldDescriptor fd; // find_field initializes fd if found
- KlassHandle sel_klass(THREAD, InstanceKlass::cast(defc())->find_field(name, type, &fd));
- // check if field exists; i.e., if a klass containing the field def has been selected
- if (sel_klass.is_null()) return empty; // should not happen
- oop type = field_signature_type_or_null(fd.signature());
- oop name = field_name_or_null(fd.name());
- bool is_setter = (ref_kind_is_valid(ref_kind) && ref_kind_is_setter(ref_kind));
- mname = Handle(THREAD,
- init_field_MemberName(mname, sel_klass,
- fd.access_flags(), type, name, fd.offset(), is_setter));
- return mname;
+ fieldDescriptor result; // find_field initializes fd if found
+ {
+ assert(!HAS_PENDING_EXCEPTION, "");
+ LinkResolver::resolve_field(result, defc, name, type, KlassHandle(), Bytecodes::_nop, false, false, THREAD);
+ if (HAS_PENDING_EXCEPTION) {
+ return empty;
+ }
+ }
+ oop mname2 = init_field_MemberName(mname, result, ref_kind_is_setter(ref_kind));
+ return Handle(THREAD, mname2);
}
default:
THROW_MSG_(vmSymbols::java_lang_InternalError(), "unrecognized MemberName format", empty);
@@ -793,7 +743,6 @@
}
case IS_FIELD:
{
- // This is taken from LinkResolver::resolve_field, sans access checks.
assert(vmtarget->is_klass(), "field vmtarget is Klass*");
if (!((Klass*) vmtarget)->oop_is_instance()) break;
instanceKlassHandle defc(THREAD, (Klass*) vmtarget);
@@ -872,11 +821,7 @@
Handle result(thread, results->obj_at(rfill++));
if (!java_lang_invoke_MemberName::is_instance(result()))
return -99; // caller bug!
- oop type = field_signature_type_or_null(st.signature());
- oop name = field_name_or_null(st.name());
- oop saved = MethodHandles::init_field_MemberName(result, st.klass(),
- st.access_flags(), type, name,
- st.offset());
+ oop saved = MethodHandles::init_field_MemberName(result, st.field_descriptor());
if (saved != result())
results->obj_at_put(rfill-1, saved); // show saved instance to user
} else if (++overflow >= overflow_limit) {
@@ -926,7 +871,8 @@
Handle result(thread, results->obj_at(rfill++));
if (!java_lang_invoke_MemberName::is_instance(result()))
return -99; // caller bug!
- oop saved = MethodHandles::init_method_MemberName(result, m, true, NULL);
+ CallInfo info(m);
+ oop saved = MethodHandles::init_method_MemberName(result, info);
if (saved != result())
results->obj_at_put(rfill-1, saved); // show saved instance to user
} else if (++overflow >= overflow_limit) {
@@ -1227,7 +1173,8 @@
x = ((Klass*) vmtarget)->java_mirror();
} else if (vmtarget->is_method()) {
Handle mname2 = MethodHandles::new_MemberName(CHECK_NULL);
- x = MethodHandles::init_method_MemberName(mname2, (Method*)vmtarget, false, NULL);
+ CallInfo info((Method*)vmtarget);
+ x = MethodHandles::init_method_MemberName(mname2, info);
}
result->obj_at_put(1, x);
return JNIHandles::make_local(env, result());
--- a/hotspot/src/share/vm/prims/methodHandles.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/prims/methodHandles.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -49,19 +49,18 @@
// Adapters.
static MethodHandlesAdapterBlob* _adapter_code;
+ // utility functions for reifying names and types
+ static oop field_name_or_null(Symbol* s);
+ static oop field_signature_type_or_null(Symbol* s);
+
public:
// working with member names
static Handle resolve_MemberName(Handle mname, TRAPS); // compute vmtarget/vmindex from name/type
static void expand_MemberName(Handle mname, int suppress, TRAPS); // expand defc/name/type if missing
static Handle new_MemberName(TRAPS); // must be followed by init_MemberName
static oop init_MemberName(Handle mname_h, Handle target_h); // compute vmtarget/vmindex from target
- static oop init_method_MemberName(Handle mname_h, Method* m, bool do_dispatch,
- KlassHandle receiver_limit_h);
- static oop init_field_MemberName(Handle mname_h, KlassHandle field_holder_h,
- AccessFlags mods, oop type, oop name,
- intptr_t offset, bool is_setter = false);
- static Handle init_method_MemberName(Handle mname_h, CallInfo& info, TRAPS);
- static Handle init_field_MemberName(Handle mname_h, FieldAccessInfo& info, TRAPS);
+ static oop init_field_MemberName(Handle mname_h, fieldDescriptor& fd, bool is_setter = false);
+ static oop init_method_MemberName(Handle mname_h, CallInfo& info);
static int method_ref_kind(Method* m, bool do_dispatch_if_possible = true);
static int find_MemberNames(KlassHandle k, Symbol* name, Symbol* sig,
int mflags, KlassHandle caller,
--- a/hotspot/src/share/vm/runtime/arguments.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/runtime/arguments.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -1869,7 +1869,7 @@
(NumberOfGCLogFiles == 0) ||
(GCLogFileSize == 0)) {
jio_fprintf(defaultStream::output_stream(),
- "To enable GC log rotation, use -Xloggc:<filename> -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=<num_of_files> -XX:GCLogFileSize=<num_of_size>\n"
+ "To enable GC log rotation, use -Xloggc:<filename> -XX:+UseGCLogFileRotation -XX:NumberOfGCLogFiles=<num_of_files> -XX:GCLogFileSize=<num_of_size>[k|K|m|M|g|G]\n"
"where num_of_file > 0 and num_of_size > 0\n"
"GC log rotation is turned off\n");
UseGCLogFileRotation = false;
@@ -1883,6 +1883,51 @@
}
}
+// This function is called for -Xloggc:<filename>, it can be used
+// to check if a given file name(or string) conforms to the following
+// specification:
+// A valid string only contains "[A-Z][a-z][0-9].-_%[p|t]"
+// %p and %t only allowed once. We only limit usage of filename not path
+bool is_filename_valid(const char *file_name) {
+ const char* p = file_name;
+ char file_sep = os::file_separator()[0];
+ const char* cp;
+ // skip prefix path
+ for (cp = file_name; *cp != '\0'; cp++) {
+ if (*cp == '/' || *cp == file_sep) {
+ p = cp + 1;
+ }
+ }
+
+ int count_p = 0;
+ int count_t = 0;
+ while (*p != '\0') {
+ if ((*p >= '0' && *p <= '9') ||
+ (*p >= 'A' && *p <= 'Z') ||
+ (*p >= 'a' && *p <= 'z') ||
+ *p == '-' ||
+ *p == '_' ||
+ *p == '.') {
+ p++;
+ continue;
+ }
+ if (*p == '%') {
+ if(*(p + 1) == 'p') {
+ p += 2;
+ count_p ++;
+ continue;
+ }
+ if (*(p + 1) == 't') {
+ p += 2;
+ count_t ++;
+ continue;
+ }
+ }
+ return false;
+ }
+ return count_p < 2 && count_t < 2;
+}
+
// Check consistency of GC selection
bool Arguments::check_gc_consistency() {
check_gclog_consistency();
@@ -2836,6 +2881,13 @@
// ostream_init_log(), when called will use this filename
// to initialize a fileStream.
_gc_log_filename = strdup(tail);
+ if (!is_filename_valid(_gc_log_filename)) {
+ jio_fprintf(defaultStream::output_stream(),
+ "Invalid file name for use with -Xloggc: Filename can only contain the "
+ "characters [A-Z][a-z][0-9]-_.%%[p|t] but it has been %s\n"
+ "Note %%p or %%t can only be used once\n", _gc_log_filename);
+ return JNI_EINVAL;
+ }
FLAG_SET_CMDLINE(bool, PrintGC, true);
FLAG_SET_CMDLINE(bool, PrintGCTimeStamps, true);
@@ -3356,6 +3408,33 @@
return shared_archive_path;
}
+#ifndef PRODUCT
+// Determine whether LogVMOutput should be implicitly turned on.
+static bool use_vm_log() {
+ if (LogCompilation || !FLAG_IS_DEFAULT(LogFile) ||
+ PrintCompilation || PrintInlining || PrintDependencies || PrintNativeNMethods ||
+ PrintDebugInfo || PrintRelocations || PrintNMethods || PrintExceptionHandlers ||
+ PrintAssembly || TraceDeoptimization || TraceDependencies ||
+ (VerifyDependencies && FLAG_IS_CMDLINE(VerifyDependencies))) {
+ return true;
+ }
+
+#ifdef COMPILER1
+ if (PrintC1Statistics) {
+ return true;
+ }
+#endif // COMPILER1
+
+#ifdef COMPILER2
+ if (PrintOptoAssembly || PrintOptoStatistics) {
+ return true;
+ }
+#endif // COMPILER2
+
+ return false;
+}
+#endif // PRODUCT
+
// Parse entry point called from JNI_CreateJavaVM
jint Arguments::parse(const JavaVMInitArgs* args) {
@@ -3656,7 +3735,13 @@
NmethodSweepFraction = 1;
}
}
-#endif
+
+ if (!LogVMOutput && FLAG_IS_DEFAULT(LogVMOutput)) {
+ if (use_vm_log()) {
+ LogVMOutput = true;
+ }
+ }
+#endif // PRODUCT
if (PrintCommandLineFlags) {
CommandLineFlags::printSetFlags(tty);
--- a/hotspot/src/share/vm/runtime/arguments.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/runtime/arguments.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -144,7 +144,7 @@
void set_os_lib(void* os_lib) { _os_lib = os_lib; }
AgentLibrary* next() const { return _next; }
bool is_static_lib() const { return _is_static_lib; }
- void set_static_lib(bool static_lib) { _is_static_lib = static_lib; }
+ 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; }
--- a/hotspot/src/share/vm/runtime/deoptimization.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/runtime/deoptimization.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -1751,7 +1751,7 @@
else return trap_state & ~DS_RECOMPILE_BIT;
}
//---------------------------format_trap_state---------------------------------
-// This is used for debugging and diagnostics, including hotspot.log output.
+// This is used for debugging and diagnostics, including LogFile output.
const char* Deoptimization::format_trap_state(char* buf, size_t buflen,
int trap_state) {
DeoptReason reason = trap_state_reason(trap_state);
@@ -1828,7 +1828,7 @@
return buf;
}
-// This is used for debugging and diagnostics, including hotspot.log output.
+// This is used for debugging and diagnostics, including LogFile output.
const char* Deoptimization::format_trap_request(char* buf, size_t buflen,
int trap_request) {
jint unloaded_class_index = trap_request_index(trap_request);
--- a/hotspot/src/share/vm/runtime/fieldDescriptor.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/runtime/fieldDescriptor.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -97,18 +97,32 @@
return constants()->uncached_string_at(initial_value_index(), CHECK_0);
}
-void fieldDescriptor::initialize(InstanceKlass* ik, int index) {
- _cp = ik->constants();
+void fieldDescriptor::reinitialize(InstanceKlass* ik, int index) {
+ if (_cp.is_null() || field_holder() != ik) {
+ _cp = constantPoolHandle(Thread::current(), ik->constants());
+ // _cp should now reference ik's constant pool; i.e., ik is now field_holder.
+ assert(field_holder() == ik, "must be already initialized to this class");
+ }
FieldInfo* f = ik->field(index);
assert(!f->is_internal(), "regular Java fields only");
_access_flags = accessFlags_from(f->access_flags());
guarantee(f->name_index() != 0 && f->signature_index() != 0, "bad constant pool index for fieldDescriptor");
_index = index;
+ verify();
}
#ifndef PRODUCT
+void fieldDescriptor::verify() const {
+ if (_cp.is_null()) {
+ assert(_index == badInt, "constructor must be called"); // see constructor
+ } else {
+ assert(_index >= 0, "good index");
+ assert(_index < field_holder()->java_fields_count(), "oob");
+ }
+}
+
void fieldDescriptor::print_on(outputStream* st) const {
access_flags().print_on(st);
name()->print_value_on(st);
--- a/hotspot/src/share/vm/runtime/fieldDescriptor.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/runtime/fieldDescriptor.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -53,6 +53,13 @@
}
public:
+ fieldDescriptor() {
+ DEBUG_ONLY(_index = badInt);
+ }
+ fieldDescriptor(InstanceKlass* ik, int index) {
+ DEBUG_ONLY(_index = badInt);
+ reinitialize(ik, index);
+ }
Symbol* name() const {
return field()->name(_cp);
}
@@ -112,12 +119,13 @@
}
// Initialization
- void initialize(InstanceKlass* ik, int index);
+ void reinitialize(InstanceKlass* ik, int index);
// Print
void print() { print_on(tty); }
void print_on(outputStream* st) const PRODUCT_RETURN;
void print_on_for(outputStream* st, oop obj) PRODUCT_RETURN;
+ void verify() const PRODUCT_RETURN;
};
#endif // SHARE_VM_RUNTIME_FIELDDESCRIPTOR_HPP
--- a/hotspot/src/share/vm/runtime/frame.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/runtime/frame.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -652,7 +652,7 @@
// Return whether the frame is in the VM or os indicating a Hotspot problem.
// Otherwise, it's likely a bug in the native library that the Java code calls,
// hopefully indicating where to submit bugs.
-static void print_C_frame(outputStream* st, char* buf, int buflen, address pc) {
+void frame::print_C_frame(outputStream* st, char* buf, int buflen, address pc) {
// C/C++ frame
bool in_vm = os::address_is_in_vm(pc);
st->print(in_vm ? "V" : "C");
--- a/hotspot/src/share/vm/runtime/frame.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/runtime/frame.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -406,6 +406,7 @@
void print_on(outputStream* st) const;
void interpreter_frame_print_on(outputStream* st) const;
void print_on_error(outputStream* st, char* buf, int buflen, bool verbose = false) const;
+ static void print_C_frame(outputStream* st, char* buf, int buflen, address pc);
// Add annotated descriptions of memory locations belonging to this frame to values
void describe(FrameValues& values, int frame_no);
--- a/hotspot/src/share/vm/runtime/globals.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/runtime/globals.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -880,7 +880,7 @@
"stay alive at the expense of JVM performance") \
\
diagnostic(bool, LogCompilation, false, \
- "Log compilation activity in detail to hotspot.log or LogFile") \
+ "Log compilation activity in detail to LogFile") \
\
product(bool, PrintCompilation, false, \
"Print compilations") \
@@ -2498,16 +2498,17 @@
"Print all VM flags with default values and descriptions and exit")\
\
diagnostic(bool, SerializeVMOutput, true, \
- "Use a mutex to serialize output to tty and hotspot.log") \
+ "Use a mutex to serialize output to tty and LogFile") \
\
diagnostic(bool, DisplayVMOutput, true, \
"Display all VM output on the tty, independently of LogVMOutput") \
\
- diagnostic(bool, LogVMOutput, trueInDebug, \
- "Save VM output to hotspot.log, or to LogFile") \
+ diagnostic(bool, LogVMOutput, false, \
+ "Save VM output to LogFile") \
\
diagnostic(ccstr, LogFile, NULL, \
- "If LogVMOutput is on, save VM output to this file [hotspot.log]") \
+ "If LogVMOutput or LogCompilation is on, save VM output to " \
+ "this file [default: ./hotspot_pid%p.log] (%p replaced with pid)") \
\
product(ccstr, ErrorFile, NULL, \
"If an error occurs, save the error data to this file " \
--- a/hotspot/src/share/vm/runtime/mutexLocker.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/runtime/mutexLocker.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -45,7 +45,6 @@
Mutex* VMStatistic_lock = NULL;
Mutex* JNIGlobalHandle_lock = NULL;
Mutex* JNIHandleBlockFreeList_lock = NULL;
-Mutex* JNICachedItableIndex_lock = NULL;
Mutex* MemberNameTable_lock = NULL;
Mutex* JmethodIdCreation_lock = NULL;
Mutex* JfieldIdCreation_lock = NULL;
@@ -253,7 +252,6 @@
}
def(Heap_lock , Monitor, nonleaf+1, false);
def(JfieldIdCreation_lock , Mutex , nonleaf+1, true ); // jfieldID, Used in VM_Operation
- def(JNICachedItableIndex_lock , Mutex , nonleaf+1, false); // Used to cache an itable index during JNI invoke
def(MemberNameTable_lock , Mutex , nonleaf+1, false); // Used to protect MemberNameTable
def(CompiledIC_lock , Mutex , nonleaf+2, false); // locks VtableStubs_lock, InlineCacheBuffer_lock
--- a/hotspot/src/share/vm/runtime/mutexLocker.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/runtime/mutexLocker.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -50,7 +50,6 @@
extern Mutex* VMStatistic_lock; // a lock used to guard statistics count increment
extern Mutex* JNIGlobalHandle_lock; // a lock on creating JNI global handles
extern Mutex* JNIHandleBlockFreeList_lock; // a lock on the JNI handle block free list
-extern Mutex* JNICachedItableIndex_lock; // a lock on caching an itable index during JNI invoke
extern Mutex* MemberNameTable_lock; // a lock on the MemberNameTable updates
extern Mutex* JmethodIdCreation_lock; // a lock on creating JNI method identifiers
extern Mutex* JfieldIdCreation_lock; // a lock on creating JNI static field identifiers
--- a/hotspot/src/share/vm/runtime/os.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/runtime/os.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -459,6 +459,7 @@
*/
void* os::find_agent_function(AgentLibrary *agent_lib, bool check_lib,
const char *syms[], size_t syms_len) {
+ assert(agent_lib != NULL, "sanity check");
const char *lib_name;
void *handle = agent_lib->os_lib();
void *entryName = NULL;
@@ -489,6 +490,7 @@
void *proc_handle;
void *save_handle;
+ assert(agent_lib != NULL, "sanity check");
if (agent_lib->name() == NULL) {
return false;
}
@@ -498,14 +500,13 @@
// We want to look in this process' symbol table.
agent_lib->set_os_lib(proc_handle);
ret = find_agent_function(agent_lib, true, syms, syms_len);
- agent_lib->set_os_lib(save_handle);
if (ret != NULL) {
// Found an entry point like Agent_OnLoad_lib_name so we have a static agent
- agent_lib->set_os_lib(proc_handle);
agent_lib->set_valid();
agent_lib->set_static_lib(true);
return true;
}
+ agent_lib->set_os_lib(save_handle);
return false;
}
--- a/hotspot/src/share/vm/runtime/os.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/runtime/os.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -91,6 +91,8 @@
typedef void (*java_call_t)(JavaValue* value, methodHandle* method, JavaCallArguments* args, Thread* thread);
class os: AllStatic {
+ friend class VMStructs;
+
public:
enum { page_sizes_max = 9 }; // Size of _page_sizes array (8 plus a sentinel)
@@ -803,6 +805,14 @@
#endif
public:
+#ifndef PLATFORM_PRINT_NATIVE_STACK
+ // No platform-specific code for printing the native stack.
+ static bool platform_print_native_stack(outputStream* st, void* context,
+ char *buf, int buf_size) {
+ return false;
+ }
+#endif
+
// debugging support (mostly used by debug.cpp but also fatal error handler)
static bool find(address pc, outputStream* st = tty); // OS specific function to make sense out of an address
--- a/hotspot/src/share/vm/runtime/reflection.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/runtime/reflection.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -952,7 +952,8 @@
}
} else {
// if the method can be overridden, we resolve using the vtable index.
- int index = reflected_method->vtable_index();
+ assert(!reflected_method->has_itable_index(), "");
+ int index = reflected_method->vtable_index();
method = reflected_method;
if (index != Method::nonvirtual_vtable_index) {
// target_klass might be an arrayKlassOop but all vtables start at
--- a/hotspot/src/share/vm/runtime/reflectionUtils.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/runtime/reflectionUtils.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -109,6 +109,8 @@
private:
int length() const { return _klass->java_fields_count(); }
+ fieldDescriptor _fd_buf;
+
public:
FieldStream(instanceKlassHandle klass, bool local_only, bool classes_only)
: KlassStream(klass, local_only, classes_only) {
@@ -134,6 +136,12 @@
int offset() const {
return _klass->field_offset( index() );
}
+ // bridge to a heavier API:
+ fieldDescriptor& field_descriptor() const {
+ fieldDescriptor& field = const_cast<fieldDescriptor&>(_fd_buf);
+ field.reinitialize(_klass(), _index);
+ return field;
+ }
};
class FilteredField : public CHeapObj<mtInternal> {
--- a/hotspot/src/share/vm/runtime/sweeper.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/runtime/sweeper.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -269,6 +269,7 @@
// the number of nmethods changes during the sweep so the final
// stage must iterate until it there are no more nmethods.
int todo = (CodeCache::nof_nmethods() - _seen) / _invocations;
+ int swept_count = 0;
assert(!SafepointSynchronize::is_at_safepoint(), "should not be in safepoint when we get here");
assert(!CodeCache_lock->owned_by_self(), "just checking");
@@ -278,6 +279,7 @@
// The last invocation iterates until there are no more nmethods
for (int i = 0; (i < todo || _invocations == 1) && _current != NULL; i++) {
+ swept_count++;
if (SafepointSynchronize::is_synchronizing()) { // Safepoint request
if (PrintMethodFlushing && Verbose) {
tty->print_cr("### Sweep at %d out of %d, invocation: %d, yielding to safepoint", _seen, CodeCache::nof_nmethods(), _invocations);
@@ -331,7 +333,7 @@
event.set_endtime(sweep_end_counter);
event.set_sweepIndex(_traversals);
event.set_sweepFractionIndex(NmethodSweepFraction - _invocations + 1);
- event.set_sweptCount(todo);
+ event.set_sweptCount(swept_count);
event.set_flushedCount(_flushed_count);
event.set_markedCount(_marked_count);
event.set_zombifiedCount(_zombified_count);
--- a/hotspot/src/share/vm/runtime/thread.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/runtime/thread.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -333,6 +333,8 @@
// Reclaim the objectmonitors from the omFreeList of the moribund thread.
ObjectSynchronizer::omFlush (this) ;
+ EVENT_THREAD_DESTRUCT(this);
+
// stack_base can be NULL if the thread is never started or exited before
// record_stack_base_and_size called. Although, we would like to ensure
// that all started threads do call record_stack_base_and_size(), there is
@@ -3719,7 +3721,7 @@
const char *name = agent->name();
const char *msg = "Could not find agent library ";
- // First check to see if agent is statcally linked into executable
+ // First check to see if agent is statically linked into executable
if (os::find_builtin_agent(agent, on_load_symbols, num_symbol_entries)) {
library = agent->os_lib();
} else if (agent->is_absolute_path()) {
--- a/hotspot/src/share/vm/runtime/vmStructs.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/runtime/vmStructs.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -315,7 +315,6 @@
nonstatic_field(InstanceKlass, _breakpoints, BreakpointInfo*) \
nonstatic_field(InstanceKlass, _generic_signature_index, u2) \
nonstatic_field(InstanceKlass, _methods_jmethod_ids, jmethodID*) \
- nonstatic_field(InstanceKlass, _methods_cached_itable_indices, int*) \
volatile_nonstatic_field(InstanceKlass, _idnum_allocated_count, u2) \
nonstatic_field(InstanceKlass, _annotations, Annotations*) \
nonstatic_field(InstanceKlass, _dependencies, nmethodBucket*) \
@@ -330,11 +329,13 @@
nonstatic_field(Klass, _java_mirror, oop) \
nonstatic_field(Klass, _modifier_flags, jint) \
nonstatic_field(Klass, _super, Klass*) \
+ nonstatic_field(Klass, _subklass, Klass*) \
nonstatic_field(Klass, _layout_helper, jint) \
nonstatic_field(Klass, _name, Symbol*) \
nonstatic_field(Klass, _access_flags, AccessFlags) \
- nonstatic_field(Klass, _subklass, Klass*) \
+ nonstatic_field(Klass, _prototype_header, markOop) \
nonstatic_field(Klass, _next_sibling, Klass*) \
+ nonstatic_field(vtableEntry, _method, Method*) \
nonstatic_field(MethodData, _size, int) \
nonstatic_field(MethodData, _method, Method*) \
nonstatic_field(MethodData, _data_size, int) \
@@ -342,10 +343,15 @@
nonstatic_field(MethodData, _nof_decompiles, uint) \
nonstatic_field(MethodData, _nof_overflow_recompiles, uint) \
nonstatic_field(MethodData, _nof_overflow_traps, uint) \
+ nonstatic_field(MethodData, _trap_hist._array[0], u1) \
nonstatic_field(MethodData, _eflags, intx) \
nonstatic_field(MethodData, _arg_local, intx) \
nonstatic_field(MethodData, _arg_stack, intx) \
nonstatic_field(MethodData, _arg_returned, intx) \
+ nonstatic_field(DataLayout, _header._struct._tag, u1) \
+ nonstatic_field(DataLayout, _header._struct._flags, u1) \
+ nonstatic_field(DataLayout, _header._struct._bci, u2) \
+ nonstatic_field(DataLayout, _cells[0], intptr_t) \
nonstatic_field(MethodCounters, _interpreter_invocation_count, int) \
nonstatic_field(MethodCounters, _interpreter_throwout_count, u2) \
nonstatic_field(MethodCounters, _number_of_breakpoints, u2) \
@@ -357,6 +363,7 @@
nonstatic_field(Method, _access_flags, AccessFlags) \
nonstatic_field(Method, _vtable_index, int) \
nonstatic_field(Method, _method_size, u2) \
+ nonstatic_field(Method, _intrinsic_id, u1) \
nonproduct_nonstatic_field(Method, _compiled_invocation_count, int) \
volatile_nonstatic_field(Method, _code, nmethod*) \
nonstatic_field(Method, _i2i_entry, address) \
@@ -443,12 +450,19 @@
static_field(Universe, _bootstrapping, bool) \
static_field(Universe, _fully_initialized, bool) \
static_field(Universe, _verify_count, int) \
+ static_field(Universe, _non_oop_bits, intptr_t) \
static_field(Universe, _narrow_oop._base, address) \
static_field(Universe, _narrow_oop._shift, int) \
static_field(Universe, _narrow_oop._use_implicit_null_checks, bool) \
static_field(Universe, _narrow_klass._base, address) \
static_field(Universe, _narrow_klass._shift, int) \
\
+ /******/ \
+ /* os */ \
+ /******/ \
+ \
+ static_field(os, _polling_page, address) \
+ \
/**********************************************************************************/ \
/* Generation and Space hierarchies */ \
/**********************************************************************************/ \
@@ -456,6 +470,7 @@
unchecked_nonstatic_field(ageTable, sizes, sizeof(ageTable::sizes)) \
\
nonstatic_field(BarrierSet, _max_covered_regions, int) \
+ nonstatic_field(BarrierSet, _kind, BarrierSet::Name) \
nonstatic_field(BlockOffsetTable, _bottom, HeapWord*) \
nonstatic_field(BlockOffsetTable, _end, HeapWord*) \
\
@@ -495,6 +510,7 @@
nonstatic_field(CollectedHeap, _barrier_set, BarrierSet*) \
nonstatic_field(CollectedHeap, _defer_initial_card_mark, bool) \
nonstatic_field(CollectedHeap, _is_gc_active, bool) \
+ nonstatic_field(CollectedHeap, _total_collections, unsigned int) \
nonstatic_field(CompactibleSpace, _compaction_top, HeapWord*) \
nonstatic_field(CompactibleSpace, _first_dead, HeapWord*) \
nonstatic_field(CompactibleSpace, _end_of_live, HeapWord*) \
@@ -505,7 +521,7 @@
nonstatic_field(ContiguousSpace, _saved_mark_word, HeapWord*) \
\
nonstatic_field(DefNewGeneration, _next_gen, Generation*) \
- nonstatic_field(DefNewGeneration, _tenuring_threshold, uint) \
+ nonstatic_field(DefNewGeneration, _tenuring_threshold, uint) \
nonstatic_field(DefNewGeneration, _age_table, ageTable) \
nonstatic_field(DefNewGeneration, _eden_space, EdenSpace*) \
nonstatic_field(DefNewGeneration, _from_space, ContiguousSpace*) \
@@ -552,6 +568,11 @@
nonstatic_field(ThreadLocalAllocBuffer, _desired_size, size_t) \
nonstatic_field(ThreadLocalAllocBuffer, _refill_waste_limit, size_t) \
static_field(ThreadLocalAllocBuffer, _target_refills, unsigned) \
+ nonstatic_field(ThreadLocalAllocBuffer, _number_of_refills, unsigned) \
+ nonstatic_field(ThreadLocalAllocBuffer, _fast_refill_waste, unsigned) \
+ nonstatic_field(ThreadLocalAllocBuffer, _slow_refill_waste, unsigned) \
+ nonstatic_field(ThreadLocalAllocBuffer, _gc_waste, unsigned) \
+ nonstatic_field(ThreadLocalAllocBuffer, _slow_allocations, unsigned) \
nonstatic_field(VirtualSpace, _low_boundary, char*) \
nonstatic_field(VirtualSpace, _high_boundary, char*) \
nonstatic_field(VirtualSpace, _low, char*) \
@@ -713,6 +734,13 @@
\
static_field(ClassLoaderDataGraph, _head, ClassLoaderData*) \
\
+ /**********/ \
+ /* Arrays */ \
+ /**********/ \
+ \
+ nonstatic_field(Array<Klass*>, _length, int) \
+ nonstatic_field(Array<Klass*>, _data[0], Klass*) \
+ \
/*******************/ \
/* GrowableArrays */ \
/*******************/ \
@@ -720,7 +748,7 @@
nonstatic_field(GenericGrowableArray, _len, int) \
nonstatic_field(GenericGrowableArray, _max, int) \
nonstatic_field(GenericGrowableArray, _arena, Arena*) \
- nonstatic_field(GrowableArray<int>, _data, int*) \
+ nonstatic_field(GrowableArray<int>, _data, int*) \
\
/********************************/ \
/* CodeCache (NOTE: incomplete) */ \
@@ -763,7 +791,20 @@
/* StubRoutines (NOTE: incomplete) */ \
/***********************************/ \
\
+ static_field(StubRoutines, _verify_oop_count, jint) \
static_field(StubRoutines, _call_stub_return_address, address) \
+ static_field(StubRoutines, _aescrypt_encryptBlock, address) \
+ static_field(StubRoutines, _aescrypt_decryptBlock, address) \
+ static_field(StubRoutines, _cipherBlockChaining_encryptAESCrypt, address) \
+ static_field(StubRoutines, _cipherBlockChaining_decryptAESCrypt, address) \
+ static_field(StubRoutines, _updateBytesCRC32, address) \
+ static_field(StubRoutines, _crc_table_adr, address) \
+ \
+ /*****************/ \
+ /* SharedRuntime */ \
+ /*****************/ \
+ \
+ static_field(SharedRuntime, _ic_miss_blob, RuntimeStub*) \
\
/***************************************/ \
/* PcDesc and other compiled code info */ \
@@ -853,6 +894,7 @@
volatile_nonstatic_field(Thread, _suspend_flags, uint32_t) \
nonstatic_field(Thread, _active_handles, JNIHandleBlock*) \
nonstatic_field(Thread, _tlab, ThreadLocalAllocBuffer) \
+ nonstatic_field(Thread, _allocated_bytes, jlong) \
nonstatic_field(Thread, _current_pending_monitor, ObjectMonitor*) \
nonstatic_field(Thread, _current_pending_monitor_is_from_java, bool) \
nonstatic_field(Thread, _current_waiting_monitor, ObjectMonitor*) \
@@ -866,6 +908,7 @@
nonstatic_field(JavaThread, _pending_async_exception, oop) \
volatile_nonstatic_field(JavaThread, _exception_oop, oop) \
volatile_nonstatic_field(JavaThread, _exception_pc, address) \
+ volatile_nonstatic_field(JavaThread, _is_method_handle_return, int) \
nonstatic_field(JavaThread, _is_compiling, bool) \
nonstatic_field(JavaThread, _special_runtime_exit_condition, JavaThread::AsyncRequests) \
nonstatic_field(JavaThread, _saved_exception_pc, address) \
@@ -875,6 +918,8 @@
nonstatic_field(JavaThread, _stack_size, size_t) \
nonstatic_field(JavaThread, _vframe_array_head, vframeArray*) \
nonstatic_field(JavaThread, _vframe_array_last, vframeArray*) \
+ nonstatic_field(JavaThread, _satb_mark_queue, ObjPtrQueue) \
+ nonstatic_field(JavaThread, _dirty_card_queue, DirtyCardQueue) \
nonstatic_field(Thread, _resource_area, ResourceArea*) \
nonstatic_field(CompilerThread, _env, ciEnv*) \
\
@@ -1187,7 +1232,7 @@
unchecked_nonstatic_field(Array<int>, _data, sizeof(int)) \
unchecked_nonstatic_field(Array<u1>, _data, sizeof(u1)) \
unchecked_nonstatic_field(Array<u2>, _data, sizeof(u2)) \
- unchecked_nonstatic_field(Array<Method*>, _data, sizeof(Method*)) \
+ unchecked_nonstatic_field(Array<Method*>, _data, sizeof(Method*)) \
unchecked_nonstatic_field(Array<Klass*>, _data, sizeof(Klass*)) \
\
/*********************************/ \
@@ -1203,7 +1248,7 @@
/* Miscellaneous fields */ \
/************************/ \
\
- nonstatic_field(CompileTask, _method, Method*) \
+ nonstatic_field(CompileTask, _method, Method*) \
nonstatic_field(CompileTask, _osr_bci, int) \
nonstatic_field(CompileTask, _comp_level, int) \
nonstatic_field(CompileTask, _compile_id, uint) \
@@ -1217,7 +1262,11 @@
\
nonstatic_field(vframeArrayElement, _frame, frame) \
nonstatic_field(vframeArrayElement, _bci, int) \
- nonstatic_field(vframeArrayElement, _method, Method*) \
+ nonstatic_field(vframeArrayElement, _method, Method*) \
+ \
+ nonstatic_field(PtrQueue, _active, bool) \
+ nonstatic_field(PtrQueue, _buf, void**) \
+ nonstatic_field(PtrQueue, _index, size_t) \
\
nonstatic_field(AccessFlags, _flags, jint) \
nonstatic_field(elapsedTimer, _counter, jlong) \
@@ -1363,7 +1412,7 @@
/* MetadataOopDesc hierarchy (NOTE: some missing) */ \
/**************************************************/ \
\
- declare_toplevel_type(CompiledICHolder) \
+ declare_toplevel_type(CompiledICHolder) \
declare_toplevel_type(MetaspaceObj) \
declare_type(Metadata, MetaspaceObj) \
declare_type(Klass, Metadata) \
@@ -1374,17 +1423,20 @@
declare_type(InstanceClassLoaderKlass, InstanceKlass) \
declare_type(InstanceMirrorKlass, InstanceKlass) \
declare_type(InstanceRefKlass, InstanceKlass) \
- declare_type(ConstantPool, Metadata) \
- declare_type(ConstantPoolCache, MetaspaceObj) \
- declare_type(MethodData, Metadata) \
- declare_type(Method, Metadata) \
- declare_type(MethodCounters, MetaspaceObj) \
- declare_type(ConstMethod, MetaspaceObj) \
+ declare_type(ConstantPool, Metadata) \
+ declare_type(ConstantPoolCache, MetaspaceObj) \
+ declare_type(MethodData, Metadata) \
+ declare_type(Method, Metadata) \
+ declare_type(MethodCounters, MetaspaceObj) \
+ declare_type(ConstMethod, MetaspaceObj) \
+ \
+ declare_toplevel_type(vtableEntry) \
\
declare_toplevel_type(Symbol) \
declare_toplevel_type(Symbol*) \
declare_toplevel_type(volatile Metadata*) \
\
+ declare_toplevel_type(DataLayout) \
declare_toplevel_type(nmethodBucket) \
\
/********/ \
@@ -1432,6 +1484,7 @@
declare_type(ModRefBarrierSet, BarrierSet) \
declare_type(CardTableModRefBS, ModRefBarrierSet) \
declare_type(CardTableModRefBSForCTRS, CardTableModRefBS) \
+ declare_toplevel_type(BarrierSet::Name) \
declare_toplevel_type(GenRemSet) \
declare_type(CardTableRS, GenRemSet) \
declare_toplevel_type(BlockOffsetSharedArray) \
@@ -1450,6 +1503,8 @@
declare_toplevel_type(ThreadLocalAllocBuffer) \
declare_toplevel_type(VirtualSpace) \
declare_toplevel_type(WaterMark) \
+ declare_toplevel_type(ObjPtrQueue) \
+ declare_toplevel_type(DirtyCardQueue) \
\
/* Pointers to Garbage Collection types */ \
\
@@ -2068,6 +2123,7 @@
declare_toplevel_type(StubQueue*) \
declare_toplevel_type(Thread*) \
declare_toplevel_type(Universe) \
+ declare_toplevel_type(os) \
declare_toplevel_type(vframeArray) \
declare_toplevel_type(vframeArrayElement) \
declare_toplevel_type(Annotations*) \
@@ -2076,6 +2132,8 @@
/* Miscellaneous types */ \
/***************/ \
\
+ declare_toplevel_type(PtrQueue) \
+ \
/* freelist */ \
declare_toplevel_type(FreeChunk*) \
declare_toplevel_type(Metablock*) \
@@ -2106,6 +2164,7 @@
/* Useful globals */ \
/******************/ \
\
+ declare_preprocessor_constant("ASSERT", DEBUG_ONLY(1) NOT_DEBUG(0)) \
\
/**************/ \
/* Stack bias */ \
@@ -2122,6 +2181,8 @@
declare_constant(BytesPerWord) \
declare_constant(BytesPerLong) \
\
+ declare_constant(LogKlassAlignmentInBytes) \
+ \
/********************************************/ \
/* Generation and Space Hierarchy Constants */ \
/********************************************/ \
@@ -2130,6 +2191,9 @@
\
declare_constant(BarrierSet::ModRef) \
declare_constant(BarrierSet::CardTableModRef) \
+ declare_constant(BarrierSet::CardTableExtension) \
+ declare_constant(BarrierSet::G1SATBCT) \
+ declare_constant(BarrierSet::G1SATBCTLogging) \
declare_constant(BarrierSet::Other) \
\
declare_constant(BlockOffsetSharedArray::LogN) \
@@ -2248,8 +2312,11 @@
declare_constant(Klass::_primary_super_limit) \
declare_constant(Klass::_lh_instance_slow_path_bit) \
declare_constant(Klass::_lh_log2_element_size_shift) \
+ declare_constant(Klass::_lh_log2_element_size_mask) \
declare_constant(Klass::_lh_element_type_shift) \
+ declare_constant(Klass::_lh_element_type_mask) \
declare_constant(Klass::_lh_header_size_shift) \
+ declare_constant(Klass::_lh_header_size_mask) \
declare_constant(Klass::_lh_array_tag_shift) \
declare_constant(Klass::_lh_array_tag_type_value) \
declare_constant(Klass::_lh_array_tag_obj_value) \
@@ -2268,6 +2335,12 @@
declare_constant(ConstMethod::_has_default_annotations) \
declare_constant(ConstMethod::_has_type_annotations) \
\
+ /**************/ \
+ /* DataLayout */ \
+ /**************/ \
+ \
+ declare_constant(DataLayout::cell_size) \
+ \
/*************************************/ \
/* InstanceKlass enum */ \
/*************************************/ \
@@ -2402,6 +2475,13 @@
declare_constant(Deoptimization::Reason_LIMIT) \
declare_constant(Deoptimization::Reason_RECORDED_LIMIT) \
\
+ declare_constant(Deoptimization::Action_none) \
+ declare_constant(Deoptimization::Action_maybe_recompile) \
+ declare_constant(Deoptimization::Action_reinterpret) \
+ declare_constant(Deoptimization::Action_make_not_entrant) \
+ declare_constant(Deoptimization::Action_make_not_compilable) \
+ declare_constant(Deoptimization::Action_LIMIT) \
+ \
/*********************/ \
/* Matcher (C2 only) */ \
/*********************/ \
@@ -2468,6 +2548,16 @@
declare_constant(vmSymbols::FIRST_SID) \
declare_constant(vmSymbols::SID_LIMIT) \
\
+ /****************/ \
+ /* vmIntrinsics */ \
+ /****************/ \
+ \
+ declare_constant(vmIntrinsics::_invokeBasic) \
+ declare_constant(vmIntrinsics::_linkToVirtual) \
+ declare_constant(vmIntrinsics::_linkToStatic) \
+ declare_constant(vmIntrinsics::_linkToSpecial) \
+ declare_constant(vmIntrinsics::_linkToInterface) \
+ \
/********************************/ \
/* Calling convention constants */ \
/********************************/ \
@@ -2515,6 +2605,8 @@
declare_constant(markOopDesc::biased_lock_bit_in_place) \
declare_constant(markOopDesc::age_mask) \
declare_constant(markOopDesc::age_mask_in_place) \
+ declare_constant(markOopDesc::epoch_mask) \
+ declare_constant(markOopDesc::epoch_mask_in_place) \
declare_constant(markOopDesc::hash_mask) \
declare_constant(markOopDesc::hash_mask_in_place) \
declare_constant(markOopDesc::biased_lock_alignment) \
--- a/hotspot/src/share/vm/services/gcNotifier.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/services/gcNotifier.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -209,7 +209,7 @@
GCNotificationRequest *request = getRequest();
if (request != NULL) {
NotificationMark nm(request);
- Handle objGcInfo = createGcInfo(request->gcManager, request->gcStatInfo, THREAD);
+ Handle objGcInfo = createGcInfo(request->gcManager, request->gcStatInfo, CHECK);
Handle objName = java_lang_String::create_from_str(request->gcManager->name(), CHECK);
Handle objAction = java_lang_String::create_from_str(request->gcAction, CHECK);
--- a/hotspot/src/share/vm/services/memPtr.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/services/memPtr.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -34,9 +34,9 @@
jint seq = Atomic::add(1, &_seq_number);
if (seq < 0) {
MemTracker::shutdown(MemTracker::NMT_sequence_overflow);
+ } else {
+ NOT_PRODUCT(_max_seq_number = (seq > _max_seq_number) ? seq : _max_seq_number;)
}
- assert(seq > 0, "counter overflow");
- NOT_PRODUCT(_max_seq_number = (seq > _max_seq_number) ? seq : _max_seq_number;)
return seq;
}
--- a/hotspot/src/share/vm/trace/traceMacros.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/trace/traceMacros.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -26,6 +26,7 @@
#define SHARE_VM_TRACE_TRACE_MACRO_HPP
#define EVENT_THREAD_EXIT(thread)
+#define EVENT_THREAD_DESTRUCT(thread)
#define TRACE_INIT_ID(k)
#define TRACE_DATA TraceThreadData
--- a/hotspot/src/share/vm/utilities/decoder.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/utilities/decoder.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -24,7 +24,6 @@
#include "precompiled.hpp"
#include "prims/jvm.h"
-#include "runtime/mutexLocker.hpp"
#include "runtime/os.hpp"
#include "utilities/decoder.hpp"
#include "utilities/vmError.hpp"
@@ -80,6 +79,23 @@
return decoder;
}
+inline bool DecoderLocker::is_first_error_thread() {
+ return (os::current_thread_id() == VMError::get_first_error_tid());
+}
+
+DecoderLocker::DecoderLocker() :
+ MutexLockerEx(DecoderLocker::is_first_error_thread() ?
+ NULL : Decoder::shared_decoder_lock(), true) {
+ _decoder = is_first_error_thread() ?
+ Decoder::get_error_handler_instance() : Decoder::get_shared_instance();
+ assert(_decoder != NULL, "null decoder");
+}
+
+Mutex* Decoder::shared_decoder_lock() {
+ assert(_shared_decoder_lock != NULL, "Just check");
+ return _shared_decoder_lock;
+}
+
bool Decoder::decode(address addr, char* buf, int buflen, int* offset, const char* modulepath) {
assert(_shared_decoder_lock != NULL, "Just check");
bool error_handling_thread = os::current_thread_id() == VMError::first_error_tid;
--- a/hotspot/src/share/vm/utilities/decoder.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/utilities/decoder.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -28,6 +28,7 @@
#include "memory/allocation.hpp"
#include "runtime/mutex.hpp"
+#include "runtime/mutexLocker.hpp"
class AbstractDecoder : public CHeapObj<mtInternal> {
public:
@@ -124,6 +125,19 @@
protected:
static Mutex* _shared_decoder_lock;
+ static Mutex* shared_decoder_lock();
+
+ friend class DecoderLocker;
+};
+
+class DecoderLocker : public MutexLockerEx {
+ AbstractDecoder* _decoder;
+ inline bool is_first_error_thread();
+public:
+ DecoderLocker();
+ AbstractDecoder* decoder() {
+ return _decoder;
+ }
};
#endif // SHARE_VM_UTILITIES_DECODER_HPP
--- a/hotspot/src/share/vm/utilities/ostream.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/utilities/ostream.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -342,7 +342,7 @@
}
char* stringStream::as_string() {
- char* copy = NEW_RESOURCE_ARRAY(char, buffer_pos+1);
+ char* copy = NEW_RESOURCE_ARRAY(char, buffer_pos + 1);
strncpy(copy, buffer, buffer_pos);
copy[buffer_pos] = 0; // terminating null
return copy;
@@ -355,14 +355,190 @@
outputStream* gclog_or_tty;
extern Mutex* tty_lock;
+#define EXTRACHARLEN 32
+#define CURRENTAPPX ".current"
+#define FILENAMEBUFLEN 1024
+// convert YYYY-MM-DD HH:MM:SS to YYYY-MM-DD_HH-MM-SS
+char* get_datetime_string(char *buf, size_t len) {
+ os::local_time_string(buf, len);
+ int i = (int)strlen(buf);
+ while (i-- >= 0) {
+ if (buf[i] == ' ') buf[i] = '_';
+ else if (buf[i] == ':') buf[i] = '-';
+ }
+ return buf;
+}
+
+static const char* make_log_name_internal(const char* log_name, const char* force_directory,
+ int pid, const char* tms) {
+ const char* basename = log_name;
+ char file_sep = os::file_separator()[0];
+ const char* cp;
+ char pid_text[32];
+
+ for (cp = log_name; *cp != '\0'; cp++) {
+ if (*cp == '/' || *cp == file_sep) {
+ basename = cp + 1;
+ }
+ }
+ const char* nametail = log_name;
+ // Compute buffer length
+ size_t buffer_length;
+ if (force_directory != NULL) {
+ buffer_length = strlen(force_directory) + strlen(os::file_separator()) +
+ strlen(basename) + 1;
+ } else {
+ buffer_length = strlen(log_name) + 1;
+ }
+
+ // const char* star = strchr(basename, '*');
+ const char* pts = strstr(basename, "%p");
+ int pid_pos = (pts == NULL) ? -1 : (pts - nametail);
+
+ if (pid_pos >= 0) {
+ jio_snprintf(pid_text, sizeof(pid_text), "pid%u", pid);
+ buffer_length += strlen(pid_text);
+ }
+
+ pts = strstr(basename, "%t");
+ int tms_pos = (pts == NULL) ? -1 : (pts - nametail);
+ if (tms_pos >= 0) {
+ buffer_length += strlen(tms);
+ }
+
+ // Create big enough buffer.
+ char *buf = NEW_C_HEAP_ARRAY(char, buffer_length, mtInternal);
+
+ strcpy(buf, "");
+ if (force_directory != NULL) {
+ strcat(buf, force_directory);
+ strcat(buf, os::file_separator());
+ nametail = basename; // completely skip directory prefix
+ }
+
+ // who is first, %p or %t?
+ int first = -1, second = -1;
+ const char *p1st = NULL;
+ const char *p2nd = NULL;
+
+ if (pid_pos >= 0 && tms_pos >= 0) {
+ // contains both %p and %t
+ if (pid_pos < tms_pos) {
+ // case foo%pbar%tmonkey.log
+ first = pid_pos;
+ p1st = pid_text;
+ second = tms_pos;
+ p2nd = tms;
+ } else {
+ // case foo%tbar%pmonkey.log
+ first = tms_pos;
+ p1st = tms;
+ second = pid_pos;
+ p2nd = pid_text;
+ }
+ } else if (pid_pos >= 0) {
+ // contains %p only
+ first = pid_pos;
+ p1st = pid_text;
+ } else if (tms_pos >= 0) {
+ // contains %t only
+ first = tms_pos;
+ p1st = tms;
+ }
+
+ int buf_pos = (int)strlen(buf);
+ const char* tail = nametail;
+
+ if (first >= 0) {
+ tail = nametail + first + 2;
+ strncpy(&buf[buf_pos], nametail, first);
+ strcpy(&buf[buf_pos + first], p1st);
+ buf_pos = (int)strlen(buf);
+ if (second >= 0) {
+ strncpy(&buf[buf_pos], tail, second - first - 2);
+ strcpy(&buf[buf_pos + second - first - 2], p2nd);
+ tail = nametail + second + 2;
+ }
+ }
+ strcat(buf, tail); // append rest of name, or all of name
+ return buf;
+}
+
+// log_name comes from -XX:LogFile=log_name or -Xloggc:log_name
+// in log_name, %p => pipd1234 and
+// %t => YYYY-MM-DD_HH-MM-SS
+static const char* make_log_name(const char* log_name, const char* force_directory) {
+ char timestr[32];
+ get_datetime_string(timestr, sizeof(timestr));
+ return make_log_name_internal(log_name, force_directory, os::current_process_id(),
+ timestr);
+}
+
+#ifndef PRODUCT
+void test_loggc_filename() {
+ int pid;
+ char tms[32];
+ char i_result[FILENAMEBUFLEN];
+ const char* o_result;
+ get_datetime_string(tms, sizeof(tms));
+ pid = os::current_process_id();
+
+ // test.log
+ jio_snprintf(i_result, sizeof(char)*FILENAMEBUFLEN, "test.log", tms);
+ o_result = make_log_name_internal("test.log", NULL, pid, tms);
+ assert(strcmp(i_result, o_result) == 0, "failed on testing make_log_name(\"test.log\", NULL)");
+ FREE_C_HEAP_ARRAY(char, o_result, mtInternal);
+
+ // test-%t-%p.log
+ jio_snprintf(i_result, sizeof(char)*FILENAMEBUFLEN, "test-%s-pid%u.log", tms, pid);
+ o_result = make_log_name_internal("test-%t-%p.log", NULL, pid, tms);
+ assert(strcmp(i_result, o_result) == 0, "failed on testing make_log_name(\"test-%%t-%%p.log\", NULL)");
+ FREE_C_HEAP_ARRAY(char, o_result, mtInternal);
+
+ // test-%t%p.log
+ jio_snprintf(i_result, sizeof(char)*FILENAMEBUFLEN, "test-%spid%u.log", tms, pid);
+ o_result = make_log_name_internal("test-%t%p.log", NULL, pid, tms);
+ assert(strcmp(i_result, o_result) == 0, "failed on testing make_log_name(\"test-%%t%%p.log\", NULL)");
+ FREE_C_HEAP_ARRAY(char, o_result, mtInternal);
+
+ // %p%t.log
+ jio_snprintf(i_result, sizeof(char)*FILENAMEBUFLEN, "pid%u%s.log", pid, tms);
+ o_result = make_log_name_internal("%p%t.log", NULL, pid, tms);
+ assert(strcmp(i_result, o_result) == 0, "failed on testing make_log_name(\"%%p%%t.log\", NULL)");
+ FREE_C_HEAP_ARRAY(char, o_result, mtInternal);
+
+ // %p-test.log
+ jio_snprintf(i_result, sizeof(char)*FILENAMEBUFLEN, "pid%u-test.log", pid);
+ o_result = make_log_name_internal("%p-test.log", NULL, pid, tms);
+ assert(strcmp(i_result, o_result) == 0, "failed on testing make_log_name(\"%%p-test.log\", NULL)");
+ FREE_C_HEAP_ARRAY(char, o_result, mtInternal);
+
+ // %t.log
+ jio_snprintf(i_result, sizeof(char)*FILENAMEBUFLEN, "%s.log", tms);
+ o_result = make_log_name_internal("%t.log", NULL, pid, tms);
+ assert(strcmp(i_result, o_result) == 0, "failed on testing make_log_name(\"%%t.log\", NULL)");
+ FREE_C_HEAP_ARRAY(char, o_result, mtInternal);
+}
+#endif // PRODUCT
+
fileStream::fileStream(const char* file_name) {
_file = fopen(file_name, "w");
- _need_close = true;
+ if (_file != NULL) {
+ _need_close = true;
+ } else {
+ warning("Cannot open file %s due to %s\n", file_name, strerror(errno));
+ _need_close = false;
+ }
}
fileStream::fileStream(const char* file_name, const char* opentype) {
_file = fopen(file_name, opentype);
- _need_close = true;
+ if (_file != NULL) {
+ _need_close = true;
+ } else {
+ warning("Cannot open file %s due to %s\n", file_name, strerror(errno));
+ _need_close = false;
+ }
}
void fileStream::write(const char* s, size_t len) {
@@ -423,34 +599,51 @@
update_position(s, len);
}
-rotatingFileStream::~rotatingFileStream() {
+// dump vm version, os version, platform info, build id,
+// memory usage and command line flags into header
+void gcLogFileStream::dump_loggc_header() {
+ if (is_open()) {
+ print_cr(Abstract_VM_Version::internal_vm_info_string());
+ os::print_memory_info(this);
+ print("CommandLine flags: ");
+ CommandLineFlags::printSetFlags(this);
+ }
+}
+
+gcLogFileStream::~gcLogFileStream() {
if (_file != NULL) {
if (_need_close) fclose(_file);
- _file = NULL;
+ _file = NULL;
+ }
+ if (_file_name != NULL) {
FREE_C_HEAP_ARRAY(char, _file_name, mtInternal);
_file_name = NULL;
}
}
-rotatingFileStream::rotatingFileStream(const char* file_name) {
+gcLogFileStream::gcLogFileStream(const char* file_name) {
_cur_file_num = 0;
_bytes_written = 0L;
- _file_name = NEW_C_HEAP_ARRAY(char, strlen(file_name)+10, mtInternal);
- jio_snprintf(_file_name, strlen(file_name)+10, "%s.%d", file_name, _cur_file_num);
- _file = fopen(_file_name, "w");
- _need_close = true;
+ _file_name = make_log_name(file_name, NULL);
+
+ // gc log file rotation
+ if (UseGCLogFileRotation && NumberOfGCLogFiles > 1) {
+ char tempbuf[FILENAMEBUFLEN];
+ jio_snprintf(tempbuf, sizeof(tempbuf), "%s.%d" CURRENTAPPX, _file_name, _cur_file_num);
+ _file = fopen(tempbuf, "w");
+ } else {
+ _file = fopen(_file_name, "w");
+ }
+ if (_file != NULL) {
+ _need_close = true;
+ dump_loggc_header();
+ } else {
+ warning("Cannot open file %s due to %s\n", _file_name, strerror(errno));
+ _need_close = false;
+ }
}
-rotatingFileStream::rotatingFileStream(const char* file_name, const char* opentype) {
- _cur_file_num = 0;
- _bytes_written = 0L;
- _file_name = NEW_C_HEAP_ARRAY(char, strlen(file_name)+10, mtInternal);
- jio_snprintf(_file_name, strlen(file_name)+10, "%s.%d", file_name, _cur_file_num);
- _file = fopen(_file_name, opentype);
- _need_close = true;
-}
-
-void rotatingFileStream::write(const char* s, size_t len) {
+void gcLogFileStream::write(const char* s, size_t len) {
if (_file != NULL) {
size_t count = fwrite(s, 1, len, _file);
_bytes_written += count;
@@ -466,7 +659,12 @@
// write to gc log file at safepoint. If in future, changes made for mutator threads or
// concurrent GC threads to run parallel with VMThread at safepoint, write and rotate_log
// must be synchronized.
-void rotatingFileStream::rotate_log() {
+void gcLogFileStream::rotate_log() {
+ char time_msg[FILENAMEBUFLEN];
+ char time_str[EXTRACHARLEN];
+ char current_file_name[FILENAMEBUFLEN];
+ char renamed_file_name[FILENAMEBUFLEN];
+
if (_bytes_written < (jlong)GCLogFileSize) {
return;
}
@@ -481,27 +679,89 @@
// rotate in same file
rewind();
_bytes_written = 0L;
+ jio_snprintf(time_msg, sizeof(time_msg), "File %s rotated at %s\n",
+ _file_name, os::local_time_string((char *)time_str, sizeof(time_str)));
+ write(time_msg, strlen(time_msg));
+ dump_loggc_header();
return;
}
- // rotate file in names file.0, file.1, file.2, ..., file.<MaxGCLogFileNumbers-1>
- // close current file, rotate to next file
+#if defined(_WINDOWS)
+#ifndef F_OK
+#define F_OK 0
+#endif
+#endif // _WINDOWS
+
+ // rotate file in names extended_filename.0, extended_filename.1, ...,
+ // extended_filename.<NumberOfGCLogFiles - 1>. Current rotation file name will
+ // have a form of extended_filename.<i>.current where i is the current rotation
+ // file number. After it reaches max file size, the file will be saved and renamed
+ // with .current removed from its tail.
+ size_t filename_len = strlen(_file_name);
if (_file != NULL) {
- _cur_file_num ++;
- if (_cur_file_num >= NumberOfGCLogFiles) _cur_file_num = 0;
- jio_snprintf(_file_name, strlen(Arguments::gc_log_filename()) + 10, "%s.%d",
- Arguments::gc_log_filename(), _cur_file_num);
+ jio_snprintf(renamed_file_name, filename_len + EXTRACHARLEN, "%s.%d",
+ _file_name, _cur_file_num);
+ jio_snprintf(current_file_name, filename_len + EXTRACHARLEN, "%s.%d" CURRENTAPPX,
+ _file_name, _cur_file_num);
+ jio_snprintf(time_msg, sizeof(time_msg), "%s GC log file has reached the"
+ " maximum size. Saved as %s\n",
+ os::local_time_string((char *)time_str, sizeof(time_str)),
+ renamed_file_name);
+ write(time_msg, strlen(time_msg));
+
fclose(_file);
_file = NULL;
+
+ bool can_rename = true;
+ if (access(current_file_name, F_OK) != 0) {
+ // current file does not exist?
+ warning("No source file exists, cannot rename\n");
+ can_rename = false;
+ }
+ if (can_rename) {
+ if (access(renamed_file_name, F_OK) == 0) {
+ if (remove(renamed_file_name) != 0) {
+ warning("Could not delete existing file %s\n", renamed_file_name);
+ can_rename = false;
+ }
+ } else {
+ // file does not exist, ok to rename
+ }
+ }
+ if (can_rename && rename(current_file_name, renamed_file_name) != 0) {
+ warning("Could not rename %s to %s\n", _file_name, renamed_file_name);
+ }
}
- _file = fopen(_file_name, "w");
+
+ _cur_file_num++;
+ if (_cur_file_num > NumberOfGCLogFiles - 1) _cur_file_num = 0;
+ jio_snprintf(current_file_name, filename_len + EXTRACHARLEN, "%s.%d" CURRENTAPPX,
+ _file_name, _cur_file_num);
+ _file = fopen(current_file_name, "w");
+
if (_file != NULL) {
_bytes_written = 0L;
_need_close = true;
+ // reuse current_file_name for time_msg
+ jio_snprintf(current_file_name, filename_len + EXTRACHARLEN,
+ "%s.%d", _file_name, _cur_file_num);
+ jio_snprintf(time_msg, sizeof(time_msg), "%s GC log file created %s\n",
+ os::local_time_string((char *)time_str, sizeof(time_str)),
+ current_file_name);
+ write(time_msg, strlen(time_msg));
+ dump_loggc_header();
+ // remove the existing file
+ if (access(current_file_name, F_OK) == 0) {
+ if (remove(current_file_name) != 0) {
+ warning("Could not delete existing file %s\n", current_file_name);
+ }
+ }
} else {
- tty->print_cr("failed to open rotation log file %s due to %s\n",
+ warning("failed to open rotation log file %s due to %s\n"
+ "Turned off GC log file rotation\n",
_file_name, strerror(errno));
_need_close = false;
+ FLAG_SET_DEFAULT(UseGCLogFileRotation, false);
}
}
@@ -530,69 +790,9 @@
return _log_file != NULL;
}
-static const char* make_log_name(const char* log_name, const char* force_directory) {
- const char* basename = log_name;
- char file_sep = os::file_separator()[0];
- const char* cp;
- for (cp = log_name; *cp != '\0'; cp++) {
- if (*cp == '/' || *cp == file_sep) {
- basename = cp+1;
- }
- }
- const char* nametail = log_name;
-
- // Compute buffer length
- size_t buffer_length;
- if (force_directory != NULL) {
- buffer_length = strlen(force_directory) + strlen(os::file_separator()) +
- strlen(basename) + 1;
- } else {
- buffer_length = strlen(log_name) + 1;
- }
-
- const char* star = strchr(basename, '*');
- int star_pos = (star == NULL) ? -1 : (star - nametail);
- int skip = 1;
- if (star == NULL) {
- // Try %p
- star = strstr(basename, "%p");
- if (star != NULL) {
- skip = 2;
- }
- }
- star_pos = (star == NULL) ? -1 : (star - nametail);
-
- char pid[32];
- if (star_pos >= 0) {
- jio_snprintf(pid, sizeof(pid), "%u", os::current_process_id());
- buffer_length += strlen(pid);
- }
-
- // Create big enough buffer.
- char *buf = NEW_C_HEAP_ARRAY(char, buffer_length, mtInternal);
-
- strcpy(buf, "");
- if (force_directory != NULL) {
- strcat(buf, force_directory);
- strcat(buf, os::file_separator());
- nametail = basename; // completely skip directory prefix
- }
-
- if (star_pos >= 0) {
- // convert foo*bar.log or foo%pbar.log to foo123bar.log
- int buf_pos = (int) strlen(buf);
- strncpy(&buf[buf_pos], nametail, star_pos);
- strcpy(&buf[buf_pos + star_pos], pid);
- nametail += star_pos + skip; // skip prefix and pid format
- }
-
- strcat(buf, nametail); // append rest of name, or all of name
- return buf;
-}
-
void defaultStream::init_log() {
// %%% Need a MutexLocker?
- const char* log_name = LogFile != NULL ? LogFile : "hotspot.log";
+ const char* log_name = LogFile != NULL ? LogFile : "hotspot_pid%p.log";
const char* try_name = make_log_name(log_name, NULL);
fileStream* file = new(ResourceObj::C_HEAP, mtInternal) fileStream(try_name);
if (!file->is_open()) {
@@ -603,14 +803,15 @@
// Note: This feature is for maintainer use only. No need for L10N.
jio_print(warnbuf);
FREE_C_HEAP_ARRAY(char, try_name, mtInternal);
- try_name = make_log_name("hs_pid%p.log", os::get_temp_directory());
+ try_name = make_log_name(log_name, os::get_temp_directory());
jio_snprintf(warnbuf, sizeof(warnbuf),
"Warning: Forcing option -XX:LogFile=%s\n", try_name);
jio_print(warnbuf);
delete file;
file = new(ResourceObj::C_HEAP, mtInternal) fileStream(try_name);
- FREE_C_HEAP_ARRAY(char, try_name, mtInternal);
}
+ FREE_C_HEAP_ARRAY(char, try_name, mtInternal);
+
if (file->is_open()) {
_log_file = file;
xmlStream* xs = new(ResourceObj::C_HEAP, mtInternal) xmlStream(file);
@@ -877,11 +1078,8 @@
gclog_or_tty = tty; // default to tty
if (Arguments::gc_log_filename() != NULL) {
- fileStream * gclog = UseGCLogFileRotation ?
- new(ResourceObj::C_HEAP, mtInternal)
- rotatingFileStream(Arguments::gc_log_filename()) :
- new(ResourceObj::C_HEAP, mtInternal)
- fileStream(Arguments::gc_log_filename());
+ fileStream * gclog = new(ResourceObj::C_HEAP, mtInternal)
+ gcLogFileStream(Arguments::gc_log_filename());
if (gclog->is_open()) {
// now we update the time stamp of the GC log to be synced up
// with tty.
--- a/hotspot/src/share/vm/utilities/ostream.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/utilities/ostream.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -231,20 +231,24 @@
void flush() {};
};
-class rotatingFileStream : public fileStream {
+class gcLogFileStream : public fileStream {
protected:
- char* _file_name;
+ const char* _file_name;
jlong _bytes_written;
- uintx _cur_file_num; // current logfile rotation number, from 0 to MaxGCLogFileNumbers-1
+ uintx _cur_file_num; // current logfile rotation number, from 0 to NumberOfGCLogFiles-1
public:
- rotatingFileStream(const char* file_name);
- rotatingFileStream(const char* file_name, const char* opentype);
- rotatingFileStream(FILE* file) : fileStream(file) {}
- ~rotatingFileStream();
+ gcLogFileStream(const char* file_name);
+ ~gcLogFileStream();
virtual void write(const char* c, size_t len);
virtual void rotate_log();
+ void dump_loggc_header();
};
+#ifndef PRODUCT
+// unit test for checking -Xloggc:<filename> parsing result
+void test_loggc_filename();
+#endif
+
void ostream_init();
void ostream_init_log();
void ostream_exit();
--- a/hotspot/src/share/vm/utilities/vmError.cpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/utilities/vmError.cpp Tue Sep 24 10:14:02 2013 +0200
@@ -574,6 +574,10 @@
STEP(120, "(printing native stack)" )
if (_verbose) {
+ if (os::platform_print_native_stack(st, _context, buf, sizeof(buf))) {
+ // We have printed the native stack in platform-specific code
+ // Windows/x64 needs special handling.
+ } else {
frame fr = _context ? os::fetch_frame_from_context(_context)
: os::current_frame();
@@ -604,6 +608,7 @@
st->cr();
}
}
+ }
STEP(130, "(printing Java stack)" )
--- a/hotspot/src/share/vm/utilities/vmError.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/utilities/vmError.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -136,6 +136,10 @@
// check to see if fatal error reporting is in progress
static bool fatal_error_in_progress() { return first_error != NULL; }
+
+ static jlong get_first_error_tid() {
+ return first_error_tid;
+ }
};
#endif // SHARE_VM_UTILITIES_VMERROR_HPP
--- a/hotspot/src/share/vm/utilities/yieldingWorkgroup.hpp Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/src/share/vm/utilities/yieldingWorkgroup.hpp Tue Sep 24 10:14:02 2013 +0200
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -26,10 +26,7 @@
#define SHARE_VM_UTILITIES_YIELDINGWORKGROUP_HPP
#include "utilities/macros.hpp"
-#if INCLUDE_ALL_GCS
#include "utilities/workgroup.hpp"
-#endif // INCLUDE_ALL_GCS
-
// Forward declarations
class YieldingFlexibleWorkGang;
--- a/hotspot/test/TEST.groups Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/test/TEST.groups Tue Sep 24 10:14:02 2013 +0200
@@ -84,6 +84,7 @@
runtime/NMT/ThreadedVirtualAllocTestType.java \
runtime/NMT/VirtualAllocTestType.java \
runtime/RedefineObject/TestRedefineObject.java \
+ runtime/XCheckJniJsig/XCheckJSig.java \
serviceability/attach/AttachWithStalePidFile.java
# JRE adds further tests to compact3
@@ -159,7 +160,18 @@
gc/g1/TestRegionAlignment.java \
gc/g1/TestShrinkToOneRegion.java \
gc/metaspace/G1AddMetaspaceDependency.java \
- runtime/6929067/Test6929067.sh
+ gc/startup_warnings/TestCMS.java \
+ gc/startup_warnings/TestCMSIncrementalMode.java \
+ gc/startup_warnings/TestCMSNoIncrementalMode.java \
+ gc/startup_warnings/TestDefaultMaxRAMFraction.java \
+ gc/startup_warnings/TestDefNewCMS.java \
+ gc/startup_warnings/TestIncGC.java \
+ gc/startup_warnings/TestParallelGC.java \
+ gc/startup_warnings/TestParallelScavengeSerialOld.java \
+ gc/startup_warnings/TestParNewCMS.java \
+ gc/startup_warnings/TestParNewSerialOld.java \
+ runtime/6929067/Test6929067.sh \
+ runtime/SharedArchiveFile/SharedArchiveFile.java
# Minimal VM on Compact 2 adds in some compact2 tests
#
--- a/hotspot/test/gc/TestVerifyDuringStartup.java Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/test/gc/TestVerifyDuringStartup.java Tue Sep 24 10:14:02 2013 +0200
@@ -48,7 +48,7 @@
"-XX:+VerifyDuringStartup",
"-version"});
- System.out.print("Testing:\n" + JDKToolFinder.getCurrentJDKTool("java"));
+ System.out.print("Testing:\n" + JDKToolFinder.getJDKTool("java"));
for (int i = 0; i < vmOpts.size(); i += 1) {
System.out.print(" " + vmOpts.get(i));
}
--- a/hotspot/test/runtime/6878713/Test6878713.sh Sat Sep 21 10:09:42 2013 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,137 +0,0 @@
-#!/bin/sh
-
-#
-# Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
-# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
-#
-# This code is free software; you can redistribute it and/or modify it
-# under the terms of the GNU General Public License version 2 only, as
-# published by the Free Software Foundation.
-#
-# This code is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-# version 2 for more details (a copy is included in the LICENSE file that
-# accompanied this code).
-#
-# You should have received a copy of the GNU General Public License version
-# 2 along with this work; if not, write to the Free Software Foundation,
-# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
-#
-# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
-# or visit www.oracle.com if you need additional information or have any
-# questions.
-#
-
-
-
-##
-## @test
-## @bug 6878713
-## @bug 7030610
-## @bug 7037122
-## @bug 7123945
-## @summary Verifier heap corruption, relating to backward jsrs
-## @run shell Test6878713.sh
-##
-## some tests require path to find test source dir
-if [ "${TESTSRC}" = "" ]
-then
- TESTSRC=${PWD}
- echo "TESTSRC not set. Using "${TESTSRC}" as default"
-fi
-echo "TESTSRC=${TESTSRC}"
-## Adding common setup Variables for running shell tests.
-. ${TESTSRC}/../../test_env.sh
-
-TARGET_CLASS=OOMCrashClass1960_2
-
-echo "INFO: extracting the target class."
-${COMPILEJAVA}${FS}bin${FS}jar xvf \
- ${TESTSRC}${FS}testcase.jar ${TARGET_CLASS}.class
-
-# remove any hs_err_pid that might exist here
-rm -f hs_err_pid*.log
-
-echo "INFO: checking for 32-bit versus 64-bit VM."
-${TESTJAVA}${FS}bin${FS}java ${TESTVMOPTS} -version 2>&1 \
- | grep "64-Bit [^ ][^ ]* VM" > /dev/null 2>&1
-status="$?"
-if [ "$status" = 0 ]; then
- echo "INFO: testing a 64-bit VM."
- is_64_bit=true
-else
- echo "INFO: testing a 32-bit VM."
-fi
-
-if [ "$is_64_bit" = true ]; then
- # limit is 768MB in 8-byte words (1024 * 1024 * 768 / 8) == 100663296
- MALLOC_MAX=100663296
-else
- # limit is 768MB in 4-byte words (1024 * 1024 * 768 / 4) == 201326592
- MALLOC_MAX=201326592
-fi
-echo "INFO: MALLOC_MAX=$MALLOC_MAX"
-
-echo "INFO: executing the target class."
-# -XX:+PrintCommandLineFlags for debugging purposes
-# -XX:+IgnoreUnrecognizedVMOptions so test will run on a VM without
-# the new -XX:MallocMaxTestWords option
-# -XX:+UnlockDiagnosticVMOptions so we can use -XX:MallocMaxTestWords
-# -XX:MallocMaxTestWords limits malloc to $MALLOC_MAX
-${TESTJAVA}${FS}bin${FS}java \
- -XX:+PrintCommandLineFlags \
- -XX:+IgnoreUnrecognizedVMOptions \
- -XX:+UnlockDiagnosticVMOptions \
- -XX:MallocMaxTestWords=$MALLOC_MAX \
- ${TESTVMOPTS} ${TARGET_CLASS} > test.out 2>&1
-
-echo "INFO: begin contents of test.out:"
-cat test.out
-echo "INFO: end contents of test.out."
-
-echo "INFO: checking for memory allocation error message."
-# We are looking for this specific memory allocation failure mesg so
-# we know we exercised the right allocation path with the test class:
-MESG1="Native memory allocation (malloc) failed to allocate 25696531[0-9][0-9] bytes"
-grep "$MESG1" test.out
-status="$?"
-if [ "$status" = 0 ]; then
- echo "INFO: found expected memory allocation error message."
-else
- echo "INFO: did not find expected memory allocation error message."
-
- # If we didn't find MESG1 above, then there are several scenarios:
- # 1) -XX:MallocMaxTestWords is not supported by the current VM and we
- # didn't fail TARGET_CLASS's memory allocation attempt; instead
- # we failed to find TARGET_CLASS's main() method. The TARGET_CLASS
- # is designed to provoke a memory allocation failure during class
- # loading; we actually don't care about running the class which is
- # why it doesn't have a main() method.
- # 2) we failed a memory allocation, but not the one we were looking
- # so it might be that TARGET_CLASS no longer tickles the same
- # memory allocation code path
- # 3) TARGET_CLASS reproduces the failure mode (SIGSEGV) fixed by
- # 6878713 because the test is running on a pre-fix VM.
- echo "INFO: checking for no main() method message."
- MESG2="Error: Main method not found in class"
- grep "$MESG2" test.out
- status="$?"
- if [ "$status" = 0 ]; then
- echo "INFO: found no main() method message."
- else
- echo "FAIL: did not find no main() method message."
- # status is non-zero for exit below
-
- if [ -s hs_err_pid*.log ]; then
- echo "INFO: begin contents of hs_err_pid file:"
- cat hs_err_pid*.log
- echo "INFO: end contents of hs_err_pid file."
- fi
- fi
-fi
-
-if [ "$status" = 0 ]; then
- echo "PASS: test found one of the expected messages."
-fi
-exit "$status"
Binary file hotspot/test/runtime/6878713/testcase.jar has changed
--- a/hotspot/test/runtime/7020373/Test7020373.sh Sat Sep 21 10:09:42 2013 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,43 +0,0 @@
-#!/bin/sh
-
-##
-## @test
-## @bug 7020373 7055247 7053586 7185550
-## @key cte_test
-## @summary JSR rewriting can overflow memory address size variables
-## @ignore Ignore it as 7053586 test uses lots of memory. See bug report for detail.
-## @run shell Test7020373.sh
-##
-
-if [ "${TESTSRC}" = "" ]
-then
- TESTSRC=${PWD}
- echo "TESTSRC not set. Using "${TESTSRC}" as default"
-fi
-echo "TESTSRC=${TESTSRC}"
-## Adding common setup Variables for running shell tests.
-. ${TESTSRC}/../../test_env.sh
-
-${COMPILEJAVA}${FS}bin${FS}jar xvf ${TESTSRC}${FS}testcase.jar
-
-${TESTJAVA}${FS}bin${FS}java ${TESTVMOPTS} OOMCrashClass4000_1 > test.out 2>&1
-
-cat test.out
-
-egrep "SIGSEGV|An unexpected error has been detected" test.out
-
-if [ $? = 0 ]
-then
- echo "Test Failed"
- exit 1
-else
- egrep "java.lang.LinkageError|java.lang.NoSuchMethodError|Main method not found in class OOMCrashClass4000_1|insufficient memory" test.out
- if [ $? = 0 ]
- then
- echo "Test Passed"
- exit 0
- else
- echo "Test Failed"
- exit 1
- fi
-fi
Binary file hotspot/test/runtime/7020373/testcase.jar has changed
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/runtime/ClassFile/JsrRewriting.java Tue Sep 24 10:14:02 2013 +0200
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+
+/*
+ * @test JsrRewriting
+ * @summary JSR (jump local subroutine)
+ * rewriting can overflow memory address size variables
+ * @bug 7020373
+ * @bug 7055247
+ * @bug 7053586
+ * @bug 7185550
+ * @bug 7149464
+ * @key cte_test
+ * @library /testlibrary
+ * @run main JsrRewriting
+ */
+
+import com.oracle.java.testlibrary.*;
+import java.io.File;
+
+public class JsrRewriting {
+
+ public static void main(String[] args) throws Exception {
+
+ // ======= Configure the test
+ String jarFile = System.getProperty("test.src") +
+ File.separator + "JsrRewritingTestCase.jar";
+ String className = "OOMCrashClass4000_1";
+
+ // limit is 768MB in native words
+ int mallocMaxTestWords = (1024 * 1024 * 768 / 4);
+ if (Platform.is64bit())
+ mallocMaxTestWords = (mallocMaxTestWords / 2);
+
+ // ======= extract the test class
+ ProcessBuilder pb = new ProcessBuilder(new String[] {
+ JDKToolFinder.getJDKTool("jar"),
+ "xvf", jarFile } );
+ OutputAnalyzer output = new OutputAnalyzer(pb.start());
+ output.shouldHaveExitValue(0);
+
+ // ======= execute the test
+ pb = ProcessTools.createJavaProcessBuilder(
+ "-cp", ".",
+ "-XX:+UnlockDiagnosticVMOptions",
+ "-XX:MallocMaxTestWords=" + mallocMaxTestWords,
+ className);
+
+ output = new OutputAnalyzer(pb.start());
+ String[] expectedMsgs = {
+ "java.lang.LinkageError",
+ "java.lang.NoSuchMethodError",
+ "Main method not found in class " + className,
+ "insufficient memory"
+ };
+
+ MultipleOrMatch(output, expectedMsgs);
+ }
+
+ private static void
+ MultipleOrMatch(OutputAnalyzer analyzer, String[] whatToMatch) {
+ String output = analyzer.getOutput();
+
+ for (String expected : whatToMatch)
+ if (output.contains(expected))
+ return;
+
+ String err =
+ " stdout: [" + analyzer.getOutput() + "];\n" +
+ " exitValue = " + analyzer.getExitValue() + "\n";
+ System.err.println(err);
+
+ StringBuilder msg = new StringBuilder("Output did not contain " +
+ "any of the following expected messages: \n");
+ for (String expected : whatToMatch)
+ msg.append(expected).append(System.lineSeparator());
+ throw new RuntimeException(msg.toString());
+ }
+}
+
Binary file hotspot/test/runtime/ClassFile/JsrRewritingTestCase.jar has changed
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/runtime/ClassFile/OomWhileParsingRepeatedJsr.java Tue Sep 24 10:14:02 2013 +0200
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+
+
+/*
+ * @test OomWhileParsingRepeatedJsr
+ * @summary Testing class file parser; specifically parsing
+ * a file with repeated JSR (jump local subroutine)
+ * bytecode command.
+ * @bug 6878713
+ * @bug 7030610
+ * @bug 7037122
+ * @bug 7123945
+ * @bug 8016029
+ * @library /testlibrary
+ * @run main OomWhileParsingRepeatedJsr
+ */
+
+import com.oracle.java.testlibrary.*;
+
+
+public class OomWhileParsingRepeatedJsr {
+
+ public static void main(String[] args) throws Exception {
+
+ // ======= Configure the test
+ String jarFile = System.getProperty("test.src") + "/testcase.jar";
+ String className = "OOMCrashClass1960_2";
+
+ // limit is 768MB in native words
+ int mallocMaxTestWords = (1024 * 1024 * 768 / 4);
+ if (Platform.is64bit())
+ mallocMaxTestWords = (mallocMaxTestWords / 2);
+
+ // ======= extract the test class
+ ProcessBuilder pb = new ProcessBuilder(new String[] {
+ JDKToolFinder.getJDKTool("jar"),
+ "xvf", jarFile } );
+ OutputAnalyzer output = new OutputAnalyzer(pb.start());
+ output.shouldHaveExitValue(0);
+
+ // ======= execute the test
+ pb = ProcessTools.createJavaProcessBuilder(
+ "-cp", ".",
+ "-XX:+UnlockDiagnosticVMOptions",
+ "-XX:MallocMaxTestWords=" + mallocMaxTestWords,
+ className );
+
+ output = new OutputAnalyzer(pb.start());
+ output.shouldContain("Cannot reserve enough memory");
+ }
+}
+
Binary file hotspot/test/runtime/ClassFile/testcase.jar has changed
--- a/hotspot/test/runtime/InitialThreadOverflow/testme.sh Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/test/runtime/InitialThreadOverflow/testme.sh Tue Sep 24 10:14:02 2013 +0200
@@ -43,9 +43,9 @@
exit 0
fi
-gcc_cmd=`which gcc`
-if [ "x$gcc_cmd" == "x" ]; then
- echo "WARNING: gcc not found. Cannot execute test." 2>&1
+gcc_cmd=`which g++`
+if [ "x$gcc_cmd" = "x" ]; then
+ echo "WARNING: g++ not found. Cannot execute test." 2>&1
exit 0;
fi
--- a/hotspot/test/testlibrary/com/oracle/java/testlibrary/JDKToolFinder.java Sat Sep 21 10:09:42 2013 +0200
+++ b/hotspot/test/testlibrary/com/oracle/java/testlibrary/JDKToolFinder.java Tue Sep 24 10:14:02 2013 +0200
@@ -23,7 +23,9 @@
package com.oracle.java.testlibrary;
-import java.io.File;
+import java.io.FileNotFoundException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
public final class JDKToolFinder {
@@ -32,38 +34,73 @@
/**
* Returns the full path to an executable in jdk/bin based on System
- * property {@code compile.jdk} (set by jtreg test suite)
+ * property {@code test.jdk} or {@code compile.jdk} (both are set by the jtreg test suite)
*
* @return Full path to an executable in jdk/bin
*/
public static String getJDKTool(String tool) {
- String binPath = System.getProperty("compile.jdk");
- if (binPath == null) {
- throw new RuntimeException("System property 'compile.jdk' not set. "
- + "This property is normally set by jtreg. "
- + "When running test separately, set this property using "
- + "'-Dcompile.jdk=/path/to/jdk'.");
+
+ // First try to find the executable in test.jdk
+ try {
+ return getTool(tool, "test.jdk");
+ } catch (FileNotFoundException e) {
+
}
- binPath += File.separatorChar + "bin" + File.separatorChar + tool;
- return binPath;
+ // Now see if it's available in compile.jdk
+ try {
+ return getTool(tool, "compile.jdk");
+ } catch (FileNotFoundException e) {
+ throw new RuntimeException("Failed to find " + tool +
+ ", looked in test.jdk (" + System.getProperty("test.jdk") +
+ ") and compile.jdk (" + System.getProperty("compile.jdk") + ")");
+ }
}
+
/**
- * Returns the full path to an executable in <current jdk>/bin based
- * on System property {@code test.jdk} (set by jtreg test suite)
+ * Returns the full path to an executable in jdk/bin based on System
+ * property {@code compile.jdk}
*
* @return Full path to an executable in jdk/bin
*/
- public static String getCurrentJDKTool(String tool) {
- String binPath = System.getProperty("test.jdk");
- if (binPath == null) {
- throw new RuntimeException("System property 'test.jdk' not set. "
- + "This property is normally set by jtreg. "
- + "When running test separately, set this property using "
- + "'-Dtest.jdk=/path/to/jdk'.");
+ public static String getCompileJDKTool(String tool) {
+ try {
+ return getTool(tool, "compile.jdk");
+ } catch (FileNotFoundException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ /**
+ * Returns the full path to an executable in jdk/bin based on System
+ * property {@code test.jdk}
+ *
+ * @return Full path to an executable in jdk/bin
+ */
+ public static String getTestJDKTool(String tool) {
+ try {
+ return getTool(tool, "test.jdk");
+ } catch (FileNotFoundException e) {
+ throw new RuntimeException(e);
}
- binPath += File.separatorChar + "bin" + File.separatorChar + tool;
+ }
+
+ private static String getTool(String tool, String property) throws FileNotFoundException {
+ String jdkPath = System.getProperty(property);
- return binPath;
+ if (jdkPath == null) {
+ throw new RuntimeException(
+ "System property '" + property + "' not set. This property is normally set by jtreg. "
+ + "When running test separately, set this property using '-D" + property + "=/path/to/jdk'.");
+ }
+
+ Path toolName = Paths.get("bin", tool + (Platform.isWindows() ? ".exe" : ""));
+
+ Path jdkTool = Paths.get(jdkPath, toolName.toString());
+ if (!jdkTool.toFile().exists()) {
+ throw new FileNotFoundException("Could not find file " + jdkTool.toAbsolutePath());
+ }
+
+ return jdkTool.toAbsolutePath().toString();
}
}