# HG changeset patch # User acorn # Date 1286984806 14400 # Node ID 75b0735b4d04ecc835544d7f7322a2f7c164f2d9 # Parent c77b5c592eabad07ef2b71e9e72cdb3a16f04436# Parent 0715f0cf171d3ef573cd75a098b15825ed6ccec3 Merge diff -r 0715f0cf171d -r 75b0735b4d04 src/cpu/sparc/vm/globals_sparc.hpp --- a/src/cpu/sparc/vm/globals_sparc.hpp Fri Oct 08 09:29:09 2010 -0700 +++ b/src/cpu/sparc/vm/globals_sparc.hpp Wed Oct 13 11:46:46 2010 -0400 @@ -62,3 +62,5 @@ define_pd_global(bool, RewriteBytecodes, true); define_pd_global(bool, RewriteFrequentPairs, true); + +define_pd_global(bool, UseMembar, false); diff -r 0715f0cf171d -r 75b0735b4d04 src/cpu/x86/vm/globals_x86.hpp --- a/src/cpu/x86/vm/globals_x86.hpp Fri Oct 08 09:29:09 2010 -0700 +++ b/src/cpu/x86/vm/globals_x86.hpp Wed Oct 13 11:46:46 2010 -0400 @@ -63,3 +63,5 @@ define_pd_global(bool, RewriteBytecodes, true); define_pd_global(bool, RewriteFrequentPairs, true); + +define_pd_global(bool, UseMembar, false); diff -r 0715f0cf171d -r 75b0735b4d04 src/cpu/x86/vm/methodHandles_x86.cpp diff -r 0715f0cf171d -r 75b0735b4d04 src/cpu/zero/vm/globals_zero.hpp --- a/src/cpu/zero/vm/globals_zero.hpp Fri Oct 08 09:29:09 2010 -0700 +++ b/src/cpu/zero/vm/globals_zero.hpp Wed Oct 13 11:46:46 2010 -0400 @@ -45,3 +45,5 @@ define_pd_global(bool, RewriteBytecodes, true); define_pd_global(bool, RewriteFrequentPairs, true); + +define_pd_global(bool, UseMembar, false); diff -r 0715f0cf171d -r 75b0735b4d04 src/os/linux/vm/attachListener_linux.cpp --- a/src/os/linux/vm/attachListener_linux.cpp Fri Oct 08 09:29:09 2010 -0700 +++ b/src/os/linux/vm/attachListener_linux.cpp Wed Oct 13 11:46:46 2010 -0400 @@ -176,10 +176,10 @@ int n = snprintf(path, UNIX_PATH_MAX, "%s/.java_pid%d", os::get_temp_directory(), os::current_process_id()); - if (n <= (int)UNIX_PATH_MAX) { + if (n < (int)UNIX_PATH_MAX) { n = snprintf(initial_path, UNIX_PATH_MAX, "%s.tmp", path); } - if (n > (int)UNIX_PATH_MAX) { + if (n >= (int)UNIX_PATH_MAX) { return -1; } diff -r 0715f0cf171d -r 75b0735b4d04 src/os/linux/vm/os_linux.cpp --- a/src/os/linux/vm/os_linux.cpp Fri Oct 08 09:29:09 2010 -0700 +++ b/src/os/linux/vm/os_linux.cpp Wed Oct 13 11:46:46 2010 -0400 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1999, 2009, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 2010, 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 @@ -827,8 +827,10 @@ 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(); + // 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) { @@ -3922,12 +3924,21 @@ 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 a page for compiler2 recursion in main thread. + // Add in 2*BytesPerWord times page size 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, + (size_t)(StackYellowPages+StackRedPages+StackShadowPages+ + 2*BytesPerWord COMPILER2_PRESENT(+1)) * Linux::page_size()); + size_t threadStackSizeInBytes = ThreadStackSize * K; if (threadStackSizeInBytes != 0 && - threadStackSizeInBytes < Linux::min_stack_allowed) { + threadStackSizeInBytes < os::Linux::min_stack_allowed) { tty->print_cr("\nThe stack size specified is too small, " "Specify at least %dk", - Linux::min_stack_allowed / K); + os::Linux::min_stack_allowed/ K); return JNI_ERR; } @@ -4839,7 +4850,7 @@ // Next, demultiplex/decode time arguments timespec absTime; - if (time < 0) { // don't wait at all + if (time < 0 || (isAbsolute && time == 0) ) { // don't wait at all return; } if (time > 0) { diff -r 0715f0cf171d -r 75b0735b4d04 src/os/solaris/vm/os_solaris.cpp --- a/src/os/solaris/vm/os_solaris.cpp Fri Oct 08 09:29:09 2010 -0700 +++ b/src/os/solaris/vm/os_solaris.cpp Wed Oct 13 11:46:46 2010 -0400 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2009, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2010, 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 @@ -4878,18 +4878,17 @@ // Check minimum allowable stack size for thread creation and to initialize // the java system classes, including StackOverflowError - depends on page // size. Add a page for compiler2 recursion in main thread. - // Add in BytesPerWord times page size to account for VM stack during + // Add in 2*BytesPerWord times page size to account for VM stack during // class initialization depending on 32 or 64 bit VM. - guarantee((Solaris::min_stack_allowed >= - (StackYellowPages+StackRedPages+StackShadowPages+BytesPerWord - COMPILER2_PRESENT(+1)) * page_size), - "need to increase Solaris::min_stack_allowed on this platform"); + os::Solaris::min_stack_allowed = MAX2(os::Solaris::min_stack_allowed, + (size_t)(StackYellowPages+StackRedPages+StackShadowPages+ + 2*BytesPerWord COMPILER2_PRESENT(+1)) * page_size); size_t threadStackSizeInBytes = ThreadStackSize * K; if (threadStackSizeInBytes != 0 && - threadStackSizeInBytes < Solaris::min_stack_allowed) { + threadStackSizeInBytes < os::Solaris::min_stack_allowed) { tty->print_cr("\nThe stack size specified is too small, Specify at least %dk", - Solaris::min_stack_allowed/K); + os::Solaris::min_stack_allowed/K); return JNI_ERR; } @@ -5837,7 +5836,7 @@ // First, demultiplex/decode time arguments timespec absTime; - if (time < 0) { // don't wait at all + if (time < 0 || (isAbsolute && time == 0) ) { // don't wait at all return; } if (time > 0) { diff -r 0715f0cf171d -r 75b0735b4d04 src/os/windows/vm/os_windows.cpp --- a/src/os/windows/vm/os_windows.cpp Fri Oct 08 09:29:09 2010 -0700 +++ b/src/os/windows/vm/os_windows.cpp Wed Oct 13 11:46:46 2010 -0400 @@ -3311,7 +3311,6 @@ } } - // this is called _after_ the global arguments have been parsed jint os::init_2(void) { // Allocate a single page and mark it as readable for safepoint polling @@ -3390,6 +3389,21 @@ actual_reserve_size = default_reserve_size; } + // Check minimum allowable stack size for thread creation and to initialize + // the java system classes, including StackOverflowError - depends on page + // size. Add a page for compiler2 recursion in main thread. + // Add in 2*BytesPerWord times page size to account for VM stack during + // class initialization depending on 32 or 64 bit VM. + size_t min_stack_allowed = + (size_t)(StackYellowPages+StackRedPages+StackShadowPages+ + 2*BytesPerWord COMPILER2_PRESENT(+1)) * os::vm_page_size(); + if (actual_reserve_size < min_stack_allowed) { + tty->print_cr("\nThe stack size specified is too small, " + "Specify at least %dk", + min_stack_allowed / K); + return JNI_ERR; + } + JavaThread::set_stack_size_at_create(stack_commit_size); // Calculate theoretical max. size of Threads to guard gainst artifical @@ -3992,7 +4006,7 @@ if (time < 0) { // don't wait return; } - else if (time == 0) { + else if (time == 0 && !isAbsolute) { time = INFINITE; } else if (isAbsolute) { diff -r 0715f0cf171d -r 75b0735b4d04 src/share/vm/includeDB_core --- a/src/share/vm/includeDB_core Fri Oct 08 09:29:09 2010 -0700 +++ b/src/share/vm/includeDB_core Wed Oct 13 11:46:46 2010 -0400 @@ -3231,6 +3231,7 @@ orderAccess.hpp os.hpp orderAccess_.inline.hpp orderAccess.hpp +orderAccess_.inline.hpp vm_version_.hpp os.cpp allocation.inline.hpp os.cpp arguments.hpp diff -r 0715f0cf171d -r 75b0735b4d04 src/share/vm/runtime/arguments.cpp --- a/src/share/vm/runtime/arguments.cpp Fri Oct 08 09:29:09 2010 -0700 +++ b/src/share/vm/runtime/arguments.cpp Wed Oct 13 11:46:46 2010 -0400 @@ -119,11 +119,8 @@ PropertyList_add(&_system_properties, new SystemProperty("java.vm.specification.version", "1.0", false)); PropertyList_add(&_system_properties, new SystemProperty("java.vm.specification.name", "Java Virtual Machine Specification", false)); - PropertyList_add(&_system_properties, new SystemProperty("java.vm.specification.vendor", - JDK_Version::is_gte_jdk17x_version() ? "Oracle Corporation" : "Sun Microsystems Inc.", false)); PropertyList_add(&_system_properties, new SystemProperty("java.vm.version", VM_Version::vm_release(), false)); PropertyList_add(&_system_properties, new SystemProperty("java.vm.name", VM_Version::vm_name(), false)); - PropertyList_add(&_system_properties, new SystemProperty("java.vm.vendor", VM_Version::vm_vendor(), false)); PropertyList_add(&_system_properties, new SystemProperty("java.vm.info", VM_Version::vm_info_string(), true)); // following are JVMTI agent writeable properties. @@ -151,6 +148,14 @@ os::init_system_properties_values(); } + + // Update/Initialize System properties after JDK version number is known +void Arguments::init_version_specific_system_properties() { + PropertyList_add(&_system_properties, new SystemProperty("java.vm.specification.vendor", + JDK_Version::is_gte_jdk17x_version() ? "Oracle Corporation" : "Sun Microsystems Inc.", false)); + PropertyList_add(&_system_properties, new SystemProperty("java.vm.vendor", VM_Version::vm_vendor(), false)); +} + /** * Provide a slightly more user-friendly way of eliminating -XX flags. * When a flag is eliminated, it can be added to this list in order to @@ -1676,7 +1681,8 @@ bool status = true; status = status && verify_min_value(StackYellowPages, 1, "StackYellowPages"); status = status && verify_min_value(StackRedPages, 1, "StackRedPages"); - status = status && verify_min_value(StackShadowPages, 1, "StackShadowPages"); + // greater stack shadow pages can't generate instruction to bang stack + status = status && verify_interval(StackShadowPages, 1, 50, "StackShadowPages"); return status; } diff -r 0715f0cf171d -r 75b0735b4d04 src/share/vm/runtime/arguments.hpp --- a/src/share/vm/runtime/arguments.hpp Fri Oct 08 09:29:09 2010 -0700 +++ b/src/share/vm/runtime/arguments.hpp Wed Oct 13 11:46:46 2010 -0400 @@ -484,6 +484,9 @@ // System properties static void init_system_properties(); + // Update/Initialize System properties after JDK version number is known + static void init_version_specific_system_properties(); + // Property List manipulation static void PropertyList_add(SystemProperty** plist, SystemProperty *element); static void PropertyList_add(SystemProperty** plist, const char* k, char* v); diff -r 0715f0cf171d -r 75b0735b4d04 src/share/vm/runtime/globals.hpp --- a/src/share/vm/runtime/globals.hpp Fri Oct 08 09:29:09 2010 -0700 +++ b/src/share/vm/runtime/globals.hpp Wed Oct 13 11:46:46 2010 -0400 @@ -327,10 +327,10 @@ /* UseMembar is theoretically a temp flag used for memory barrier \ * removal testing. It was supposed to be removed before FCS but has \ * been re-added (see 6401008) */ \ - product(bool, UseMembar, false, \ + product_pd(bool, UseMembar, \ "(Unstable) Issues membars on thread state transitions") \ \ - /* Temporary: See 6948537 */ \ + /* Temporary: See 6948537 */ \ experimental(bool, UseMemSetInBOT, true, \ "(Unstable) uses memset in BOT updates in GC code") \ \ @@ -822,6 +822,9 @@ develop(bool, PrintJVMWarnings, false, \ "Prints warnings for unimplemented JVM functions") \ \ + product(bool, PrintWarnings, true, \ + "Prints JVM warnings to output stream") \ + \ notproduct(uintx, WarnOnStalledSpinLock, 0, \ "Prints warnings for stalled SpinLocks") \ \ diff -r 0715f0cf171d -r 75b0735b4d04 src/share/vm/runtime/sharedRuntime.cpp --- a/src/share/vm/runtime/sharedRuntime.cpp Fri Oct 08 09:29:09 2010 -0700 +++ b/src/share/vm/runtime/sharedRuntime.cpp Wed Oct 13 11:46:46 2010 -0400 @@ -302,6 +302,9 @@ return (f <= (double)0.0) ? (double)0.0 - f : f; } +#endif + +#if defined(__SOFTFP__) || defined(PPC) double SharedRuntime::dsqrt(double f) { return sqrt(f); } diff -r 0715f0cf171d -r 75b0735b4d04 src/share/vm/runtime/sharedRuntime.hpp --- a/src/share/vm/runtime/sharedRuntime.hpp Fri Oct 08 09:29:09 2010 -0700 +++ b/src/share/vm/runtime/sharedRuntime.hpp Wed Oct 13 11:46:46 2010 -0400 @@ -116,6 +116,9 @@ #if defined(__SOFTFP__) || defined(E500V2) static double dabs(double f); +#endif + +#if defined(__SOFTFP__) || defined(PPC) static double dsqrt(double f); #endif diff -r 0715f0cf171d -r 75b0735b4d04 src/share/vm/runtime/thread.cpp --- a/src/share/vm/runtime/thread.cpp Fri Oct 08 09:29:09 2010 -0700 +++ b/src/share/vm/runtime/thread.cpp Wed Oct 13 11:46:46 2010 -0400 @@ -2921,6 +2921,9 @@ // So that JDK version can be used as a discrimintor when parsing arguments JDK_Version_init(); + // Update/Initialize System properties after JDK version number is known + Arguments::init_version_specific_system_properties(); + // Parse arguments jint parse_result = Arguments::parse(args); if (parse_result != JNI_OK) return parse_result; diff -r 0715f0cf171d -r 75b0735b4d04 src/share/vm/utilities/debug.cpp --- a/src/share/vm/utilities/debug.cpp Fri Oct 08 09:29:09 2010 -0700 +++ b/src/share/vm/utilities/debug.cpp Wed Oct 13 11:46:46 2010 -0400 @@ -51,14 +51,16 @@ void warning(const char* format, ...) { - // In case error happens before init or during shutdown - if (tty == NULL) ostream_init(); + if (PrintWarnings) { + // In case error happens before init or during shutdown + if (tty == NULL) ostream_init(); - tty->print("%s warning: ", VM_Version::vm_name()); - va_list ap; - va_start(ap, format); - tty->vprint_cr(format, ap); - va_end(ap); + tty->print("%s warning: ", VM_Version::vm_name()); + va_list ap; + va_start(ap, format); + tty->vprint_cr(format, ap); + va_end(ap); + } if (BreakAtWarning) BREAKPOINT; } diff -r 0715f0cf171d -r 75b0735b4d04 src/share/vm/utilities/exceptions.cpp --- a/src/share/vm/utilities/exceptions.cpp Fri Oct 08 09:29:09 2010 -0700 +++ b/src/share/vm/utilities/exceptions.cpp Wed Oct 13 11:46:46 2010 -0400 @@ -61,6 +61,18 @@ ShouldNotReachHere(); } +#ifdef ASSERT + // Check for trying to throw stack overflow before initialization is complete + // to prevent infinite recursion trying to initialize stack overflow without + // adequate stack space. + // This can happen with stress testing a large value of StackShadowPages + 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"); + } +#endif // ASSERT + if (thread->is_VM_thread() || thread->is_Compiler_thread() ) { // We do not care what kind of exception we get for the vm-thread or a thread which @@ -91,7 +103,6 @@ thread->set_pending_exception(Universe::vm_exception(), file, line); return true; } - return false; } @@ -193,6 +204,7 @@ klassOop 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"); if (StackTraceInThrowable) { java_lang_Throwable::fill_in_stack_trace(exception); }