infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-02-04 23:48:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge

Browse Source
This commit is contained in:
Serguei Spitsyn 2016-09-13 20:17:46 +00:00
commit fadbcc36d7
1238 changed files with 34310 additions and 6795 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.hgtags
View File

@ -376,3 +376,5 @@ e613affb88d178dc7c589f1679db113d589bddb4 jdk-9+130
4d2a15091124488080d65848b704e25599b2aaeb jdk-9+131
2e83d21d78cd9c1d52e6cd2599e9c8aa36ea1f52 jdk-9+132
e17429a7e843c4a4ed3651458d0f950970edcbcc jdk-9+133
a71210c0d9800eb6925b61ecd6198abd554f90ee jdk-9+134
e384420383a5b79fa0012ebcb25d8f83cff7f777 jdk-9+135

2
.hgtags-top-repo
View File

@ -376,3 +376,5 @@ d94d54a3192fea79234c3ac55cd0b4052d45e954 jdk-9+130
8728756c2f70a79a90188f4019cfd6b9a275765c jdk-9+131
a24702d4d5ab0015a5c553ed57f66fce7d85155e jdk-9+132
be1218f792a450dfb5d4b1f82616b9d95a6a732e jdk-9+133
065724348690eda41fc69112278d8da6dcde548c jdk-9+134
82b94cb5f342319d2cda77f9fa59703ad7fde576 jdk-9+135

6
common/autoconf/generated-configure.sh
View File

@ -5095,7 +5095,7 @@ VS_SDK_PLATFORM_NAME_2013=
#CUSTOM_AUTOCONF_INCLUDE
# Do not change or remove the following line, it is needed for consistency checks:
DATE_WHEN_GENERATED=1470863189
DATE_WHEN_GENERATED=1472718471
###############################################################################
#
@ -15944,6 +15944,8 @@ $as_echo "$COMPILE_TYPE" >&6; }
HOTSPOT_TARGET_CPU_DEFINE=S390
elif test "x$OPENJDK_TARGET_CPU" = xs390x; then
HOTSPOT_TARGET_CPU_DEFINE=S390
elif test "x$OPENJDK_TARGET_CPU" != x; then
HOTSPOT_TARGET_CPU_DEFINE=$(echo $OPENJDK_TARGET_CPU | tr a-z A-Z)
fi
@ -16117,6 +16119,8 @@ $as_echo "$COMPILE_TYPE" >&6; }
HOTSPOT_BUILD_CPU_DEFINE=S390
elif test "x$OPENJDK_BUILD_CPU" = xs390x; then
HOTSPOT_BUILD_CPU_DEFINE=S390
elif test "x$OPENJDK_BUILD_CPU" != x; then
HOTSPOT_BUILD_CPU_DEFINE=$(echo $OPENJDK_BUILD_CPU | tr a-z A-Z)
fi

2
common/autoconf/platform.m4
View File

@ -454,6 +454,8 @@ AC_DEFUN([PLATFORM_SETUP_LEGACY_VARS_HELPER],
HOTSPOT_$1_CPU_DEFINE=S390
elif test "x$OPENJDK_$1_CPU" = xs390x; then
HOTSPOT_$1_CPU_DEFINE=S390
elif test "x$OPENJDK_$1_CPU" != x; then
HOTSPOT_$1_CPU_DEFINE=$(echo $OPENJDK_$1_CPU | tr a-z A-Z)
fi
AC_SUBST(HOTSPOT_$1_CPU_DEFINE)

2
corba/.hgtags
View File

@ -376,3 +376,5 @@ c3e83ccab3bb1733ae903d681879a33f85ed465c jdk-9+129
f7e1d5337c2e550fe553df7a3886bbed80292ecd jdk-9+131
1ab4b9399c4cba584f66c1c088188f2f565fbf9c jdk-9+132
2021bfedf1c478a4808a7711a6090682a12f4c0e jdk-9+133
1a497f5ca0cfd88115cc7daa8af8a62b8741caf2 jdk-9+134
094d0db606db976045f594dba47d4593b715cc81 jdk-9+135

2
hotspot/.hgtags
View File

@ -536,3 +536,5 @@ e96b34b76d863ed1fa04e0eeb3f297ac17b490fd jdk-9+129
943bf73b49c33c2d7cbd796f6a4ae3c7a00ae932 jdk-9+131
713951c08aa26813375175c2ab6cc99ff2a56903 jdk-9+132
a25e0fb6033245ab075136e744d362ce765464cd jdk-9+133
b8b694c6b4d2ab0939aed7adaf0eec1ac321a085 jdk-9+134
3b1c4562953db47e36b237a500f368d5c9746d47 jdk-9+135

1
hotspot/make/test/JtregNative.gmk
View File

@ -44,6 +44,7 @@ BUILD_HOTSPOT_JTREG_NATIVE_SRC := \
$(HOTSPOT_TOPDIR)/test/native_sanity \
$(HOTSPOT_TOPDIR)/test/runtime/jni/8025979 \
$(HOTSPOT_TOPDIR)/test/runtime/jni/8033445 \
$(HOTSPOT_TOPDIR)/test/runtime/jni/checked \
$(HOTSPOT_TOPDIR)/test/runtime/jni/ToStringInInterfaceTest \
$(HOTSPOT_TOPDIR)/test/runtime/modules/getModuleJNI \
$(HOTSPOT_TOPDIR)/test/runtime/SameObject \

3
hotspot/src/cpu/aarch64/vm/interp_masm_aarch64.cpp
View File

@ -326,7 +326,8 @@ void InterpreterMacroAssembler::push_i(Register r) {
}
void InterpreterMacroAssembler::push_l(Register r) {
str(r, pre(esp, 2 * -wordSize));
str(zr, pre(esp, -wordSize));
str(r, pre(esp, -wordsize));
}
void InterpreterMacroAssembler::pop_f(FloatRegister r) {

5
hotspot/src/cpu/aarch64/vm/sharedRuntime_aarch64.cpp
View File

@ -2041,6 +2041,11 @@ nmethod* SharedRuntime::generate_native_wrapper(MacroAssembler* masm,
__ verify_oop(r0);
}
if (CheckJNICalls) {
// clear_pending_jni_exception_check
__ str(zr, Address(rthread, JavaThread::pending_jni_exception_check_fn_offset()));
}
if (!is_critical_native) {
// reset handle block
__ ldr(r2, Address(rthread, JavaThread::active_handles_offset()));

5
hotspot/src/cpu/aarch64/vm/templateInterpreterGenerator_aarch64.cpp
View File

@ -1355,6 +1355,11 @@ address TemplateInterpreterGenerator::generate_native_entry(bool synchronized) {
// reset_last_Java_frame
__ reset_last_Java_frame(true);
if (CheckJNICalls) {
// clear_pending_jni_exception_check
__ str(zr, Address(rthread, JavaThread::pending_jni_exception_check_fn_offset()));
}
// reset handle block
__ ldr(t, Address(rthread, JavaThread::active_handles_offset()));
__ str(zr, Address(t, JNIHandleBlock::top_offset_in_bytes()));

2
hotspot/src/cpu/sparc/vm/globals_sparc.hpp
View File

@ -57,10 +57,12 @@ define_pd_global(intx, InlineSmallCode, 1500);
#ifdef _LP64
// Stack slots are 2X larger in LP64 than in the 32 bit VM.
define_pd_global(intx, CompilerThreadStackSize, 1024);
define_pd_global(intx, ThreadStackSize, 1024);
define_pd_global(intx, VMThreadStackSize, 1024);
#define DEFAULT_STACK_SHADOW_PAGES (20 DEBUG_ONLY(+2))
#else
define_pd_global(intx, CompilerThreadStackSize, 512);
define_pd_global(intx, ThreadStackSize, 512);
define_pd_global(intx, VMThreadStackSize, 512);
#define DEFAULT_STACK_SHADOW_PAGES (6 DEBUG_ONLY(+2))

2
hotspot/src/cpu/sparc/vm/interp_masm_sparc.cpp
View File

@ -359,7 +359,7 @@ void InterpreterMacroAssembler::store_unaligned_long(Register l, Register r1, in
#ifdef _LP64
stx(l, r1, offset);
// store something more useful here
debug_only(stx(G0, r1, offset+Interpreter::stackElementSize);)
stx(G0, r1, offset+Interpreter::stackElementSize);
#else
st(l, r1, offset);
st(l->successor(), r1, offset + Interpreter::stackElementSize);

5
hotspot/src/cpu/sparc/vm/sharedRuntime_sparc.cpp
View File

@ -2765,6 +2765,11 @@ nmethod* SharedRuntime::generate_native_wrapper(MacroAssembler* masm,
__ verify_oop(I0);
}
if (CheckJNICalls) {
// clear_pending_jni_exception_check
__ st_ptr(G0, G2_thread, JavaThread::pending_jni_exception_check_fn_offset());
}
if (!is_critical_native) {
// reset handle block
__ ld_ptr(G2_thread, in_bytes(JavaThread::active_handles_offset()), L5);

5
hotspot/src/cpu/sparc/vm/templateInterpreterGenerator_sparc.cpp
View File

@ -1487,6 +1487,11 @@ address TemplateInterpreterGenerator::generate_native_entry(bool synchronized) {
__ set(_thread_in_Java, G3_scratch);
__ st(G3_scratch, thread_state);
if (CheckJNICalls) {
// clear_pending_jni_exception_check
__ st_ptr(G0, G2_thread, JavaThread::pending_jni_exception_check_fn_offset());
}
// reset handle block
__ ld_ptr(G2_thread, JavaThread::active_handles_offset(), G3_scratch);
__ st(G0, G3_scratch, JNIHandleBlock::top_offset_in_bytes());

3
hotspot/src/cpu/x86/vm/interp_masm_x86.cpp
View File

@ -611,7 +611,8 @@ void InterpreterMacroAssembler::pop_l(Register r) {
void InterpreterMacroAssembler::push_l(Register r) {
subptr(rsp, 2 * wordSize);
movq(Address(rsp, 0), r);
movptr(Address(rsp, Interpreter::expr_offset_in_bytes(0)), r );
movptr(Address(rsp, Interpreter::expr_offset_in_bytes(1)), NULL_WORD );
}
void InterpreterMacroAssembler::pop(TosState state) {

5
hotspot/src/cpu/x86/vm/sharedRuntime_x86_32.cpp
View File

@ -2236,6 +2236,11 @@ nmethod* SharedRuntime::generate_native_wrapper(MacroAssembler* masm,
__ verify_oop(rax);
}
if (CheckJNICalls) {
// clear_pending_jni_exception_check
__ movptr(Address(thread, JavaThread::pending_jni_exception_check_fn_offset()), NULL_WORD);
}
if (!is_critical_native) {
// reset handle block
__ movptr(rcx, Address(thread, JavaThread::active_handles_offset()));

5
hotspot/src/cpu/x86/vm/sharedRuntime_x86_64.cpp
View File

@ -2589,6 +2589,11 @@ nmethod* SharedRuntime::generate_native_wrapper(MacroAssembler* masm,
__ verify_oop(rax);
}
if (CheckJNICalls) {
// clear_pending_jni_exception_check
__ movptr(Address(r15_thread, JavaThread::pending_jni_exception_check_fn_offset()), NULL_WORD);
}
if (!is_critical_native) {
// reset handle block
__ movptr(rcx, Address(r15_thread, JavaThread::active_handles_offset()));

5
hotspot/src/cpu/x86/vm/templateInterpreterGenerator_x86.cpp
View File

@ -1169,6 +1169,11 @@ address TemplateInterpreterGenerator::generate_native_entry(bool synchronized) {
// reset_last_Java_frame
__ reset_last_Java_frame(thread, true);
if (CheckJNICalls) {
// clear_pending_jni_exception_check
__ movptr(Address(thread, JavaThread::pending_jni_exception_check_fn_offset()), NULL_WORD);
}
// reset handle block
__ movptr(t, Address(thread, JavaThread::active_handles_offset()));
__ movl(Address(t, JNIHandleBlock::top_offset_in_bytes()), (int32_t)NULL_WORD);

3
hotspot/src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/utilities/GrowableArray.java
View File

@ -65,4 +65,7 @@ public class GrowableArray<T> extends GenericGrowableArray {
super(addr);
virtualConstructor = v;
}
public Address getData() {
return dataField.getValue(getAddress());
}
}

55
hotspot/src/os/aix/vm/os_aix.cpp
View File

@ -847,7 +847,8 @@ static void *thread_native_entry(Thread *thread) {
return 0;
}
bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
bool os::create_thread(Thread* thread, ThreadType thr_type,
size_t req_stack_size) {
assert(thread->osthread() == NULL, "caller responsible");
@ -880,37 +881,12 @@ bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
guarantee(pthread_attr_setsuspendstate_np(&attr, PTHREAD_CREATE_SUSPENDED_NP) == 0, "???");
// calculate stack size if it's not specified by caller
if (stack_size == 0) {
stack_size = os::Aix::default_stack_size(thr_type);
switch (thr_type) {
case os::java_thread:
// Java threads use ThreadStackSize whose default value can be changed with the flag -Xss.
assert(JavaThread::stack_size_at_create() > 0, "this should be set");
stack_size = JavaThread::stack_size_at_create();
break;
case os::compiler_thread:
if (CompilerThreadStackSize > 0) {
stack_size = (size_t)(CompilerThreadStackSize * K);
break;
} // else fall through:
// use VMThreadStackSize if CompilerThreadStackSize is not defined
case os::vm_thread:
case os::pgc_thread:
case os::cgc_thread:
case os::watcher_thread:
if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
break;
}
}
stack_size = MAX2(stack_size, os::Aix::min_stack_allowed);
size_t stack_size = os::Posix::get_initial_stack_size(thr_type, req_stack_size);
pthread_attr_setstacksize(&attr, stack_size);
pthread_t tid;
int ret = pthread_create(&tid, &attr, (void* (*)(void*)) thread_native_entry, thread);
char buf[64];
if (ret == 0) {
log_info(os, thread)("Thread started (pthread id: " UINTX_FORMAT ", attributes: %s). ",
@ -3593,32 +3569,11 @@ jint os::init_2(void) {
Aix::signal_sets_init();
Aix::install_signal_handlers();
// Check minimum allowable stack size for thread creation and to initialize
// the java system classes, including StackOverflowError - depends on page
// size. Add two 4K pages for compiler2 recursion in main thread.
// Add in 4*BytesPerWord 4K pages to account for VM stack during
// class initialization depending on 32 or 64 bit VM.
os::Aix::min_stack_allowed = MAX2(os::Aix::min_stack_allowed,
JavaThread::stack_guard_zone_size() +
JavaThread::stack_shadow_zone_size() +
(4*BytesPerWord COMPILER2_PRESENT(+2)) * 4 * K);
os::Aix::min_stack_allowed = align_size_up(os::Aix::min_stack_allowed, os::vm_page_size());
size_t threadStackSizeInBytes = ThreadStackSize * K;
if (threadStackSizeInBytes != 0 &&
threadStackSizeInBytes < os::Aix::min_stack_allowed) {
tty->print_cr("\nThe stack size specified is too small, "
"Specify at least %dk",
os::Aix::min_stack_allowed / K);
// Check and sets minimum stack sizes against command line options
if (Posix::set_minimum_stack_sizes() == JNI_ERR) {
return JNI_ERR;
}
// Make the stack size a multiple of the page size so that
// the yellow/red zones can be guarded.
// Note that this can be 0, if no default stacksize was set.
JavaThread::set_stack_size_at_create(round_to(threadStackSizeInBytes, vm_page_size()));
if (UseNUMA) {
UseNUMA = false;
warning("NUMA optimizations are not available on this OS.");

10
hotspot/src/os/aix/vm/os_aix.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2016, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2013, 2016 SAP SE. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
@ -140,14 +140,6 @@ class Aix {
// libpthread version string
static void libpthread_init();
// Minimum stack size a thread can be created with (allowing
// the VM to completely create the thread and enter user code)
static size_t min_stack_allowed;
// Return default stack size or guard size for the specified thread type
static size_t default_stack_size(os::ThreadType thr_type);
static size_t default_guard_size(os::ThreadType thr_type);
// Function returns true if we run on OS/400 (pase), false if we run
// on AIX.
static bool on_pase() {

55
hotspot/src/os/bsd/vm/os_bsd.cpp
View File

@ -734,7 +734,8 @@ static void *thread_native_entry(Thread *thread) {
return 0;
}
bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
bool os::create_thread(Thread* thread, ThreadType thr_type,
size_t req_stack_size) {
assert(thread->osthread() == NULL, "caller responsible");
// Allocate the OSThread object
@ -757,32 +758,7 @@ bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
// calculate stack size if it's not specified by caller
if (stack_size == 0) {
stack_size = os::Bsd::default_stack_size(thr_type);
switch (thr_type) {
case os::java_thread:
// Java threads use ThreadStackSize which default value can be
// changed with the flag -Xss
assert(JavaThread::stack_size_at_create() > 0, "this should be set");
stack_size = JavaThread::stack_size_at_create();
break;
case os::compiler_thread:
if (CompilerThreadStackSize > 0) {
stack_size = (size_t)(CompilerThreadStackSize * K);
break;
} // else fall through:
// use VMThreadStackSize if CompilerThreadStackSize is not defined
case os::vm_thread:
case os::pgc_thread:
case os::cgc_thread:
case os::watcher_thread:
if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
break;
}
}
stack_size = MAX2(stack_size, os::Bsd::min_stack_allowed);
size_t stack_size = os::Posix::get_initial_stack_size(thr_type, req_stack_size);
pthread_attr_setstacksize(&attr, stack_size);
ThreadState state;
@ -3502,32 +3478,11 @@ jint os::init_2(void) {
Bsd::signal_sets_init();
Bsd::install_signal_handlers();
// Check minimum allowable stack size for thread creation and to initialize
// the java system classes, including StackOverflowError - depends on page
// size. Add two 4K pages for compiler2 recursion in main thread.
// Add in 4*BytesPerWord 4K pages to account for VM stack during
// class initialization depending on 32 or 64 bit VM.
os::Bsd::min_stack_allowed = MAX2(os::Bsd::min_stack_allowed,
JavaThread::stack_guard_zone_size() +
JavaThread::stack_shadow_zone_size() +
(4*BytesPerWord COMPILER2_PRESENT(+2)) * 4 * K);
os::Bsd::min_stack_allowed = align_size_up(os::Bsd::min_stack_allowed, os::vm_page_size());
size_t threadStackSizeInBytes = ThreadStackSize * K;
if (threadStackSizeInBytes != 0 &&
threadStackSizeInBytes < os::Bsd::min_stack_allowed) {
tty->print_cr("\nThe stack size specified is too small, "
"Specify at least %dk",
os::Bsd::min_stack_allowed/ K);
// Check and sets minimum stack sizes against command line options
if (Posix::set_minimum_stack_sizes() == JNI_ERR) {
return JNI_ERR;
}
// Make the stack size a multiple of the page size so that
// the yellow/red zones can be guarded.
JavaThread::set_stack_size_at_create(round_to(threadStackSizeInBytes,
vm_page_size()));
if (MaxFDLimit) {
// set the number of file descriptors to max. print out error
// if getrlimit/setrlimit fails but continue regardless.

10
hotspot/src/os/bsd/vm/os_bsd.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2016, 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
@ -120,14 +120,6 @@ class Bsd {
static struct sigaction *get_chained_signal_action(int sig);
static bool chained_handler(int sig, siginfo_t* siginfo, void* context);
// Minimum stack size a thread can be created with (allowing
// the VM to completely create the thread and enter user code)
static size_t min_stack_allowed;
// Return default stack size or guard size for the specified thread type
static size_t default_stack_size(os::ThreadType thr_type);
static size_t default_guard_size(os::ThreadType thr_type);
// Real-time clock functions
static void clock_init(void);

59
hotspot/src/os/linux/vm/os_linux.cpp
View File

@ -701,7 +701,7 @@ static void *thread_native_entry(Thread *thread) {
}
bool os::create_thread(Thread* thread, ThreadType thr_type,
size_t stack_size) {
size_t req_stack_size) {
assert(thread->osthread() == NULL, "caller responsible");
// Allocate the OSThread object
@ -723,34 +723,8 @@ bool os::create_thread(Thread* thread, ThreadType thr_type,
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
// stack size
// calculate stack size if it's not specified by caller
if (stack_size == 0) {
stack_size = os::Linux::default_stack_size(thr_type);
switch (thr_type) {
case os::java_thread:
// Java threads use ThreadStackSize which default value can be
// changed with the flag -Xss
assert(JavaThread::stack_size_at_create() > 0, "this should be set");
stack_size = JavaThread::stack_size_at_create();
break;
case os::compiler_thread:
if (CompilerThreadStackSize > 0) {
stack_size = (size_t)(CompilerThreadStackSize * K);
break;
} // else fall through:
// use VMThreadStackSize if CompilerThreadStackSize is not defined
case os::vm_thread:
case os::pgc_thread:
case os::cgc_thread:
case os::watcher_thread:
if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
break;
}
}
stack_size = MAX2(stack_size, os::Linux::min_stack_allowed);
size_t stack_size = os::Posix::get_initial_stack_size(thr_type, req_stack_size);
pthread_attr_setstacksize(&attr, stack_size);
// glibc guard page
@ -956,10 +930,9 @@ static bool find_vma(address addr, address* vma_low, address* vma_high) {
// bogus value for initial thread.
void os::Linux::capture_initial_stack(size_t max_size) {
// stack size is the easy part, get it from RLIMIT_STACK
size_t stack_size;
struct rlimit rlim;
getrlimit(RLIMIT_STACK, &rlim);
stack_size = rlim.rlim_cur;
size_t stack_size = rlim.rlim_cur;
// 6308388: a bug in ld.so will relocate its own .data section to the
// lower end of primordial stack; reduce ulimit -s value a little bit
@ -4793,32 +4766,10 @@ jint os::init_2(void) {
Linux::signal_sets_init();
Linux::install_signal_handlers();
// Check minimum allowable stack size for thread creation and to initialize
// the java system classes, including StackOverflowError - depends on page
// size. Add two 4K pages for compiler2 recursion in main thread.
// Add in 4*BytesPerWord 4K pages to account for VM stack during
// class initialization depending on 32 or 64 bit VM.
os::Linux::min_stack_allowed = MAX2(os::Linux::min_stack_allowed,
JavaThread::stack_guard_zone_size() +
JavaThread::stack_shadow_zone_size() +
(4*BytesPerWord COMPILER2_PRESENT(+2)) * 4 * K);
os::Linux::min_stack_allowed = align_size_up(os::Linux::min_stack_allowed, os::vm_page_size());
size_t threadStackSizeInBytes = ThreadStackSize * K;
if (threadStackSizeInBytes != 0 &&
threadStackSizeInBytes < os::Linux::min_stack_allowed) {
tty->print_cr("\nThe stack size specified is too small, "
"Specify at least " SIZE_FORMAT "k",
os::Linux::min_stack_allowed/ K);
// Check and sets minimum stack sizes against command line options
if (Posix::set_minimum_stack_sizes() == JNI_ERR) {
return JNI_ERR;
}
// Make the stack size a multiple of the page size so that
// the yellow/red zones can be guarded.
JavaThread::set_stack_size_at_create(round_to(threadStackSizeInBytes,
vm_page_size()));
Linux::capture_initial_stack(JavaThread::stack_size_at_create());
#if defined(IA32)

8
hotspot/src/os/linux/vm/os_linux.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2016, 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
@ -170,12 +170,8 @@ class Linux {
static void libpthread_init();
static bool libnuma_init();
static void* libnuma_dlsym(void* handle, const char* name);
// Minimum stack size a thread can be created with (allowing
// the VM to completely create the thread and enter user code)
static size_t min_stack_allowed;
// Return default stack size or guard size for the specified thread type
static size_t default_stack_size(os::ThreadType thr_type);
// Return default guard size for the specified thread type
static size_t default_guard_size(os::ThreadType thr_type);
static void capture_initial_stack(size_t max_size);

117
hotspot/src/os/posix/vm/os_posix.cpp
View File

@ -1099,6 +1099,123 @@ char* os::Posix::describe_pthread_attr(char* buf, size_t buflen, const pthread_a
return buf;
}
// Check minimum allowable stack sizes for thread creation and to initialize
// the java system classes, including StackOverflowError - depends on page
// size. Add two 4K pages for compiler2 recursion in main thread.
// Add in 4*BytesPerWord 4K pages to account for VM stack during
// class initialization depending on 32 or 64 bit VM.
jint os::Posix::set_minimum_stack_sizes() {
_java_thread_min_stack_allowed = MAX2(_java_thread_min_stack_allowed,
JavaThread::stack_guard_zone_size() +
JavaThread::stack_shadow_zone_size() +
(4 * BytesPerWord COMPILER2_PRESENT(+ 2)) * 4 * K);
_java_thread_min_stack_allowed = align_size_up(_java_thread_min_stack_allowed, vm_page_size());
size_t stack_size_in_bytes = ThreadStackSize * K;
if (stack_size_in_bytes != 0 &&
stack_size_in_bytes < _java_thread_min_stack_allowed) {
// The '-Xss' and '-XX:ThreadStackSize=N' options both set
// ThreadStackSize so we go with "Java thread stack size" instead
// of "ThreadStackSize" to be more friendly.
tty->print_cr("\nThe Java thread stack size specified is too small. "
"Specify at least " SIZE_FORMAT "k",
_java_thread_min_stack_allowed / K);
return JNI_ERR;
}
#ifdef SOLARIS
// For 64kbps there will be a 64kb page size, which makes
// the usable default stack size quite a bit less. Increase the
// stack for 64kb (or any > than 8kb) pages, this increases
// virtual memory fragmentation (since we're not creating the
// stack on a power of 2 boundary. The real fix for this
// should be to fix the guard page mechanism.
if (vm_page_size() > 8*K) {
stack_size_in_bytes = (stack_size_in_bytes != 0)
? stack_size_in_bytes +
JavaThread::stack_red_zone_size() +
JavaThread::stack_yellow_zone_size()
: 0;
ThreadStackSize = stack_size_in_bytes/K;
}
#endif // SOLARIS
// Make the stack size a multiple of the page size so that
// the yellow/red zones can be guarded.
JavaThread::set_stack_size_at_create(round_to(stack_size_in_bytes,
vm_page_size()));
_compiler_thread_min_stack_allowed = align_size_up(_compiler_thread_min_stack_allowed, vm_page_size());
stack_size_in_bytes = CompilerThreadStackSize * K;
if (stack_size_in_bytes != 0 &&
stack_size_in_bytes < _compiler_thread_min_stack_allowed) {
tty->print_cr("\nThe CompilerThreadStackSize specified is too small. "
"Specify at least " SIZE_FORMAT "k",
_compiler_thread_min_stack_allowed / K);
return JNI_ERR;
}
_vm_internal_thread_min_stack_allowed = align_size_up(_vm_internal_thread_min_stack_allowed, vm_page_size());
stack_size_in_bytes = VMThreadStackSize * K;
if (stack_size_in_bytes != 0 &&
stack_size_in_bytes < _vm_internal_thread_min_stack_allowed) {
tty->print_cr("\nThe VMThreadStackSize specified is too small. "
"Specify at least " SIZE_FORMAT "k",
_vm_internal_thread_min_stack_allowed / K);
return JNI_ERR;
}
return JNI_OK;
}
// Called when creating the thread. The minimum stack sizes have already been calculated
size_t os::Posix::get_initial_stack_size(ThreadType thr_type, size_t req_stack_size) {
size_t stack_size;
if (req_stack_size == 0) {
stack_size = default_stack_size(thr_type);
} else {
stack_size = req_stack_size;
}
switch (thr_type) {
case os::java_thread:
// Java threads use ThreadStackSize which default value can be
// changed with the flag -Xss
if (req_stack_size == 0 && JavaThread::stack_size_at_create() > 0) {
// no requested size and we have a more specific default value
stack_size = JavaThread::stack_size_at_create();
}
stack_size = MAX2(stack_size,
_java_thread_min_stack_allowed);
break;
case os::compiler_thread:
if (req_stack_size == 0 && CompilerThreadStackSize > 0) {
// no requested size and we have a more specific default value
stack_size = (size_t)(CompilerThreadStackSize * K);
}
stack_size = MAX2(stack_size,
_compiler_thread_min_stack_allowed);
break;
case os::vm_thread:
case os::pgc_thread:
case os::cgc_thread:
case os::watcher_thread:
default: // presume the unknown thr_type is a VM internal
if (req_stack_size == 0 && VMThreadStackSize > 0) {
// no requested size and we have a more specific default value
stack_size = (size_t)(VMThreadStackSize * K);
}
stack_size = MAX2(stack_size,
_vm_internal_thread_min_stack_allowed);
break;
}
return stack_size;
}
os::WatcherThreadCrashProtection::WatcherThreadCrashProtection() {
assert(Thread::current()->is_Watcher_thread(), "Must be WatcherThread");

13
hotspot/src/os/posix/vm/os_posix.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2016, 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
@ -42,7 +42,18 @@ protected:
static void print_libversion_info(outputStream* st);
static void print_load_average(outputStream* st);
// Minimum stack size a thread can be created with (allowing
// the VM to completely create the thread and enter user code)
static size_t _compiler_thread_min_stack_allowed;
static size_t _java_thread_min_stack_allowed;
static size_t _vm_internal_thread_min_stack_allowed;
public:
// Return default stack size for the specified thread type
static size_t default_stack_size(os::ThreadType thr_type);
// Check and sets minimum stack sizes
static jint set_minimum_stack_sizes();
static size_t get_initial_stack_size(ThreadType thr_type, size_t req_stack_size);
// Returns true if signal is valid.
static bool is_valid_signal(int sig);

83
hotspot/src/os/solaris/vm/os_solaris.cpp
View File

@ -917,8 +917,15 @@ static char* describe_thr_create_attributes(char* buf, size_t buflen,
return buf;
}
// return default stack size for thr_type
size_t os::Posix::default_stack_size(os::ThreadType thr_type) {
// default stack size when not specified by caller is 1M (2M for LP64)
size_t s = (BytesPerWord >> 2) * K * K;
return s;
}
bool os::create_thread(Thread* thread, ThreadType thr_type,
size_t stack_size) {
size_t req_stack_size) {
// Allocate the OSThread object
OSThread* osthread = new OSThread(NULL, NULL);
if (osthread == NULL) {
@ -953,31 +960,8 @@ bool os::create_thread(Thread* thread, ThreadType thr_type,
tty->print_cr("In create_thread, creating a %s thread\n", thrtyp);
}
// Calculate stack size if it's not specified by caller.
if (stack_size == 0) {
// The default stack size 1M (2M for LP64).
stack_size = (BytesPerWord >> 2) * K * K;
switch (thr_type) {
case os::java_thread:
// Java threads use ThreadStackSize which default value can be changed with the flag -Xss
if (JavaThread::stack_size_at_create() > 0) stack_size = JavaThread::stack_size_at_create();
break;
case os::compiler_thread:
if (CompilerThreadStackSize > 0) {
stack_size = (size_t)(CompilerThreadStackSize * K);
break;
} // else fall through:
// use VMThreadStackSize if CompilerThreadStackSize is not defined
case os::vm_thread:
case os::pgc_thread:
case os::cgc_thread:
case os::watcher_thread:
if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
break;
}
}
stack_size = MAX2(stack_size, os::Solaris::min_stack_allowed);
// calculate stack size if it's not specified by caller
size_t stack_size = os::Posix::get_initial_stack_size(thr_type, req_stack_size);
// Initial state is ALLOCATED but not INITIALIZED
osthread->set_state(ALLOCATED);
@ -4400,7 +4384,12 @@ void os::init(void) {
// Constant minimum stack size allowed. It must be at least
// the minimum of what the OS supports (thr_min_stack()), and
// enough to allow the thread to get to user bytecode execution.
Solaris::min_stack_allowed = MAX2(thr_min_stack(), Solaris::min_stack_allowed);
Posix::_compiler_thread_min_stack_allowed = MAX2(thr_min_stack(),
Posix::_compiler_thread_min_stack_allowed);
Posix::_java_thread_min_stack_allowed = MAX2(thr_min_stack(),
Posix::_java_thread_min_stack_allowed);
Posix::_vm_internal_thread_min_stack_allowed = MAX2(thr_min_stack(),
Posix::_vm_internal_thread_min_stack_allowed);
// dynamic lookup of functions that may not be available in our lowest
// supported Solaris release
@ -4445,47 +4434,11 @@ jint os::init_2(void) {
log_info(os)("Memory Serialize Page address: " INTPTR_FORMAT, p2i(mem_serialize_page));
}
// Check minimum allowable stack size for thread creation and to initialize
// the java system classes, including StackOverflowError - depends on page
// size. Add two 4K pages for compiler2 recursion in main thread.
// Add in 4*BytesPerWord 4K pages to account for VM stack during
// class initialization depending on 32 or 64 bit VM.
os::Solaris::min_stack_allowed = MAX2(os::Solaris::min_stack_allowed,
JavaThread::stack_guard_zone_size() +
JavaThread::stack_shadow_zone_size() +
(4*BytesPerWord COMPILER2_PRESENT(+2)) * 4 * K);
os::Solaris::min_stack_allowed = align_size_up(os::Solaris::min_stack_allowed, os::vm_page_size());
size_t threadStackSizeInBytes = ThreadStackSize * K;
if (threadStackSizeInBytes != 0 &&
threadStackSizeInBytes < os::Solaris::min_stack_allowed) {
tty->print_cr("\nThe stack size specified is too small, Specify at least %dk",
os::Solaris::min_stack_allowed/K);
// Check and sets minimum stack sizes against command line options
if (Posix::set_minimum_stack_sizes() == JNI_ERR) {
return JNI_ERR;
}
// For 64kbps there will be a 64kb page size, which makes
// the usable default stack size quite a bit less. Increase the
// stack for 64kb (or any > than 8kb) pages, this increases
// virtual memory fragmentation (since we're not creating the
// stack on a power of 2 boundary. The real fix for this
// should be to fix the guard page mechanism.
if (vm_page_size() > 8*K) {
threadStackSizeInBytes = (threadStackSizeInBytes != 0)
? threadStackSizeInBytes +
JavaThread::stack_red_zone_size() +
JavaThread::stack_yellow_zone_size()
: 0;
ThreadStackSize = threadStackSizeInBytes/K;
}
// Make the stack size a multiple of the page size so that
// the yellow/red zones can be guarded.
JavaThread::set_stack_size_at_create(round_to(threadStackSizeInBytes,
vm_page_size()));
Solaris::libthread_init();
if (UseNUMA) {

4
hotspot/src/os/solaris/vm/os_solaris.hpp
View File

@ -292,10 +292,6 @@ class Solaris {
static jint _os_thread_limit;
static volatile jint _os_thread_count;
// Minimum stack size a thread can be created with (allowing
// the VM to completely create the thread and enter user code)
static size_t min_stack_allowed;
// Stack overflow handling

2
hotspot/src/os/windows/vm/os_windows.cpp
View File

@ -4215,7 +4215,7 @@ jint os::init_2(void) {
min_stack_allowed = align_size_up(min_stack_allowed, os::vm_page_size());
if (actual_reserve_size < min_stack_allowed) {
tty->print_cr("\nThe stack size specified is too small, "
tty->print_cr("\nThe Java thread stack size specified is too small. "
"Specify at least %dk",
min_stack_allowed / K);
return JNI_ERR;

6
hotspot/src/os_cpu/aix_ppc/vm/globals_aix_ppc.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2002, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2002, 2016, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2012, 2015 SAP SE. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
@ -33,10 +33,6 @@ define_pd_global(bool, DontYieldALot, false);
define_pd_global(intx, ThreadStackSize, 2048); // 0 => use system default
define_pd_global(intx, VMThreadStackSize, 2048);
// if we set CompilerThreadStackSize to a value different than 0, it will
// be used in os::create_thread(). Otherwise, due the strange logic in os::create_thread(),
// the stack size for compiler threads will default to VMThreadStackSize, although it
// is defined to 4M in os::Aix::default_stack_size()!
define_pd_global(intx, CompilerThreadStackSize, 4096);
// Allow extra space in DEBUG builds for asserts.

14
hotspot/src/os_cpu/aix_ppc/vm/os_aix_ppc.cpp
View File

@ -533,23 +533,17 @@ void os::Aix::init_thread_fpu_state(void) {
////////////////////////////////////////////////////////////////////////////////
// thread stack
size_t os::Aix::min_stack_allowed = 128*K;
size_t os::Posix::_compiler_thread_min_stack_allowed = 128 * K;
size_t os::Posix::_java_thread_min_stack_allowed = 128 * K;
size_t os::Posix::_vm_internal_thread_min_stack_allowed = 128 * K;
// return default stack size for thr_type
size_t os::Aix::default_stack_size(os::ThreadType thr_type) {
size_t os::Posix::default_stack_size(os::ThreadType thr_type) {
// default stack size (compiler thread needs larger stack)
// Notice that the setting for compiler threads here have no impact
// because of the strange 'fallback logic' in os::create_thread().
// Better set CompilerThreadStackSize in globals_<os_cpu>.hpp if you want to
// specify a different stack size for compiler threads!
size_t s = (thr_type == os::compiler_thread ? 4 * M : 1 * M);
return s;
}
size_t os::Aix::default_guard_size(os::ThreadType thr_type) {
return 2 * page_size();
}
/////////////////////////////////////////////////////////////////////////////
// helper functions for fatal error handler

5
hotspot/src/os_cpu/bsd_x86/vm/globals_bsd_x86.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2016, 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
@ -31,9 +31,11 @@
//
define_pd_global(bool, DontYieldALot, false);
#ifdef AMD64
define_pd_global(intx, CompilerThreadStackSize, 1024);
define_pd_global(intx, ThreadStackSize, 1024); // 0 => use system default
define_pd_global(intx, VMThreadStackSize, 1024);
#else
define_pd_global(intx, CompilerThreadStackSize, 512);
// ThreadStackSize 320 allows a couple of test cases to run while
// keeping the number of threads that can be created high. System
// default ThreadStackSize appears to be 512 which is too big.
@ -41,7 +43,6 @@ define_pd_global(intx, ThreadStackSize, 320);
define_pd_global(intx, VMThreadStackSize, 512);
#endif // AMD64
define_pd_global(intx, CompilerThreadStackSize, 0);
define_pd_global(size_t, JVMInvokeMethodSlack, 8192);

15
hotspot/src/os_cpu/bsd_x86/vm/os_bsd_x86.cpp
View File

@ -838,9 +838,13 @@ bool os::is_allocatable(size_t bytes) {
// thread stack
#ifdef AMD64
size_t os::Bsd::min_stack_allowed = 64 * K;
size_t os::Posix::_compiler_thread_min_stack_allowed = 64 * K;
size_t os::Posix::_java_thread_min_stack_allowed = 64 * K;
size_t os::Posix::_vm_internal_thread_min_stack_allowed = 64 * K;
#else
size_t os::Bsd::min_stack_allowed = (48 DEBUG_ONLY(+4))*K;
size_t os::Posix::_compiler_thread_min_stack_allowed = (48 DEBUG_ONLY(+ 4)) * K;
size_t os::Posix::_java_thread_min_stack_allowed = (48 DEBUG_ONLY(+ 4)) * K;
size_t os::Posix::_vm_internal_thread_min_stack_allowed = (48 DEBUG_ONLY(+ 4)) * K;
#ifdef __GNUC__
#define GET_GS() ({int gs; __asm__ volatile("movw %%gs, %w0":"=q"(gs)); gs&0xffff;})
@ -849,7 +853,7 @@ size_t os::Bsd::min_stack_allowed = (48 DEBUG_ONLY(+4))*K;
#endif // AMD64
// return default stack size for thr_type
size_t os::Bsd::default_stack_size(os::ThreadType thr_type) {
size_t os::Posix::default_stack_size(os::ThreadType thr_type) {
// default stack size (compiler thread needs larger stack)
#ifdef AMD64
size_t s = (thr_type == os::compiler_thread ? 4 * M : 1 * M);
@ -859,11 +863,6 @@ size_t os::Bsd::default_stack_size(os::ThreadType thr_type) {
return s;
}
size_t os::Bsd::default_guard_size(os::ThreadType thr_type) {
// Creating guard page is very expensive. Java thread has HotSpot
// guard page, only enable glibc guard page for non-Java threads.
return (thr_type == java_thread ? 0 : page_size());
}
// Java thread:
//

12
hotspot/src/os_cpu/bsd_zero/vm/os_bsd_zero.cpp
View File

@ -282,9 +282,11 @@ bool os::is_allocatable(size_t bytes) {
///////////////////////////////////////////////////////////////////////////////
// thread stack
size_t os::Bsd::min_stack_allowed = 64 * K;
size_t os::Posix::_compiler_thread_min_stack_allowed = 64 * K;
size_t os::Posix::_java_thread_min_stack_allowed = 64 * K;
size_t os::Posix::_vm_internal_thread_min_stack_allowed = 64 * K;
size_t os::Bsd::default_stack_size(os::ThreadType thr_type) {
size_t os::Posix::default_stack_size(os::ThreadType thr_type) {
#ifdef _LP64
size_t s = (thr_type == os::compiler_thread ? 4 * M : 1 * M);
#else
@ -293,12 +295,6 @@ size_t os::Bsd::default_stack_size(os::ThreadType thr_type) {
return s;
}
size_t os::Bsd::default_guard_size(os::ThreadType thr_type) {
// Only enable glibc guard pages for non-Java threads
// (Java threads have HotSpot guard pages)
return (thr_type == java_thread ? 0 : page_size());
}
static void current_stack_region(address *bottom, size_t *size) {
address stack_bottom;
address stack_top;

4
hotspot/src/os_cpu/linux_aarch64/vm/globals_linux_aarch64.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2014, Red Hat Inc. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
@ -33,7 +33,7 @@ define_pd_global(bool, DontYieldALot, false);
define_pd_global(intx, ThreadStackSize, 2048); // 0 => use system default
define_pd_global(intx, VMThreadStackSize, 2048);
define_pd_global(intx, CompilerThreadStackSize, 0);
define_pd_global(intx, CompilerThreadStackSize, 2048);
define_pd_global(uintx,JVMInvokeMethodSlack, 8192);

6
hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp
View File

@ -473,10 +473,12 @@ bool os::is_allocatable(size_t bytes) {
////////////////////////////////////////////////////////////////////////////////
// thread stack
size_t os::Linux::min_stack_allowed = 64 * K;
size_t os::Posix::_compiler_thread_min_stack_allowed = 64 * K;
size_t os::Posix::_java_thread_min_stack_allowed = 64 * K;
size_t os::Posix::_vm_internal_thread_min_stack_allowed = 64 * K;
// return default stack size for thr_type
size_t os::Linux::default_stack_size(os::ThreadType thr_type) {
size_t os::Posix::default_stack_size(os::ThreadType thr_type) {
// default stack size (compiler thread needs larger stack)
size_t s = (thr_type == os::compiler_thread ? 4 * M : 1 * M);
return s;

6
hotspot/src/os_cpu/linux_ppc/vm/globals_linux_ppc.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2002, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2002, 2016, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2012, 2015 SAP SE. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
@ -33,10 +33,6 @@ define_pd_global(bool, DontYieldALot, false);
define_pd_global(intx, ThreadStackSize, 2048); // 0 => use system default
define_pd_global(intx, VMThreadStackSize, 2048);
// if we set CompilerThreadStackSize to a value different than 0, it will
// be used in os::create_thread(). Otherwise, due the strange logic in os::create_thread(),
// the stack size for compiler threads will default to VMThreadStackSize, although it
// is defined to 4M in os::Linux::default_stack_size()!
define_pd_global(intx, CompilerThreadStackSize, 4096);
// Allow extra space in DEBUG builds for asserts.

10
hotspot/src/os_cpu/linux_ppc/vm/os_linux_ppc.cpp
View File

@ -533,15 +533,13 @@ void os::Linux::set_fpu_control_word(int fpu_control) {
////////////////////////////////////////////////////////////////////////////////
// thread stack
size_t os::Linux::min_stack_allowed = 128*K;
size_t os::Posix::_compiler_thread_min_stack_allowed = 128 * K;
size_t os::Posix::_java_thread_min_stack_allowed = 128 * K;
size_t os::Posix::_vm_internal_thread_min_stack_allowed = 128 * K;
// return default stack size for thr_type
size_t os::Linux::default_stack_size(os::ThreadType thr_type) {
size_t os::Posix::default_stack_size(os::ThreadType thr_type) {
// default stack size (compiler thread needs larger stack)
// Notice that the setting for compiler threads here have no impact
// because of the strange 'fallback logic' in os::create_thread().
// Better set CompilerThreadStackSize in globals_<os_cpu>.hpp if you want to
// specify a different stack size for compiler threads!
size_t s = (thr_type == os::compiler_thread ? 4 * M : 1024 * K);
return s;
}

3
hotspot/src/os_cpu/linux_sparc/vm/globals_linux_sparc.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2016, 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
@ -31,7 +31,6 @@
//
define_pd_global(size_t, JVMInvokeMethodSlack, 12288);
define_pd_global(intx, CompilerThreadStackSize, 0);
// Used on 64 bit platforms for UseCompressedOops base address
define_pd_global(size_t, HeapBaseMinAddress, CONST64(4)*G);

6
hotspot/src/os_cpu/linux_sparc/vm/os_linux_sparc.cpp
View File

@ -726,10 +726,12 @@ bool os::is_allocatable(size_t bytes) {
///////////////////////////////////////////////////////////////////////////////
// thread stack
size_t os::Linux::min_stack_allowed = 128 * K;
size_t os::Posix::_compiler_thread_min_stack_allowed = 128 * K;
size_t os::Posix::_java_thread_min_stack_allowed = 128 * K;
size_t os::Posix::_vm_internal_thread_min_stack_allowed = 128 * K;
// return default stack size for thr_type
size_t os::Linux::default_stack_size(os::ThreadType thr_type) {
size_t os::Posix::default_stack_size(os::ThreadType thr_type) {
// default stack size (compiler thread needs larger stack)
size_t s = (thr_type == os::compiler_thread ? 4 * M : 1 * M);
return s;

6
hotspot/src/os_cpu/linux_x86/vm/globals_linux_x86.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2016, 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,9 +30,11 @@
define_pd_global(bool, DontYieldALot, false);
#ifdef AMD64
define_pd_global(intx, CompilerThreadStackSize, 1024);
define_pd_global(intx, ThreadStackSize, 1024); // 0 => use system default
define_pd_global(intx, VMThreadStackSize, 1024);
#else
define_pd_global(intx, CompilerThreadStackSize, 512);
// ThreadStackSize 320 allows a couple of test cases to run while
// keeping the number of threads that can be created high. System
// default ThreadStackSize appears to be 512 which is too big.
@ -40,8 +42,6 @@ define_pd_global(intx, ThreadStackSize, 320);
define_pd_global(intx, VMThreadStackSize, 512);
#endif // AMD64
define_pd_global(intx, CompilerThreadStackSize, 0);
define_pd_global(size_t, JVMInvokeMethodSlack, 8192);
// Used on 64 bit platforms for UseCompressedOops base address

10
hotspot/src/os_cpu/linux_x86/vm/os_linux_x86.cpp
View File

@ -676,13 +676,17 @@ bool os::is_allocatable(size_t bytes) {
// thread stack
#ifdef AMD64
size_t os::Linux::min_stack_allowed = 64 * K;
size_t os::Posix::_compiler_thread_min_stack_allowed = 64 * K;
size_t os::Posix::_java_thread_min_stack_allowed = 64 * K;
size_t os::Posix::_vm_internal_thread_min_stack_allowed = 64 * K;
#else
size_t os::Linux::min_stack_allowed = (48 DEBUG_ONLY(+4))*K;
size_t os::Posix::_compiler_thread_min_stack_allowed = (48 DEBUG_ONLY(+ 4)) * K;
size_t os::Posix::_java_thread_min_stack_allowed = (48 DEBUG_ONLY(+ 4)) * K;
size_t os::Posix::_vm_internal_thread_min_stack_allowed = (48 DEBUG_ONLY(+ 4)) * K;
#endif // AMD64
// return default stack size for thr_type
size_t os::Linux::default_stack_size(os::ThreadType thr_type) {
size_t os::Posix::default_stack_size(os::ThreadType thr_type) {
// default stack size (compiler thread needs larger stack)
#ifdef AMD64
size_t s = (thr_type == os::compiler_thread ? 4 * M : 1 * M);

6
hotspot/src/os_cpu/linux_zero/vm/os_linux_zero.cpp
View File

@ -307,9 +307,11 @@ bool os::is_allocatable(size_t bytes) {
///////////////////////////////////////////////////////////////////////////////
// thread stack
size_t os::Linux::min_stack_allowed = 64 * K;
size_t os::Posix::_compiler_thread_min_stack_allowed = 64 * K;
size_t os::Posix::_java_thread_min_stack_allowed = 64 * K;
size_t os::Posix::_vm_internal_thread_min_stack_allowed = 64 * K;
size_t os::Linux::default_stack_size(os::ThreadType thr_type) {
size_t os::Posix::default_stack_size(os::ThreadType thr_type) {
#ifdef _LP64
size_t s = (thr_type == os::compiler_thread ? 4 * M : 1 * M);
#else

3
hotspot/src/os_cpu/solaris_sparc/vm/globals_solaris_sparc.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2016, 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
@ -31,7 +31,6 @@
//
define_pd_global(size_t, JVMInvokeMethodSlack, 12288);
define_pd_global(intx, CompilerThreadStackSize, 0);
// Used on 64 bit platforms for UseCompressedOops base address
#ifdef _LP64

8
hotspot/src/os_cpu/solaris_sparc/vm/os_solaris_sparc.cpp
View File

@ -84,9 +84,13 @@
// Minimum stack size for the VM. It's easier to document a constant
// but it's different for x86 and sparc because the page sizes are different.
#ifdef _LP64
size_t os::Solaris::min_stack_allowed = 128*K;
size_t os::Posix::_compiler_thread_min_stack_allowed = 128 * K;
size_t os::Posix::_java_thread_min_stack_allowed = 128 * K;
size_t os::Posix::_vm_internal_thread_min_stack_allowed = 128 * K;
#else
size_t os::Solaris::min_stack_allowed = 96*K;
size_t os::Posix::_compiler_thread_min_stack_allowed = 96 * K;
size_t os::Posix::_java_thread_min_stack_allowed = 96 * K;
size_t os::Posix::_vm_internal_thread_min_stack_allowed = 96 * K;
#endif
int os::Solaris::max_register_window_saves_before_flushing() {

5
hotspot/src/os_cpu/solaris_x86/vm/globals_solaris_x86.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2016, 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,10 +30,12 @@
define_pd_global(bool, DontYieldALot, true); // Determined in the design center
#ifdef AMD64
define_pd_global(intx, CompilerThreadStackSize, 1024);
define_pd_global(intx, ThreadStackSize, 1024); // 0 => use system default
define_pd_global(intx, VMThreadStackSize, 1024);
define_pd_global(size_t, JVMInvokeMethodSlack, 8*K);
#else
define_pd_global(intx, CompilerThreadStackSize, 512);
// ThreadStackSize 320 allows a couple of test cases to run while
// keeping the number of threads that can be created high.
define_pd_global(intx, ThreadStackSize, 320);
@ -41,7 +43,6 @@ define_pd_global(intx, VMThreadStackSize, 512);
define_pd_global(size_t, JVMInvokeMethodSlack, 10*K);
#endif // AMD64
define_pd_global(intx, CompilerThreadStackSize, 0);
// Used on 64 bit platforms for UseCompressedOops base address
define_pd_global(size_t, HeapBaseMinAddress, 2*G);

10
hotspot/src/os_cpu/solaris_x86/vm/os_solaris_x86.cpp
View File

@ -86,15 +86,19 @@
#define MAX_PATH (2 * K)
// Minimum stack size for the VM. It's easier to document a constant value
// Minimum stack sizes for the VM. It's easier to document a constant value
// but it's different for x86 and sparc because the page sizes are different.
#ifdef AMD64
size_t os::Solaris::min_stack_allowed = 224*K;
size_t os::Posix::_compiler_thread_min_stack_allowed = 394 * K;
size_t os::Posix::_java_thread_min_stack_allowed = 224 * K;
size_t os::Posix::_vm_internal_thread_min_stack_allowed = 224 * K;
#define REG_SP REG_RSP
#define REG_PC REG_RIP
#define REG_FP REG_RBP
#else
size_t os::Solaris::min_stack_allowed = 64*K;
size_t os::Posix::_compiler_thread_min_stack_allowed = 64 * K;
size_t os::Posix::_java_thread_min_stack_allowed = 64 * K;
size_t os::Posix::_vm_internal_thread_min_stack_allowed = 64 * K;
#define REG_SP UESP
#define REG_PC EIP
#define REG_FP EBP

13
hotspot/src/share/vm/gc/g1/g1CollectionSet.cpp
View File

@ -32,6 +32,7 @@
#include "gc/g1/heapRegionSet.hpp"
#include "logging/logStream.hpp"
#include "utilities/debug.hpp"
#include "utilities/quickSort.hpp"
G1CollectorState* G1CollectionSet::collector_state() {
return _g1->collector_state();
@ -396,6 +397,16 @@ double G1CollectionSet::finalize_young_part(double target_pause_time_ms, G1Survi
return time_remaining_ms;
}
static int compare_region_idx(const uint a, const uint b) {
if (a > b) {
return 1;
} else if (a == b) {
return 0;
} else {
return -1;
}
}
void G1CollectionSet::finalize_old_part(double time_remaining_ms) {
double non_young_start_time_sec = os::elapsedTime();
double predicted_old_time_ms = 0.0;
@ -493,6 +504,8 @@ void G1CollectionSet::finalize_old_part(double time_remaining_ms) {
double non_young_end_time_sec = os::elapsedTime();
phase_times()->record_non_young_cset_choice_time_ms((non_young_end_time_sec - non_young_start_time_sec) * 1000.0);
QuickSort::sort<uint>(_collection_set_regions, (int)_collection_set_cur_length, compare_region_idx, true);
}
#ifdef ASSERT

3
hotspot/src/share/vm/gc/g1/g1ConcurrentMark.cpp
View File

@ -1904,7 +1904,8 @@ G1ConcurrentMark::claim_region(uint worker_id) {
assert(_g1h->is_in_g1_reserved(finger), "invariant");
HeapRegion* curr_region = _g1h->heap_region_containing(finger);
// Make sure that the reads below do not float before loading curr_region.
OrderAccess::loadload();
// Above heap_region_containing may return NULL as we always scan claim
// until the end of the heap. In this case, just jump to the next region.
HeapWord* end = curr_region != NULL ? curr_region->end() : finger + HeapRegion::GrainWords;

15
hotspot/src/share/vm/gc/g1/g1MarkSweep.cpp
View File

@ -132,9 +132,16 @@ void G1MarkSweep::mark_sweep_phase1(bool& marked_for_unloading,
MarkingCodeBlobClosure follow_code_closure(&GenMarkSweep::follow_root_closure, !CodeBlobToOopClosure::FixRelocations);
{
G1RootProcessor root_processor(g1h, 1);
root_processor.process_strong_roots(&GenMarkSweep::follow_root_closure,
&GenMarkSweep::follow_cld_closure,
&follow_code_closure);
if (ClassUnloading) {
root_processor.process_strong_roots(&GenMarkSweep::follow_root_closure,
&GenMarkSweep::follow_cld_closure,
&follow_code_closure);
} else {
root_processor.process_all_roots_no_string_table(
&GenMarkSweep::follow_root_closure,
&GenMarkSweep::follow_cld_closure,
&follow_code_closure);
}
}
{
@ -157,7 +164,7 @@ void G1MarkSweep::mark_sweep_phase1(bool& marked_for_unloading,
// This is the point where the entire marking should have completed.
assert(GenMarkSweep::_marking_stack.is_empty(), "Marking should have completed");
{
if (ClassUnloading) {
GCTraceTime(Debug, gc, phases) trace("Class Unloading", gc_timer());
// Unload classes and purge the SystemDictionary.

45
hotspot/src/share/vm/gc/g1/g1RootProcessor.cpp
View File

@ -83,6 +83,7 @@ void G1RootProcessor::evacuate_roots(G1EvacuationRootClosures* closures, uint wo
}
process_vm_roots(closures, phase_times, worker_i);
process_string_table_roots(closures, phase_times, worker_i);
{
// Now the CM ref_processor roots.
@ -191,19 +192,34 @@ public:
void G1RootProcessor::process_all_roots(OopClosure* oops,
CLDClosure* clds,
CodeBlobClosure* blobs) {
CodeBlobClosure* blobs,
bool process_string_table) {
AllRootsClosures closures(oops, clds);
process_java_roots(&closures, NULL, 0);
process_vm_roots(&closures, NULL, 0);
if (!_process_strong_tasks.is_task_claimed(G1RP_PS_CodeCache_oops_do)) {
CodeCache::blobs_do(blobs);
if (process_string_table) {
process_string_table_roots(&closures, NULL, 0);
}
process_code_cache_roots(blobs, NULL, 0);
_process_strong_tasks.all_tasks_completed(n_workers());
}
void G1RootProcessor::process_all_roots(OopClosure* oops,
CLDClosure* clds,
CodeBlobClosure* blobs) {
process_all_roots(oops, clds, blobs, true);
}
void G1RootProcessor::process_all_roots_no_string_table(OopClosure* oops,
CLDClosure* clds,
CodeBlobClosure* blobs) {
assert(!ClassUnloading, "Should only be used when class unloading is disabled");
process_all_roots(oops, clds, blobs, false);
}
void G1RootProcessor::process_java_roots(G1RootClosures* closures,
G1GCPhaseTimes* phase_times,
uint worker_i) {
@ -280,14 +296,23 @@ void G1RootProcessor::process_vm_roots(G1RootClosures* closures,
SystemDictionary::roots_oops_do(strong_roots, weak_roots);
}
}
}
{
G1GCParPhaseTimesTracker x(phase_times, G1GCPhaseTimes::StringTableRoots, worker_i);
// All threads execute the following. A specific chunk of buckets
// from the StringTable are the individual tasks.
if (weak_roots != NULL) {
StringTable::possibly_parallel_oops_do(weak_roots);
}
void G1RootProcessor::process_string_table_roots(G1RootClosures* closures,
G1GCPhaseTimes* phase_times,
uint worker_i) {
assert(closures->weak_oops() != NULL, "Should only be called when all roots are processed");
G1GCParPhaseTimesTracker x(phase_times, G1GCPhaseTimes::StringTableRoots, worker_i);
// All threads execute the following. A specific chunk of buckets
// from the StringTable are the individual tasks.
StringTable::possibly_parallel_oops_do(closures->weak_oops());
}
void G1RootProcessor::process_code_cache_roots(CodeBlobClosure* code_closure,
G1GCPhaseTimes* phase_times,
uint worker_i) {
if (!_process_strong_tasks.is_task_claimed(G1RP_PS_CodeCache_oops_do)) {
CodeCache::blobs_do(code_closure);
}
}

20
hotspot/src/share/vm/gc/g1/g1RootProcessor.hpp
View File

@ -73,6 +73,11 @@ class G1RootProcessor : public StackObj {
void worker_has_discovered_all_strong_classes();
void wait_until_all_strong_classes_discovered();
void process_all_roots(OopClosure* oops,
CLDClosure* clds,
CodeBlobClosure* blobs,
bool process_string_table);
void process_java_roots(G1RootClosures* closures,
G1GCPhaseTimes* phase_times,
uint worker_i);
@ -81,6 +86,14 @@ class G1RootProcessor : public StackObj {
G1GCPhaseTimes* phase_times,
uint worker_i);
void process_string_table_roots(G1RootClosures* closures,
G1GCPhaseTimes* phase_times,
uint worker_i);
void process_code_cache_roots(CodeBlobClosure* code_closure,
G1GCPhaseTimes* phase_times,
uint worker_i);
public:
G1RootProcessor(G1CollectedHeap* g1h, uint n_workers);
@ -99,6 +112,13 @@ public:
CLDClosure* clds,
CodeBlobClosure* blobs);
// Apply oops, clds and blobs to strongly and weakly reachable roots in the system,
// the only thing different from process_all_roots is that we skip the string table
// to avoid keeping every string live when doing class unloading.
void process_all_roots_no_string_table(OopClosure* oops,
CLDClosure* clds,
CodeBlobClosure* blobs);
// Number of worker threads used by the root processor.
uint n_workers() const;
};

1
hotspot/src/share/vm/gc/g1/heapRegionManager.cpp
View File

@ -123,6 +123,7 @@ void HeapRegionManager::make_regions_available(uint start, uint num_regions) {
for (uint i = start; i < start + num_regions; i++) {
if (_regions.get_by_index(i) == NULL) {
HeapRegion* new_hr = new_heap_region(i);
OrderAccess::storestore();
_regions.set_by_index(i, new_hr);
_allocated_heapregions_length = MAX2(_allocated_heapregions_length, i + 1);
}

6
hotspot/src/share/vm/gc/shared/gcTrace.cpp
View File

@ -185,8 +185,10 @@ void OldGCTracer::report_concurrent_mode_failure() {
}
#if INCLUDE_ALL_GCS
void G1MMUTracer::report_mmu(double timeSlice, double gcTime, double maxTime) {
send_g1_mmu_event(timeSlice, gcTime, maxTime);
void G1MMUTracer::report_mmu(double time_slice_sec, double gc_time_sec, double max_time_sec) {
send_g1_mmu_event(time_slice_sec * MILLIUNITS,
gc_time_sec * MILLIUNITS,
max_time_sec * MILLIUNITS);
}
void G1NewTracer::report_yc_type(G1YCType type) {

4
hotspot/src/share/vm/gc/shared/gcTrace.hpp
View File

@ -235,10 +235,10 @@ class ParNewTracer : public YoungGCTracer {
#if INCLUDE_ALL_GCS
class G1MMUTracer : public AllStatic {
static void send_g1_mmu_event(double timeSlice, double gcTime, double maxTime);
static void send_g1_mmu_event(double time_slice_ms, double gc_time_ms, double max_time_ms);
public:
static void report_mmu(double timeSlice, double gcTime, double maxTime);
static void report_mmu(double time_slice_sec, double gc_time_sec, double max_time_sec);
};
class G1NewTracer : public YoungGCTracer {

20
hotspot/src/share/vm/gc/shared/gcTraceSend.cpp
View File

@ -200,13 +200,13 @@ void G1NewTracer::send_g1_young_gc_event() {
}
}
void G1MMUTracer::send_g1_mmu_event(double timeSlice, double gcTime, double maxTime) {
void G1MMUTracer::send_g1_mmu_event(double time_slice_ms, double gc_time_ms, double max_time_ms) {
EventG1MMU e;
if (e.should_commit()) {
e.set_gcId(GCId::current());
e.set_timeSlice(timeSlice);
e.set_gcTime(gcTime);
e.set_maxGcTime(maxTime);
e.set_timeSlice(time_slice_ms);
e.set_gcTime(gc_time_ms);
e.set_pauseTarget(max_time_ms);
e.commit();
}
}
@ -281,10 +281,10 @@ void G1NewTracer::send_basic_ihop_statistics(size_t threshold,
evt.set_targetOccupancy(target_occupancy);
evt.set_thresholdPercentage(target_occupancy > 0 ? ((double)threshold / target_occupancy) : 0.0);
evt.set_currentOccupancy(current_occupancy);
evt.set_lastAllocationSize(last_allocation_size);
evt.set_lastAllocationDuration(last_allocation_duration);
evt.set_lastAllocationRate(last_allocation_duration != 0.0 ? last_allocation_size / last_allocation_duration : 0.0);
evt.set_lastMarkingLength(last_marking_length);
evt.set_recentMutatorAllocationSize(last_allocation_size);
evt.set_recentMutatorDuration(last_allocation_duration * MILLIUNITS);
evt.set_recentAllocationRate(last_allocation_duration != 0.0 ? last_allocation_size / last_allocation_duration : 0.0);
evt.set_lastMarkingDuration(last_marking_length * MILLIUNITS);
evt.commit();
}
}
@ -301,11 +301,11 @@ void G1NewTracer::send_adaptive_ihop_statistics(size_t threshold,
evt.set_gcId(GCId::current());
evt.set_threshold(threshold);
evt.set_thresholdPercentage(internal_target_occupancy > 0 ? ((double)threshold / internal_target_occupancy) : 0.0);
evt.set_internalTargetOccupancy(internal_target_occupancy);
evt.set_ihopTargetOccupancy(internal_target_occupancy);
evt.set_currentOccupancy(current_occupancy);
evt.set_additionalBufferSize(additional_buffer_size);
evt.set_predictedAllocationRate(predicted_allocation_rate);
evt.set_predictedMarkingLength(predicted_marking_length);
evt.set_predictedMarkingDuration(predicted_marking_length * MILLIUNITS);
evt.set_predictionActive(prediction_active);
evt.commit();
}

16
hotspot/src/share/vm/prims/whitebox.cpp
View File

@ -894,6 +894,7 @@ static bool GetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, F
}
ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
const char* flag_name = env->GetStringUTFChars(name, NULL);
CHECK_JNI_EXCEPTION_(env, false);
Flag::Error result = (*TAt)(flag_name, value, true, true);
env->ReleaseStringUTFChars(name, flag_name);
return (result == Flag::SUCCESS);
@ -906,6 +907,7 @@ static bool SetVMFlag(JavaThread* thread, JNIEnv* env, jstring name, T* value, F
}
ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
const char* flag_name = env->GetStringUTFChars(name, NULL);
CHECK_JNI_EXCEPTION_(env, false);
Flag::Error result = (*TAtPut)(flag_name, value, Flag::INTERNAL);
env->ReleaseStringUTFChars(name, flag_name);
return (result == Flag::SUCCESS);
@ -944,6 +946,7 @@ static jobject doubleBox(JavaThread* thread, JNIEnv* env, jdouble value) {
static Flag* getVMFlag(JavaThread* thread, JNIEnv* env, jstring name) {
ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
const char* flag_name = env->GetStringUTFChars(name, NULL);
CHECK_JNI_EXCEPTION_(env, NULL);
Flag* result = Flag::find_flag(flag_name, strlen(flag_name), true, true);
env->ReleaseStringUTFChars(name, flag_name);
return result;
@ -1084,7 +1087,14 @@ WB_END
WB_ENTRY(void, WB_SetStringVMFlag(JNIEnv* env, jobject o, jstring name, jstring value))
ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
const char* ccstrValue = (value == NULL) ? NULL : env->GetStringUTFChars(value, NULL);
const char* ccstrValue;
if (value == NULL) {
ccstrValue = NULL;
}
else {
ccstrValue = env->GetStringUTFChars(value, NULL);
CHECK_JNI_EXCEPTION(env);
}
ccstr ccstrResult = ccstrValue;
bool needFree;
{
@ -1308,6 +1318,7 @@ WB_ENTRY(jobjectArray, WB_GetCodeHeapEntries(JNIEnv* env, jobject o, jint blob_t
jclass clazz = env->FindClass(vmSymbols::java_lang_Object()->as_C_string());
CHECK_JNI_EXCEPTION_(env, NULL);
result = env->NewObjectArray(blobs.length(), clazz, NULL);
CHECK_JNI_EXCEPTION_(env, NULL);
if (result == NULL) {
return result;
}
@ -1317,6 +1328,7 @@ WB_ENTRY(jobjectArray, WB_GetCodeHeapEntries(JNIEnv* env, jobject o, jint blob_t
jobjectArray obj = codeBlob2objectArray(thread, env, *it);
CHECK_JNI_EXCEPTION_(env, NULL);
env->SetObjectArrayElement(result, i, obj);
CHECK_JNI_EXCEPTION_(env, NULL);
++i;
}
return result;
@ -1523,6 +1535,7 @@ static bool GetMethodOption(JavaThread* thread, JNIEnv* env, jobject method, jst
// can't be in VM when we call JNI
ThreadToNativeFromVM ttnfv(thread);
const char* flag_name = env->GetStringUTFChars(name, NULL);
CHECK_JNI_EXCEPTION_(env, false);
bool result = CompilerOracle::has_option_value(mh, flag_name, *value);
env->ReleaseStringUTFChars(name, flag_name);
return result;
@ -1678,6 +1691,7 @@ WB_ENTRY(jint, WB_AddCompilerDirective(JNIEnv* env, jobject o, jstring compDirec
// can't be in VM when we call JNI
ThreadToNativeFromVM ttnfv(thread);
const char* dir = env->GetStringUTFChars(compDirect, NULL);
CHECK_JNI_EXCEPTION_(env, 0);
int ret;
{
ThreadInVMfromNative ttvfn(thread); // back to VM

15
hotspot/src/share/vm/prims/whitebox.hpp
View File

@ -33,9 +33,22 @@
#include "oops/symbol.hpp"
#include "runtime/interfaceSupport.hpp"
// Unconditionally clear pedantic pending JNI checks
class ClearPendingJniExcCheck : public StackObj {
private:
JavaThread* _thread;
public:
ClearPendingJniExcCheck(JNIEnv* env) : _thread(JavaThread::thread_from_jni_environment(env)) {}
~ClearPendingJniExcCheck() {
_thread->clear_pending_jni_exception_check();
}
};
// Entry macro to transition from JNI to VM state.
#define WB_ENTRY(result_type, header) JNI_ENTRY(result_type, header)
#define WB_ENTRY(result_type, header) JNI_ENTRY(result_type, header) \
ClearPendingJniExcCheck _clearCheck(env);
#define WB_END JNI_END
#define WB_METHOD_DECLARE(result_type) extern "C" result_type JNICALL

58
hotspot/src/share/vm/runtime/arguments.cpp
View File

@ -1308,35 +1308,13 @@ bool Arguments::add_property(const char* prop, PropertyWriteable writeable, Prop
return true;
}
// sets or adds a module name to the jdk.module.addmods property
bool Arguments::append_to_addmods_property(const char* module_name) {
const char* key = "jdk.module.addmods";
const char* old_value = Arguments::get_property(key);
size_t buf_len = strlen(key) + strlen(module_name) + 2;
if (old_value != NULL) {
buf_len += strlen(old_value) + 1;
}
char* new_value = AllocateHeap(buf_len, mtArguments);
if (new_value == NULL) {
return false;
}
if (old_value == NULL) {
jio_snprintf(new_value, buf_len, "%s=%s", key, module_name);
} else {
jio_snprintf(new_value, buf_len, "%s=%s,%s", key, old_value, module_name);
}
bool added = add_property(new_value, UnwriteableProperty, InternalProperty);
FreeHeap(new_value);
return added;
}
#if INCLUDE_CDS
void Arguments::check_unsupported_dumping_properties() {
assert(DumpSharedSpaces, "this function is only used with -Xshare:dump");
const char* unsupported_properties[5] = { "jdk.module.main",
"jdk.module.path",
"jdk.module.upgrade.path",
"jdk.module.addmods",
"jdk.module.addmods.0",
"jdk.module.limitmods" };
const char* unsupported_options[5] = { "-m",
"--module-path",
@ -1687,11 +1665,6 @@ void Arguments::set_cms_and_parnew_gc_flags() {
CompactibleFreeListSpaceLAB::modify_initialization(OldPLABSize, OldPLABWeight);
}
if (!ClassUnloading) {
FLAG_SET_CMDLINE(bool, CMSClassUnloadingEnabled, false);
FLAG_SET_CMDLINE(bool, ExplicitGCInvokesConcurrentAndUnloadsClasses, false);
}
log_trace(gc)("MarkStackSize: %uk MarkStackSizeMax: %uk", (unsigned int) (MarkStackSize / K), (uint) (MarkStackSizeMax / K));
}
#endif // INCLUDE_ALL_GCS
@ -2019,6 +1992,13 @@ void Arguments::set_gc_specific_flags() {
// Keeping the heap 100% free is hard ;-) so limit it to 99%.
FLAG_SET_ERGO(uintx, MinHeapFreeRatio, 99);
}
// If class unloading is disabled, also disable concurrent class unloading.
if (!ClassUnloading) {
FLAG_SET_CMDLINE(bool, CMSClassUnloadingEnabled, false);
FLAG_SET_CMDLINE(bool, ClassUnloadingWithConcurrentMark, false);
FLAG_SET_CMDLINE(bool, ExplicitGCInvokesConcurrentAndUnloadsClasses, false);
}
#endif // INCLUDE_ALL_GCS
}
@ -2566,8 +2546,8 @@ bool Arguments::parse_uintx(const char* value,
unsigned int addreads_count = 0;
unsigned int addexports_count = 0;
unsigned int addmods_count = 0;
unsigned int patch_mod_count = 0;
const char* add_modules_value = NULL;
bool Arguments::create_property(const char* prop_name, const char* prop_value, PropertyInternal internal) {
size_t prop_len = strlen(prop_name) + strlen(prop_value) + 2;
@ -2821,7 +2801,9 @@ jint Arguments::parse_each_vm_init_arg(const JavaVMInitArgs* args, bool* patch_m
return JNI_ENOMEM;
}
} else if (match_option(option, "--add-modules=", &tail)) {
add_modules_value = tail;
if (!create_numbered_property("jdk.module.addmods", tail, addmods_count++)) {
return JNI_ENOMEM;
}
} else if (match_option(option, "--limit-modules=", &tail)) {
if (!create_property("jdk.module.limitmods", tail, InternalProperty)) {
return JNI_ENOMEM;
@ -2873,7 +2855,7 @@ jint Arguments::parse_each_vm_init_arg(const JavaVMInitArgs* args, bool* patch_m
char *options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(tail) + 1, mtArguments), tail);
add_init_agent("instrument", options, false);
// java agents need module java.instrument
if (!Arguments::append_to_addmods_property("java.instrument")) {
if (!create_numbered_property("jdk.module.addmods", "java.instrument", addmods_count++)) {
return JNI_ENOMEM;
}
}
@ -3149,7 +3131,7 @@ jint Arguments::parse_each_vm_init_arg(const JavaVMInitArgs* args, bool* patch_m
return JNI_EINVAL;
}
// management agent in module java.management
if (!Arguments::append_to_addmods_property("java.management")) {
if (!create_numbered_property("jdk.module.addmods", "java.management", addmods_count++)) {
return JNI_ENOMEM;
}
#else
@ -3560,15 +3542,6 @@ jint Arguments::finalize_vm_init_args() {
return JNI_ERR;
}
// Append the value of the last --add-modules option specified on the command line.
// This needs to be done here, to prevent overwriting possible values written
// to the jdk.module.addmods property by -javaagent and other options.
if (add_modules_value != NULL) {
if (!append_to_addmods_property(add_modules_value)) {
return JNI_ENOMEM;
}
}
// This must be done after all arguments have been processed.
// java_compiler() true means set to "NONE" or empty.
if (java_compiler() && !xdebug_mode()) {
@ -3617,7 +3590,8 @@ jint Arguments::finalize_vm_init_args() {
#endif
#if INCLUDE_JVMCI
if (EnableJVMCI && !append_to_addmods_property("jdk.vm.ci")) {
if (EnableJVMCI &&
!create_numbered_property("jdk.module.addmods", "jdk.vm.ci", addmods_count++)) {
return JNI_ENOMEM;
}
#endif

3
hotspot/src/share/vm/runtime/arguments.hpp
View File

@ -489,9 +489,6 @@ class Arguments : AllStatic {
static int process_patch_mod_option(const char* patch_mod_tail, bool* patch_mod_javabase);
// Miscellaneous system property setter
static bool append_to_addmods_property(const char* module_name);
// Aggressive optimization flags.
static jint set_aggressive_opts_flags();

1
hotspot/src/share/vm/runtime/interfaceSupport.hpp
View File

@ -280,6 +280,7 @@ class ThreadToNativeFromVM : public ThreadStateTransition {
~ThreadToNativeFromVM() {
trans_from_native(_thread_in_vm);
assert(!_thread->is_pending_jni_exception_check(), "Pending JNI Exception Check");
// We don't need to clear_walkable because it will happen automagically when we return to java
}
};

2
hotspot/src/share/vm/runtime/os.hpp
View File

@ -443,7 +443,7 @@ class os: AllStatic {
static bool create_thread(Thread* thread,
ThreadType thr_type,
size_t stack_size = 0);
size_t req_stack_size = 0);
static bool create_main_thread(JavaThread* thread);
static bool create_attached_thread(JavaThread* thread);
static void pd_start_thread(Thread* thread);

9
hotspot/src/share/vm/runtime/thread.hpp
View File

@ -1542,6 +1542,9 @@ class JavaThread: public Thread {
static ByteSize jmp_ring_offset() { return byte_offset_of(JavaThread, _jmp_ring); }
#endif // PRODUCT
static ByteSize jni_environment_offset() { return byte_offset_of(JavaThread, _jni_environment); }
static ByteSize pending_jni_exception_check_fn_offset() {
return byte_offset_of(JavaThread, _pending_jni_exception_check_fn);
}
static ByteSize last_Java_sp_offset() {
return byte_offset_of(JavaThread, _anchor) + JavaFrameAnchor::last_Java_sp_offset();
}
@ -1615,7 +1618,11 @@ class JavaThread: public Thread {
assert(_jni_active_critical >= 0, "JNI critical nesting problem?");
}
// Checked JNI, is the programmer required to check for exceptions, specify which function name
// Checked JNI: is the programmer required to check for exceptions, if so specify
// which function name. Returning to a Java frame should implicitly clear the
// pending check, this is done for Native->Java transitions (i.e. user JNI code).
// VM->Java transistions are not cleared, it is expected that JNI code enclosed
// within ThreadToNativeFromVM makes proper exception checks (i.e. VM internal).
bool is_pending_jni_exception_check() const { return _pending_jni_exception_check_fn != NULL; }
void clear_pending_jni_exception_check() { _pending_jni_exception_check_fn = NULL; }
const char* get_pending_jni_exception_check() const { return _pending_jni_exception_check_fn; }

38
hotspot/src/share/vm/trace/traceevents.xml
View File

@ -315,9 +315,9 @@ Declares a structure type that can be used in other events.
<event id="G1MMU" path="vm/gc/detailed/g1_mmu_info" label="G1 MMU Information" is_instant="true">
<value type="UINT" field="gcId" label="GC Identifier" relation="GcId"/>
<value type="DOUBLE" field="timeSlice" label="Time Slice" description="Time slice used to calculate MMU"/>
<value type="DOUBLE" field="gcTime" label="GC Time" description="Time spent on GC during last time slice"/>
<value type="DOUBLE" field="maxGcTime" label="Max GC Time" description="Max time allowed to be spent on GC during last time slice"/>
<value type="MILLIS" field="timeSlice" label="Time Slice" description="Time slice used to calculate MMU"/>
<value type="MILLIS" field="gcTime" label="GC Time" description="Time stopped because of GC during last time slice"/>
<value type="MILLIS" field="pauseTarget" label="Pause Target" description="Max time allowed to be spent on GC during last time slice"/>
</event>
<event id="EvacuationInformation" path="vm/gc/detailed/evacuation_info" label="Evacuation Information" is_instant="true">
@ -377,29 +377,29 @@ Declares a structure type that can be used in other events.
<structvalue type="G1EvacuationStatistics" field="statistics" label="Evacuation Statistics"/>
</event>
<event id="G1BasicIHOP" path="vm/gc/detailed/g1_basic_ihop_status" label="G1 Basic IHOP statistics"
<event id="G1BasicIHOP" path="vm/gc/detailed/g1_basic_ihop_status" label="G1 Basic IHOP Statistics"
is_instant="true" description="Basic statistics related to current IHOP calculation">
<value type="UINT" field="gcId" label="GC Identifier" relation="GcId"/>
<value type="BYTES64" field="threshold" label="Current IHOP threshold" description="Current IHOP threshold in bytes"/>
<value type="PERCENTAGE" field="thresholdPercentage" label="Current IHOP threshold in percent" description="Current IHOP threshold in percent of old gen"/>
<value type="BYTES64" field="targetOccupancy" label="Target Occupancy" description="Target old gen occupancy to reach at the start of mixed GC in bytes"/>
<value type="BYTES64" field="currentOccupancy" label="Current Occupancy" description="Current old generation occupancy in bytes"/>
<value type="BYTES64" field="lastAllocationSize" label="Last Mutator Allocation" description="Mutator allocation during mutator operation since last GC in bytes"/>
<value type="DOUBLE" field="lastAllocationDuration" label="Last Mutator Operation" description="Time the mutator ran since last GC in seconds"/>
<value type="DOUBLE" field="lastAllocationRate" label="Last Mutator Allocation Rate" description="Allocation rate of the mutator since last GC in bytes/second"/>
<value type="DOUBLE" field="lastMarkingLength" label="Last Marking Length" description="Last time from the end of the last initial mark to the first mixed GC in seconds"/>
<value type="BYTES64" field="threshold" label="Current IHOP Threshold" description="Current IHOP threshold"/>
<value type="PERCENTAGE" field="thresholdPercentage" label="Current IHOP Threshold" description="Current IHOP threshold in percent of old generation"/>
<value type="BYTES64" field="targetOccupancy" label="Target Occupancy" description="Target old generation occupancy to reach at the start of mixed GC"/>
<value type="BYTES64" field="currentOccupancy" label="Current Occupancy" description="Current old generation occupancy"/>
<value type="BYTES64" field="recentMutatorAllocationSize" label="Recent Mutator Allocation Size" description="Mutator allocation during mutator operation in the most recent interval"/>
<value type="MILLIS" field="recentMutatorDuration" label="Recent Mutator Duration" description="Time the mutator ran in the most recent interval"/>
<value type="DOUBLE" field="recentAllocationRate" label="Recent Allocation Rate" description="Allocation rate of the mutator in the most recent interval in bytes/second"/>
<value type="MILLIS" field="lastMarkingDuration" label="Last Marking Duration" description="Last time from the end of the last initial mark to the first mixed GC"/>
</event>
<event id="G1AdaptiveIHOP" path="vm/gc/detailed/g1_adaptive_ihop_status" label="G1 Adaptive IHOP statistics"
<event id="G1AdaptiveIHOP" path="vm/gc/detailed/g1_adaptive_ihop_status" label="G1 Adaptive IHOP Statistics"
is_instant="true" description="Statistics related to current adaptive IHOP calculation">
<value type="UINT" field="gcId" label="GC Identifier" relation="GcId"/>
<value type="BYTES64" field="threshold" label="Threshold" description="Current IHOP threshold in bytes"/>
<value type="PERCENTAGE" field="thresholdPercentage" label="Threshold Percentage" description="Current IHOP threshold in percent of the internal target occupancy"/>
<value type="BYTES64" field="internalTargetOccupancy" label="Target Occupancy" description="Internal target old generation occupancy to reach at the start of mixed GC in bytes"/>
<value type="BYTES64" field="currentOccupancy" label="Current Occupancy" description="Current old generation occupancy in bytes"/>
<value type="BYTES64" field="additionalBufferSize" label="Additional Buffer" description="Additional buffer size in bytes"/>
<value type="BYTES64" field="threshold" label="Threshold" description="Current IHOP Threshold"/>
<value type="PERCENTAGE" field="thresholdPercentage" label="Threshold" description="Current IHOP threshold in percent of the internal target occupancy"/>
<value type="BYTES64" field="ihopTargetOccupancy" label="IHOP Target Occupancy" description="Internal target old generation occupancy to reach at the start of mixed GC"/>
<value type="BYTES64" field="currentOccupancy" label="Current Occupancy" description="Current old generation occupancy"/>
<value type="BYTES64" field="additionalBufferSize" label="Additional Buffer" description="Additional buffer size" experimental="true"/>
<value type="DOUBLE" field="predictedAllocationRate" label="Predicted Allocation Rate" description="Current predicted allocation rate for the mutator in bytes/second"/>
<value type="DOUBLE" field="predictedMarkingLength" label="Predicted Marking Length" description="Current predicted time from the end of the last initial mark to the first mixed GC in seconds"/>
<value type="MILLIS" field="predictedMarkingDuration" label="Predicted Marking Duration" description="Current predicted time from the end of the last initial mark to the first mixed GC"/>
<value type="BOOLEAN" field="predictionActive" label="Prediction Active" description="Indicates whether the adaptive IHOP prediction is active"/>
</event>

4
hotspot/src/share/vm/utilities/exceptions.cpp
View File

@ -80,7 +80,7 @@ bool Exceptions::special_exception(Thread* thread, const char* file, int line, H
if (h_exception()->klass() == SystemDictionary::StackOverflowError_klass()) {
InstanceKlass* ik = InstanceKlass::cast(h_exception->klass());
assert(ik->is_initialized(),
"need to increase min_stack_allowed calculation");
"need to increase java_thread_min_stack_allowed calculation");
}
#endif // ASSERT
@ -227,7 +227,7 @@ void Exceptions::throw_stack_overflow_exception(Thread* THREAD, const char* file
Klass* k = SystemDictionary::StackOverflowError_klass();
oop e = InstanceKlass::cast(k)->allocate_instance(CHECK);
exception = Handle(THREAD, e); // fill_in_stack trace does gc
assert(InstanceKlass::cast(k)->is_initialized(), "need to increase min_stack_allowed calculation");
assert(InstanceKlass::cast(k)->is_initialized(), "need to increase java_thread_min_stack_allowed calculation");
if (StackTraceInThrowable) {
java_lang_Throwable::fill_in_stack_trace(exception, method());
}

4
hotspot/test/compiler/cpuflags/AESIntrinsicsBase.java
View File

@ -48,8 +48,8 @@ public abstract class AESIntrinsicsBase extends CommandLineOptionTest {
= {"-XX:+UnlockDiagnosticVMOptions", "-XX:+PrintIntrinsics"};
public static final String[] TEST_AES_CMD
= {"-XX:+IgnoreUnrecognizedVMOptions", "-XX:+PrintFlagsFinal",
"-Xbatch", "-DcheckOutput=true", "-Dmode=CBC",
TestAESMain.class.getName()};
"-Xbatch", "-XX:CompileThresholdScaling=0.01", "-DcheckOutput=true", "-Dmode=CBC",
TestAESMain.class.getName(), "100", "1000"};
protected AESIntrinsicsBase(BooleanSupplier predicate) {
super(predicate);

4
hotspot/test/compiler/cpuflags/TestAESIntrinsicsOnSupportedConfig.java
View File

@ -27,11 +27,11 @@
* @library /test/lib /
* @modules java.base/jdk.internal.misc
* java.management
* @ignore 8146128
* @build sun.hotspot.WhiteBox
* @run driver ClassFileInstaller sun.hotspot.WhiteBox
* sun.hotspot.WhiteBox$WhiteBoxPermission
* @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions
* @run main/othervm/timeout=600 -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions
* -XX:+WhiteBoxAPI -Xbatch
* compiler.cpuflags.TestAESIntrinsicsOnSupportedConfig
*/

118
hotspot/test/gc/class_unloading/TestClassUnloadingDisabled.java Normal file
View File

@ -0,0 +1,118 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reqserved.
* 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
* @key gc
* @bug 8114823
* @requires vm.gc == null
* @requires vm.opt.ExplicitGCInvokesConcurrent != true
* @requires vm.opt.ClassUnloading != true
* @library /test/lib
* @modules java.base/jdk.internal.misc
* java.management
* @build sun.hotspot.WhiteBox
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* sun.hotspot.WhiteBox$WhiteBoxPermission
*
* @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
* -XX:-ClassUnloading -XX:+UseG1GC TestClassUnloadingDisabled
*
* @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
* -XX:-ClassUnloading -XX:+UseSerialGC TestClassUnloadingDisabled
*
* @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
* -XX:-ClassUnloading -XX:+UseParallelGC TestClassUnloadingDisabled
*
* @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
* -XX:-ClassUnloading -XX:+UseConcMarkSweepGC TestClassUnloadingDisabled
*/
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import sun.hotspot.WhiteBox;
import static jdk.test.lib.Asserts.*;
public class TestClassUnloadingDisabled {
public static void main(String args[]) throws Exception {
final WhiteBox wb = WhiteBox.getWhiteBox();
// Fetch the dir where the test class and the class
// to be loaded resides.
String classDir = TestClassUnloadingDisabled.class.getProtectionDomain().getCodeSource().getLocation().getPath();
String className = "ClassToLoadUnload";
assertFalse(wb.isClassAlive(className), "Should not be loaded yet");
// The NoPDClassLoader handles loading classes in the test directory
// and loads them without a protection domain, which in some cases
// keeps the class live regardless of marking state.
NoPDClassLoader nopd = new NoPDClassLoader(classDir);
nopd.loadClass(className);
assertTrue(wb.isClassAlive(className), "Class should be loaded");
// Clear the class-loader, class and object references to make
// class unloading possible.
nopd = null;
System.gc();
assertTrue(wb.isClassAlive(className), "Class should not have ben unloaded");
}
}
class NoPDClassLoader extends ClassLoader {
String path;
NoPDClassLoader(String path) {
this.path = path;
}
public Class<?> loadClass(String name) throws ClassNotFoundException {
byte[] cls = null;
File f = new File(path,name + ".class");
// Delegate class loading if class not present in the given
// directory.
if (!f.exists()) {
return super.loadClass(name);
}
try {
Path path = Paths.get(f.getAbsolutePath());
cls = Files.readAllBytes(path);
} catch (IOException e) {
throw new ClassNotFoundException(name);
}
// Define class with no protection domain and resolve it.
return defineClass(name, cls, 0, cls.length, null);
}
}
class ClassToLoadUnload {
}

16
hotspot/test/runtime/CommandLine/OptionsValidation/TestOptionsWithRanges.java
View File

@ -88,20 +88,6 @@ public class TestOptionsWithRanges {
*/
excludeTestMaxRange("CICompilerCount");
/*
* JDK-8136766
* Temporarily remove ThreadStackSize from testing because Windows can set it to 0
* (for default OS size) but other platforms insist it must be greater than 0
*/
excludeTestRange("ThreadStackSize");
/*
* Remove the flag controlling the size of the stack because the
* flag has direct influence on the physical memory usage of
* the VM.
*/
allOptionsAsMap.remove("CompilerThreadStackSize");
/*
* Exclude MallocMaxTestWords as it is expected to exit VM at small values (>=0)
*/
@ -124,6 +110,8 @@ public class TestOptionsWithRanges {
excludeTestMaxRange("OldSize");
excludeTestMaxRange("ParallelGCThreads");
excludeTestMaxRange("CompilerThreadStackSize");
excludeTestMaxRange("ThreadStackSize");
excludeTestMaxRange("VMThreadStackSize");
/*

99
hotspot/test/runtime/LocalLong/LocalLongHelper.java Normal file
View File

@ -0,0 +1,99 @@
/*
* Copyright (c) 2016, 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.
*/
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.lang.StackWalker.StackFrame;
public class LocalLongHelper {
static StackWalker sw;
static Method intValue;
static Method getLocals;
static Class<?> primitiveValueClass;
static Method primitiveType;
static Method getMethodType;
static Field memberName;
static Field offset;
public static void main(String[] args) throws Throwable {
setupReflectionStatics();
new LocalLongHelper().longArg(0xC0FFEE, 0x1234567890ABCDEFL);
}
// locals[2] contains the high byte of the long argument.
public long longArg(int i, long l) throws Throwable {
List<StackFrame> frames = sw.walk(s -> s.collect(Collectors.toList()));
Object[] locals = (Object[]) getLocals.invoke(frames.get(0));
int locals_2 = (int) intValue.invoke(locals[2]);
if (locals_2 != 0){
throw new RuntimeException("Expected locals_2 == 0");
}
return l; // Don't want l to become a dead var
}
private static void setupReflectionStatics() throws Throwable {
Class<?> liveStackFrameClass = Class.forName("java.lang.LiveStackFrame");
primitiveValueClass = Class.forName("java.lang.LiveStackFrame$PrimitiveValue");
getLocals = liveStackFrameClass.getDeclaredMethod("getLocals");
getLocals.setAccessible(true);
intValue = primitiveValueClass.getDeclaredMethod("intValue");
intValue.setAccessible(true);
Class<?> stackFrameInfoClass = Class.forName("java.lang.StackFrameInfo");
memberName = stackFrameInfoClass.getDeclaredField("memberName");
memberName.setAccessible(true);
offset = stackFrameInfoClass.getDeclaredField("bci");
offset.setAccessible(true);
getMethodType = Class.forName("java.lang.invoke.MemberName").getDeclaredMethod("getMethodType");
getMethodType.setAccessible(true);
Class<?> extendedOptionClass = Class.forName("java.lang.StackWalker$ExtendedOption");
Method ewsNI = StackWalker.class.getDeclaredMethod("newInstance", Set.class, extendedOptionClass);
ewsNI.setAccessible(true);
Field f = extendedOptionClass.getDeclaredField("LOCALS_AND_OPERANDS");
f.setAccessible(true);
Object localsAndOperandsOption = f.get(null);
primitiveType = primitiveValueClass.getDeclaredMethod("type");
primitiveType.setAccessible(true);
sw = (StackWalker) ewsNI.invoke(null, java.util.Collections.emptySet(), localsAndOperandsOption);
}
private static String type(Object o) throws Throwable {
if (primitiveValueClass.isInstance(o)) {
final char c = (char) primitiveType.invoke(o);
return String.valueOf(c);
} else if (o != null) {
return o.getClass().getName();
} else {
return "null";
}
}
}

47
hotspot/test/runtime/LocalLong/LocalLongTest.java Normal file
View File

@ -0,0 +1,47 @@
/*
* Copyright (c) 2016, 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 LocalLongTest
* @bug 8163014
* @modules java.base/jdk.internal.misc
* @library /test/lib
* @compile LocalLongHelper.java
* @run driver LocalLongTest
*/
import jdk.test.lib.Platform;
import jdk.test.lib.process.ProcessTools;
import jdk.test.lib.process.OutputAnalyzer;
public class LocalLongTest {
public static void main(String... args) throws Exception {
if (Platform.is64bit()) {
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder("-Xint",
"LocalLongHelper");
OutputAnalyzer o = new OutputAnalyzer(pb.start());
o.shouldHaveExitValue(0);
}
};
}

198
hotspot/test/runtime/Thread/TooSmallStackSize.java Normal file
View File

@ -0,0 +1,198 @@
/*
* Copyright (c) 2016, 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 8140520
* @summary Setting small CompilerThreadStackSize, ThreadStackSize, and
* VMThreadStackSize values should result in an error message that shows
* the minimum stack size value for each thread type.
* @library /test/lib
* @modules java.base/jdk.internal.misc
* java.management
* @run main TooSmallStackSize
*/
/*
* The primary purpose of this test is to make sure we can run with a
* stack smaller than the minimum without crashing. Also this test will
* determine the minimum allowed stack size for the platform (as
* provided by the JVM error message when a very small stack is used),
* and then verify that the JVM can be launched with that stack size
* without a crash or any error messages.
*
* Note: The '-Xss<size>' and '-XX:ThreadStackSize=<k-bytes>' options
* both control Java thread stack size. This repo's version of the test
* exercises the '-XX:ThreadStackSize' VM option. The jdk repo's version
* of the test exercises the '-Xss' option.
*/
import jdk.test.lib.process.ProcessTools;
import jdk.test.lib.process.OutputAnalyzer;
public class TooSmallStackSize {
/* for debugging. Normally false. */
static final boolean verbose = false;
static final String CompilerThreadStackSizeString = "CompilerThreadStackSize";
static final String ThreadStackSizeString = "Java thread stack size";
static final String VMThreadStackSizeString = "VMThreadStackSize";
/*
* Returns the minimum stack size this platform will allowed based on the
* contents of the error message the JVM outputs when too small of a
* stack size was used.
*
* The testOutput argument must contain the result of having already run
* the JVM with too small of a stack size.
*/
static String getMinStackAllowed(String testOutput) {
/*
* The JVM output will contain in one of the lines:
* "The CompilerThreadStackSize specified is too small. Specify at least 100k"
* "The Java thread stack size specified is too small. Specify at least 100k"
* "The VMThreadStackSize specified is too small. Specify at least 100k"
* Although the actual size will vary. We need to extract this size
* string from the output and return it.
*/
String matchStr = "Specify at least ";
int match_idx = testOutput.indexOf(matchStr);
if (match_idx >= 0) {
int size_start_idx = match_idx + matchStr.length();
int k_start_idx = testOutput.indexOf("k", size_start_idx);
// don't include the 'k'; the caller will have to
// add it back as needed.
return testOutput.substring(size_start_idx, k_start_idx);
}
System.out.println("Expect='" + matchStr + "'");
System.out.println("Actual: " + testOutput);
System.out.println("FAILED: Could not get the stack size from the output");
throw new RuntimeException("test fails");
}
/*
* Run the JVM with the specified stack size.
*
* Returns the minimum allowed stack size gleaned from the error message,
* if there is an error message. Otherwise returns the stack size passed in.
*/
static String checkStack(String stackOption, String optionMesg, String stackSize) throws Exception {
String min_stack_allowed;
System.out.println("*** Testing " + stackOption + stackSize);
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
stackOption + stackSize,
// Uncomment the following to get log output
// that shows actual thread creation sizes.
// "-Xlog:os+thread",
"-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
if (verbose) {
System.out.println("stdout: " + output.getStdout());
}
if (output.getExitValue() == 0) {
// checkMinStackAllowed() is called with stackSize values
// that should be the minimum that works. This method,
// checkStack(), is called with stackSize values that
// should be too small and result in error messages.
// However, some platforms fix up a stackSize value that is
// too small into something that works so we have to allow
// for checkStack() calls that work.
System.out.println("PASSED: got exit_code == 0 with " + stackOption + stackSize);
min_stack_allowed = stackSize;
} else {
String expect = "The " + optionMesg + " specified is too small";
if (verbose) {
System.out.println("Expect='" + expect + "'");
}
output.shouldContain(expect);
min_stack_allowed = getMinStackAllowed(output.getStdout());
System.out.println("PASSED: got expected error message with " + stackOption + stackSize);
}
return min_stack_allowed;
}
/*
* Run the JVM with the minimum allowed stack size. This should always succeed.
*/
static void checkMinStackAllowed(String stackOption, String optionMesg, String stackSize) throws Exception {
System.out.println("*** Testing " + stackOption + stackSize);
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
stackOption + stackSize,
// Uncomment the following to get log output
// that shows actual thread creation sizes.
// "-Xlog:os+thread",
"-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0);
System.out.println("PASSED: VM launched with " + stackOption + stackSize);
}
public static void main(String... args) throws Exception {
/*
* The result of a 16k stack size should be a quick exit with a complaint
* that the stack size is too small. However, for some win32 builds, the
* stack is always at least 64k, and this also sometimes is the minimum
* allowed size, so we won't see an error in this case.
*
* This test case will also produce a crash on some platforms if the fix
* for 6762191 is not yet in place.
*/
checkStack("-XX:ThreadStackSize=", ThreadStackSizeString, "16");
/*
* Try with a 32k stack size, which is the size that the launcher will
* set to if you try setting to anything smaller. This should produce the same
* result as setting to 16k if the fix for 6762191 is in place.
*/
String min_stack_allowed = checkStack("-XX:ThreadStackSize=", ThreadStackSizeString, "32");
/*
* Try again with a the minimum stack size that was given in the error message
*/
checkMinStackAllowed("-XX:ThreadStackSize=", ThreadStackSizeString, min_stack_allowed);
/*
* Now redo the same tests with the compiler thread stack size:
*/
checkStack("-XX:CompilerThreadStackSize=", CompilerThreadStackSizeString, "16");
min_stack_allowed = checkStack("-XX:CompilerThreadStackSize=", CompilerThreadStackSizeString, "32");
checkMinStackAllowed("-XX:CompilerThreadStackSize=", CompilerThreadStackSizeString, min_stack_allowed);
/*
* Now redo the same tests with the VM thread stack size:
*/
checkStack("-XX:VMThreadStackSize=", VMThreadStackSizeString, "16");
min_stack_allowed = checkStack("-XX:VMThreadStackSize=", VMThreadStackSizeString, "32");
checkMinStackAllowed("-XX:VMThreadStackSize=", VMThreadStackSizeString, min_stack_allowed);
}
}

209
hotspot/test/runtime/jni/checked/TestCheckedJniExceptionCheck.java Normal file
View File

@ -0,0 +1,209 @@
/*
* Copyright (c) 2016, 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 8164086
* @summary regression tests for 8164086, verify correct warning from checked JNI
* @library /test/lib
* @modules java.management
* @run main/native TestCheckedJniExceptionCheck launch
*/
import java.util.List;
import jdk.test.lib.process.ProcessTools;
import jdk.test.lib.process.OutputAnalyzer;
public class TestCheckedJniExceptionCheck {
static {
System.loadLibrary("TestCheckedJniExceptionCheck");
}
int callableMethodInvokeCount = 0;
static final String TEST_START = "TEST STARTED";
static final String EXPECT_WARNING_START = "EXPECT_WARNING_START";
static final String EXPECT_WARNING_END = "EXPECT_WARNING_END";
static final String JNI_CHECK_EXCEPTION = "WARNING in native method: JNI call made without checking exceptions when required to from";
static void printExpectWarningStart(int count) {
System.out.println(EXPECT_WARNING_START + " " + count);
}
static void printExpectWarningEnd() {
System.out.println(EXPECT_WARNING_END);
}
public TestCheckedJniExceptionCheck() {
initMethodIds("callableMethod", "()V",
"callableNestedMethod", "(IZ)V");
System.out.println(TEST_START);
}
public void test() {
testSingleCallNoCheck();
testSingleCallCheck();
testSingleCallNoCheckMultipleTimes();
testMultipleCallsNoCheck();
testMultipleCallsCheck();
testNestedSingleCallsNoCheck();
testNestedSingleCallsCheck();
testNestedMultipleCallsNoCheck();
testNestedMultipleCallsCheck();
}
public void testSingleCallNoCheck() {
System.out.println("testSingleCallNoCheck start");
callJavaFromNative(1, false);
System.out.println("testSingleCallNoCheck end");
}
public void testSingleCallCheck() {
System.out.println("testSingleCallCheck start");
callJavaFromNative(1, true);
System.out.println("testSingleCallCheck end");
}
public void testSingleCallNoCheckMultipleTimes() {
System.out.println("testSingleCallNoCheckMultipleTimes start");
callJavaFromNative(1, false);
callJavaFromNative(1, false);
System.out.println("testSingleCallNoCheckMultipleTimes end");
}
public void testMultipleCallsNoCheck() {
System.out.println("testMultipleCallsNoCheck start");
printExpectWarningStart(1);
callJavaFromNative(2, false);
printExpectWarningEnd();
System.out.println("testMultipleCallsNoCheck end");
}
public void testMultipleCallsCheck() {
System.out.println("testMultipleCallsCheck start");
callJavaFromNative(2, true);
System.out.println("testMultipleCallsCheck end");
}
public void testNestedSingleCallsNoCheck() {
System.out.println("testNestedSingleCallsNoCheck start");
callNestedJavaFromNative(1, false);
System.out.println("testNestedSingleCallsNoCheck end");
}
public void testNestedSingleCallsCheck() {
System.out.println("testNestedSingleCallsCheck start");
callNestedJavaFromNative(1, true);
System.out.println("testNestedSingleCallsCheck end");
}
public void testNestedMultipleCallsNoCheck() {
System.out.println("testNestedMultipleCallsNoCheck start");
printExpectWarningStart(3);
callNestedJavaFromNative(2, false);
printExpectWarningEnd();
System.out.println("testNestedMultipleCallsNoCheck end");
}
public void testNestedMultipleCallsCheck() {
System.out.println("testNestedMultipleCallsCheck start");
callNestedJavaFromNative(2, true);
System.out.println("testNestedMultipleCallsCheck end");
}
public void callableMethod() {
callableMethodInvokeCount++;
}
public void callableNestedMethod(int nofCalls, boolean withExceptionChecks) {
callJavaFromNative(nofCalls, withExceptionChecks);
}
public native void callJavaFromNative(int nofCalls, boolean withExceptionChecks);
public native void callNestedJavaFromNative(int nofCalls, boolean withExceptionChecks);
private native void initMethodIds(String callableMethodName,
String callableMethodSig,
String callableNestedMethodName,
String callableNestedMethodSig);
// Check warnings appear where they should, with start/end statements in output...
static void checkOuputForCorrectWarnings(OutputAnalyzer oa) throws RuntimeException {
List<String> lines = oa.asLines();
int expectedWarnings = 0;
int warningCount = 0;
int lineNo = 0;
boolean testStartLine = false;
for (String line : lines) {
lineNo++;
if (!testStartLine) { // Skip any warning before the actual test itself
testStartLine = line.startsWith(TEST_START);
continue;
}
if (line.startsWith(JNI_CHECK_EXCEPTION)) {
if (expectedWarnings == 0) {
oa.reportDiagnosticSummary();
throw new RuntimeException("Unexpected warning at line " + lineNo);
}
warningCount++;
if (warningCount > expectedWarnings) {
oa.reportDiagnosticSummary();
throw new RuntimeException("Unexpected warning at line " + lineNo);
}
}
else if (line.startsWith(EXPECT_WARNING_START)) {
String countStr = line.substring(EXPECT_WARNING_START.length() + 1);
expectedWarnings = Integer.parseInt(countStr);
}
else if (line.startsWith(EXPECT_WARNING_END)) {
if (warningCount != expectedWarnings) {
oa.reportDiagnosticSummary();
throw new RuntimeException("Missing warning at line " + lineNo);
}
warningCount = 0;
expectedWarnings = 0;
}
}
/*
System.out.println("Output looks good...");
oa.reportDiagnosticSummary();
*/
}
public static void main(String[] args) throws Throwable {
if (args == null || args.length == 0) {
new TestCheckedJniExceptionCheck().test();
return;
}
// launch and check output
checkOuputForCorrectWarnings(ProcessTools.executeTestJvm("-Xcheck:jni",
"TestCheckedJniExceptionCheck"));
}
}

98
hotspot/test/runtime/jni/checked/libTestCheckedJniExceptionCheck.c Normal file
View File

@ -0,0 +1,98 @@
/*
* Copyright (c) 2016, 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.
*/
#include <jni.h>
static jmethodID _callable_method_id;
static jmethodID _callable_nested_method_id;
static void check_exceptions(JNIEnv *env) {
if ((*env)->ExceptionCheck(env)) {
(*env)->ExceptionDescribe(env);
(*env)->FatalError(env, "Unexpected Exception");
}
}
static jmethodID get_method_id(JNIEnv *env, jclass clz, jstring jname, jstring jsig) {
jmethodID mid;
const char *name, *sig;
name = (*env)->GetStringUTFChars(env, jname, NULL);
check_exceptions(env);
sig = (*env)->GetStringUTFChars(env, jsig, NULL);
check_exceptions(env);
mid = (*env)->GetMethodID(env, clz, name, sig);
check_exceptions(env);
(*env)->ReleaseStringUTFChars(env, jname, name);
(*env)->ReleaseStringUTFChars(env, jsig, sig);
return mid;
}
JNIEXPORT void JNICALL
Java_TestCheckedJniExceptionCheck_initMethodIds(JNIEnv *env,
jobject obj,
jstring callable_method_name,
jstring callable_method_sig,
jstring callable_nested_method_name,
jstring callable_nested_method_sig) {
jclass clz = (*env)->GetObjectClass(env, obj);
_callable_method_id = get_method_id(env, clz,
callable_method_name,
callable_method_sig);
_callable_nested_method_id = get_method_id(env, clz,
callable_nested_method_name,
callable_nested_method_sig);
}
JNIEXPORT void JNICALL
Java_TestCheckedJniExceptionCheck_callJavaFromNative(JNIEnv *env,
jobject obj,
jint nofCalls,
jboolean checkExceptions) {
int i;
for (i = 0; i < nofCalls; i++) {
(*env)->CallVoidMethod(env, obj, _callable_method_id);
if (checkExceptions == JNI_TRUE) {
check_exceptions(env);
}
}
}
JNIEXPORT void JNICALL
Java_TestCheckedJniExceptionCheck_callNestedJavaFromNative(JNIEnv *env,
jobject obj,
jint nofCalls,
jboolean checkExceptions) {
int i;
for (i = 0; i < nofCalls; i++) {
(*env)->CallVoidMethod(env, obj, _callable_nested_method_id, nofCalls, checkExceptions);
if (checkExceptions == JNI_TRUE) {
check_exceptions(env);
}
}
}

14
hotspot/test/runtime/modules/ModuleOptionsTest.java
View File

@ -24,8 +24,8 @@
/*
* @test
* @bug 8136930
* @summary Test that the VM only recognizes the last specified --add-modules
* and --list-modules options
* @summary Test that the VM only recognizes the last specified --list-modules
* options but accumulates --add-module values.
* @modules java.base/jdk.internal.misc
* @library /test/lib
*/
@ -38,14 +38,16 @@ public class ModuleOptionsTest {
public static void main(String[] args) throws Exception {
// Test that last --add-modules is the only one recognized. No exception
// should be thrown.
// Test that multiple --add-modules options are cumulative, not last one wins.
// An exception should be thrown because module i_dont_exist doesn't exist.
ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(
"--add-modules=i_dont_exist", "--add-modules=java.base", "-version");
OutputAnalyzer output = new OutputAnalyzer(pb.start());
output.shouldHaveExitValue(0);
output.shouldContain("ResolutionException");
output.shouldContain("i_dont_exist");
output.shouldHaveExitValue(1);
// Test that last --limit-modules is the only one recognized. No exception
// Test that the last --limit-modules is the only one recognized. No exception
// should be thrown.
pb = ProcessTools.createJavaProcessBuilder(
"--limit-modules=i_dont_exist", "--limit-modules=java.base", "-version");

2
jaxp/.hgtags
View File

@ -376,3 +376,5 @@ e66cdc2de6b02443911d386fc9217b0d824d0686 jdk-9+130
874082a9b565a7092a40bfa934a6e3e3c3455a60 jdk-9+131
907445d85e680ea410fe2c83c0ec64b5508e4f3e jdk-9+132
9490ba2e5e41685c858a0ca2a6ec87611eb011c6 jdk-9+133
1c6c21d87aa459d82425e1fddc9ce8647aebde34 jdk-9+134
f695240370c77a25fed88225a392e7d530cb4d78 jdk-9+135

23
jaxp/src/java.xml/share/classes/com/sun/org/apache/xalan/internal/xsltc/compiler/TransletOutput.java
View File

@ -1,13 +1,14 @@
/*
* reserved comment block
* DO NOT REMOVE OR ALTER!
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
*/
/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
@ -17,9 +18,6 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* $Id: TransletOutput.java,v 1.2.4.1 2005/09/05 09:19:44 pvedula Exp $
*/
package com.sun.org.apache.xalan.internal.xsltc.compiler;
@ -35,6 +33,7 @@ import com.sun.org.apache.xalan.internal.xsltc.compiler.util.StringType;
import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Type;
import com.sun.org.apache.xalan.internal.xsltc.compiler.util.TypeCheckError;
import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Util;
import jdk.xml.internal.JdkXmlFeatures;
/**
* @author Morten Jorgensen
@ -103,8 +102,10 @@ final class TransletOutput extends Instruction {
final InstructionList il = methodGen.getInstructionList();
final boolean isSecureProcessing = classGen.getParser().getXSLTC()
.isSecureProcessing();
final boolean isExtensionFunctionEnabled = classGen.getParser().getXSLTC()
.getFeature(JdkXmlFeatures.XmlFeature.ENABLE_EXTENSION_FUNCTION);
if (isSecureProcessing) {
if (isSecureProcessing && !isExtensionFunctionEnabled) {
int index = cpg.addMethodref(BASIS_LIBRARY_CLASS,
"unallowed_extension_elementF",
"(Ljava/lang/String;)V");

9
jaxp/src/java.xml/share/classes/com/sun/org/apache/xalan/internal/xsltc/runtime/AbstractTranslet.java
View File

@ -111,6 +111,9 @@ public abstract class AbstractTranslet implements Translet {
private boolean _useServicesMechanism;
// The OutputStream for redirect function
private FileOutputStream output = null;
/**
* protocols allowed for external references set by the stylesheet processing instruction, Document() function, Import and Include element.
*/
@ -567,9 +570,10 @@ public abstract class AbstractTranslet implements Translet {
dir.mkdirs();
}
output = new FileOutputStream(filename, append);
factory.setEncoding(_encoding);
factory.setOutputMethod(_method);
factory.setOutputStream(new BufferedOutputStream(new FileOutputStream(filename, append)));
factory.setOutputStream(new BufferedOutputStream(output));
factory.setOutputType(TransletOutputHandlerFactory.STREAM);
final SerializationHandler handler
@ -594,6 +598,9 @@ public abstract class AbstractTranslet implements Translet {
try {
handler.endDocument();
handler.close();
if (output != null) {
output.close();
}
}
catch (Exception e) {
// what can you do?

54
jaxp/src/java.xml/share/classes/javax/xml/catalog/CatalogImpl.java
View File

@ -31,6 +31,7 @@ import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
@ -72,9 +73,6 @@ class CatalogImpl extends GroupEntry implements Catalog {
//System Id for this catalog
String systemId;
//The parent
CatalogImpl parent = null;
/*
A list of catalog entry files from the input, excluding the current catalog.
Paths in the List are normalized.
@ -107,7 +105,7 @@ class CatalogImpl extends GroupEntry implements Catalog {
* catalog file.
*/
public CatalogImpl(CatalogImpl parent, CatalogFeatures f, String... file) throws CatalogException {
super(CatalogEntryType.CATALOG);
super(CatalogEntryType.CATALOG, parent);
if (f == null) {
throw new NullPointerException(
formatMessage(CatalogMessages.ERR_NULL_ARGUMENT, new Object[]{"CatalogFeatures"}));
@ -117,7 +115,7 @@ class CatalogImpl extends GroupEntry implements Catalog {
CatalogMessages.reportNPEOnNull("The path to the catalog file", file[0]);
}
init(parent, f);
init(f);
//Path of catalog files
String[] catalogFile = file;
@ -159,19 +157,34 @@ class CatalogImpl extends GroupEntry implements Catalog {
}
}
}
if (systemId != null) {
parse(systemId);
}
}
}
private void init(CatalogImpl parent, CatalogFeatures f) {
this.parent = parent;
/**
* Loads the catalog
*/
void load() {
if (systemId != null) {
parse(systemId);
}
//save this catalog before loading the next
loadedCatalogs.put(systemId, this);
//Load delegate and alternative catalogs if defer is false.
if (!isDeferred()) {
loadDelegateCatalogs();
loadNextCatalogs();
}
}
private void init(CatalogFeatures f) {
if (parent == null) {
level = 0;
} else {
level = parent.level + 1;
this.loadedCatalogs = parent.loadedCatalogs;
this.catalogsSearched = parent.catalogsSearched;
}
if (f == null) {
this.features = CatalogFeatures.defaults();
@ -196,11 +209,6 @@ class CatalogImpl extends GroupEntry implements Catalog {
entries.stream().filter((entry) -> (entry.type == CatalogEntryType.GROUP)).forEach((entry) -> {
((GroupEntry) entry).reset();
});
if (parent != null) {
this.loadedCatalogs = parent.loadedCatalogs;
this.catalogsSearched = parent.catalogsSearched;
}
}
/**
@ -421,16 +429,16 @@ class CatalogImpl extends GroupEntry implements Catalog {
void loadNextCatalogs() {
//loads catalogs specified in nextCatalogs
if (nextCatalogs != null) {
for (NextCatalog next : nextCatalogs) {
nextCatalogs.stream().forEach((next) -> {
getCatalog(next.getCatalogURI());
}
});
}
//loads catalogs from the input list
if (inputFiles != null) {
for (String file : inputFiles) {
inputFiles.stream().forEach((file) -> {
getCatalog(getSystemId(file));
}
});
}
}
@ -445,14 +453,14 @@ class CatalogImpl extends GroupEntry implements Catalog {
return null;
}
Catalog c = null;
CatalogImpl c = null;
String path = uri.toASCIIString();
if (verifyCatalogFile(uri)) {
c = getLoadedCatalog(path);
if (c == null) {
c = new CatalogImpl(this, features, path);
saveLoadedCatalog(path, c);
c.load();
}
}
return c;
@ -464,7 +472,7 @@ class CatalogImpl extends GroupEntry implements Catalog {
* @param catalogId the catalogId associated with the Catalog object
* @param c the Catalog to be saved
*/
void saveLoadedCatalog(String catalogId, Catalog c) {
void saveLoadedCatalog(String catalogId, CatalogImpl c) {
loadedCatalogs.put(catalogId, c);
}

4
jaxp/src/java.xml/share/classes/javax/xml/catalog/CatalogManager.java
View File

@ -62,7 +62,9 @@ public final class CatalogManager {
* @throws CatalogException If an error occurs while parsing the catalog
*/
public static Catalog catalog(CatalogFeatures features, String... paths) {
return new CatalogImpl(features, paths);
CatalogImpl catalog = new CatalogImpl(features, paths);
catalog.load();
return catalog;
}
/**

9
jaxp/src/java.xml/share/classes/javax/xml/catalog/CatalogReader.java
View File

@ -259,15 +259,6 @@ class CatalogReader extends DefaultHandler implements EntityResolver, URIResolve
CatalogEntryType type = CatalogEntryType.getType(localName);
if (type == CatalogEntryType.GROUP) {
inGroup = false;
} else if (type == CatalogEntryType.CATALOGENTRY) {
/*
Done reading the catalog file.
Load delegate and alternative catalogs if defer is false.
*/
if (!catalog.isDeferred()) {
catalog.loadDelegateCatalogs();
catalog.loadNextCatalogs();
}
}
}

4
jaxp/src/java.xml/share/classes/javax/xml/catalog/CatalogResolverImpl.java
View File

@ -119,6 +119,10 @@ final class CatalogResolverImpl implements CatalogResolver {
String result = null;
CatalogImpl c = (CatalogImpl)catalog;
String uri = Normalizer.normalizeURI(href);
if (uri == null) {
return null;
}
//check whether uri is an urn
if (uri != null && uri.startsWith(Util.URN)) {
String publicId = Normalizer.decodeURN(uri);

37
jaxp/src/java.xml/share/classes/javax/xml/catalog/GroupEntry.java
View File

@ -48,6 +48,9 @@ class GroupEntry extends BaseEntry {
//Value of the prefer attribute
boolean isPreferPublic = true;
//The parent of the catalog instance
CatalogImpl parent = null;
//The catalog instance this group belongs to
CatalogImpl catalog;
@ -55,10 +58,10 @@ class GroupEntry extends BaseEntry {
List<BaseEntry> entries = new ArrayList<>();
//loaded delegated catalog by system id
Map<String, Catalog> delegateCatalogs = new HashMap<>();
Map<String, CatalogImpl> delegateCatalogs = new HashMap<>();
//A list of all loaded Catalogs, including this, and next catalogs
Map<String, Catalog> loadedCatalogs = new HashMap<>();
Map<String, CatalogImpl> loadedCatalogs = new HashMap<>();
/*
A list of Catalog Ids that have already been searched in a matching
@ -136,8 +139,9 @@ class GroupEntry extends BaseEntry {
*
* @param type The type of the entry
*/
public GroupEntry(CatalogEntryType type) {
public GroupEntry(CatalogEntryType type, CatalogImpl parent) {
super(type);
this.parent = parent;
}
/**
@ -163,7 +167,7 @@ class GroupEntry extends BaseEntry {
}
/**
* Constructs a group entry.
* @param catalog The parent catalog
* @param catalog The catalog this GroupEntry belongs
* @param base The baseURI attribute
* @param attributes The attributes
*/
@ -445,13 +449,14 @@ class GroupEntry extends BaseEntry {
* @param catalogId the catalog Id
*/
Catalog loadCatalog(URI catalogURI) {
Catalog delegateCatalog = null;
CatalogImpl delegateCatalog = null;
if (catalogURI != null) {
String catalogId = catalogURI.toASCIIString();
delegateCatalog = getLoadedCatalog(catalogId);
if (delegateCatalog == null) {
if (verifyCatalogFile(catalogURI)) {
delegateCatalog = new CatalogImpl(catalog, features, catalogId);
delegateCatalog.load();
delegateCatalogs.put(catalogId, delegateCatalog);
}
}
@ -467,8 +472,8 @@ class GroupEntry extends BaseEntry {
* @return a Catalog object previously loaded, or null if none in the saved
* list
*/
Catalog getLoadedCatalog(String catalogId) {
Catalog c = null;
CatalogImpl getLoadedCatalog(String catalogId) {
CatalogImpl c = null;
//checl delegate Catalogs
c = delegateCatalogs.get(catalogId);
@ -504,7 +509,7 @@ class GroupEntry extends BaseEntry {
}
String catalogId = catalogURI.toASCIIString();
if (catalogsSearched.contains(catalogId)) {
if (catalogsSearched.contains(catalogId) || isCircular(catalogId)) {
CatalogMessages.reportRunTimeError(CatalogMessages.ERR_CIRCULAR_REFERENCE,
new Object[]{CatalogMessages.sanitize(catalogId)});
}
@ -512,4 +517,20 @@ class GroupEntry extends BaseEntry {
return true;
}
/**
* Checks whether the catalog is circularly referenced
* @param systemId the system identifier of the catalog to be loaded
* @return true if is circular, false otherwise
*/
boolean isCircular(String systemId) {
if (parent == null) {
return false;
}
if (parent.systemId.equals(systemId)) {
return true;
}
return parent.isCircular(systemId);
}
}

1
jaxp/src/java.xml/share/classes/javax/xml/datatype/XMLGregorianCalendar.java
View File

@ -1072,4 +1072,3 @@ public abstract class XMLGregorianCalendar
@Override
public abstract Object clone();
}

40
jaxp/src/java.xml/share/classes/jdk/xml/internal/JdkXmlFeatures.java
View File

@ -42,6 +42,9 @@ public class JdkXmlFeatures {
ORACLE_JAXP_PROPERTY_PREFIX + "enableExtensionFunctions";
public static final String SP_ENABLE_EXTENSION_FUNCTION =
"javax.xml.enableExtensionFunctions";
// This is the correct name by the spec
public static final String SP_ENABLE_EXTENSION_FUNCTION_SPEC =
"jdk.xml.enableExtensionFunctions";
public static final String CATALOG_FEATURES = "javax.xml.catalog.catalogFeatures";
public final static String PROPERTY_USE_CATALOG = XMLConstants.USE_CATALOG;
@ -49,11 +52,11 @@ public class JdkXmlFeatures {
public static enum XmlFeature {
/**
* Feature enableExtensionFunctions
* FSP: extension function is enforced by FSP. When FSP is on, entension
* FSP: extension function is enforced by FSP. When FSP is on, extension
* function is disabled.
*/
ENABLE_EXTENSION_FUNCTION(ORACLE_ENABLE_EXTENSION_FUNCTION,
SP_ENABLE_EXTENSION_FUNCTION, true, false, true, true),
SP_ENABLE_EXTENSION_FUNCTION_SPEC, true, false, true, true),
/**
* The {@link javax.xml.XMLConstants.USE_CATALOG} feature.
* FSP: USE_CATALOG is not enforced by FSP.
@ -148,6 +151,30 @@ public class JdkXmlFeatures {
}
/**
* Maps old property names with the new ones. This map is used to keep track of
* name changes so that old or incorrect names continue to be supported for compatibility.
*/
public static enum NameMap {
ENABLE_EXTENSION_FUNCTION(SP_ENABLE_EXTENSION_FUNCTION_SPEC, SP_ENABLE_EXTENSION_FUNCTION);
final String newName;
final String oldName;
NameMap(String newName, String oldName) {
this.newName = newName;
this.oldName = oldName;
}
String getOldName(String newName) {
if (newName.equals(this.newName)) {
return oldName;
}
return null;
}
}
/**
* States of the settings of a property, in the order: default value, value
* set by FEATURE_SECURE_PROCESSING, jaxp.properties file, jaxp system
@ -316,6 +343,15 @@ public class JdkXmlFeatures {
private void readSystemProperties() {
for (XmlFeature feature : XmlFeature.values()) {
getSystemProperty(feature, feature.systemProperty());
if (!getSystemProperty(feature, feature.systemProperty())) {
//if system property is not found, try the older form if any
for (NameMap nameMap : NameMap.values()) {
String oldName = nameMap.getOldName(feature.systemProperty());
if (oldName != null) {
getSystemProperty(feature, oldName);
}
}
}
}
}

1
jaxp/src/java.xml/share/classes/module-info.java
View File

@ -92,4 +92,3 @@ module java.xml {
uses javax.xml.xpath.XPathFactory;
uses org.xml.sax.XMLReader;
}

1
jaxp/src/jdk.xml.dom/share/classes/module-info.java
View File

@ -30,4 +30,3 @@ module jdk.xml.dom {
exports org.w3c.dom.stylesheets;
exports org.w3c.dom.xpath;
}

4
jaxp/test/ProblemList.txt
View File

@ -24,7 +24,3 @@
###########################################################################
javax/xml/jaxp/isolatedjdk/catalog/PropertiesTest.sh 8147431 generic-all
javax/xml/jaxp/unittest/common/TransformationWarningsTest.java 8150145 generic-all
javax/xml/jaxp/unittest/common/ValidationWarningsTest.java 8150145 generic-all

8
jaxp/test/javax/xml/jaxp/functional/catalog/DeferFeatureTest.java
View File

@ -64,12 +64,12 @@ public class DeferFeatureTest {
public Object[][] data() {
return new Object[][]{
// By default, alternative catalogs are not loaded.
{createCatalog(CatalogFeatures.defaults()), 0},
{createCatalog(CatalogFeatures.defaults()), 1},
// Alternative catalogs are not loaded when DEFER is set to true.
{createCatalog(createDeferFeature(DEFER_TRUE)), 0},
// The 3 alternative catalogs are not pre-loaded
{createCatalog(createDeferFeature(DEFER_TRUE)), 1},
// The 3 alternative catalogs are pre-loaded along with the parent
//when DEFER is set to false.
{createCatalog(createDeferFeature(DEFER_FALSE)), 3}};
{createCatalog(createDeferFeature(DEFER_FALSE)), 4}};
}
private CatalogFeatures createDeferFeature(String defer) {

1
jaxp/test/javax/xml/jaxp/functional/javax/xml/datatype/ptests/DurationTest.java
View File

@ -587,4 +587,3 @@ public class DurationTest {
private final BigInteger one = BigInteger.ONE;
}

1
jaxp/test/javax/xml/jaxp/functional/javax/xml/datatype/ptests/FactoryNewInstanceTest.java
View File

@ -77,4 +77,3 @@ public class FactoryNewInstanceTest {
}
}

1
jaxp/test/javax/xml/jaxp/functional/javax/xml/datatype/ptests/XMLGregorianCalendarTest.java
View File

@ -358,4 +358,3 @@ public class XMLGregorianCalendarTest {
private final int undef = DatatypeConstants.FIELD_UNDEFINED;
}

2
jaxp/test/javax/xml/jaxp/functional/javax/xml/parsers/ptests/DBFNamespaceTest.java
View File

@ -105,5 +105,3 @@ public class DBFNamespaceTest {
}
}
}

2
jaxp/test/javax/xml/jaxp/functional/javax/xml/parsers/ptests/DocumentBuilderFactoryTest.java
View File

@ -531,5 +531,3 @@ public class DocumentBuilderFactoryTest {
assertTrue(compareWithGold(goldFile, outputFile));
}
}

2
jaxp/test/javax/xml/jaxp/functional/javax/xml/parsers/ptests/DocumentBuilderImpl01.java
View File

@ -157,5 +157,3 @@ public class DocumentBuilderImpl01 implements EntityResolver {
return null;
}
}

2
jaxp/test/javax/xml/jaxp/functional/javax/xml/parsers/ptests/FactoryConfErrorTest.java
View File

@ -86,5 +86,3 @@ public class FactoryConfErrorTest {
DocumentBuilderFactory.newInstance();
}
}

2
jaxp/test/javax/xml/jaxp/functional/javax/xml/parsers/ptests/SAXFactoryNewInstanceTest.java
View File

@ -78,5 +78,3 @@ public class SAXFactoryNewInstanceTest {
}
}

2
jaxp/test/javax/xml/jaxp/functional/javax/xml/parsers/ptests/SAXParserFactTest.java
View File

@ -229,5 +229,3 @@ public class SAXParserFactTest {
assertFalse(spf.getFeature(EXTERNAL_P_ENTITIES));
}
}

2
jaxp/test/javax/xml/jaxp/functional/javax/xml/parsers/ptests/SAXParserTest.java
View File

@ -502,5 +502,3 @@ public class SAXParserTest {
}
}
}

Some files were not shown because too many files have changed in this diff Show More