changeset 770:f5ee65f94d9a

Merge
author ohair
date Fri, 15 May 2009 13:41:04 -0700
parents 116b019a3961 aa0c48844632
children a77eddcd510c
files make/jprt.config make/linux/makefiles/gcc.make make/linux/makefiles/jsig.make make/linux/makefiles/saproc.make
diffstat 30 files changed, 349 insertions(+), 556 deletions(-) [+]
line wrap: on
line diff
--- a/.hgtags	Fri May 08 14:33:58 2009 -0700
+++ b/.hgtags	Fri May 15 13:41:04 2009 -0700
@@ -32,3 +32,5 @@
 f8e839c086152da70d6ec5913ba6f9f509282e8d jdk7-b55
 a3fd9e40ff2e854f6169eb6d09d491a28634d04f jdk7-b56
 f4cbf78110c726919f46b59a3b054c54c7e889b4 jdk7-b57
+53d9bf689e80fcc76b221bbe6c5d58e08b80cbc6 jdk7-b58
+c55be0c7bd32c016c52218eb4c8b5da8a75450b5 jdk7-b59
--- a/agent/src/os/linux/Makefile	Fri May 08 14:33:58 2009 -0700
+++ b/agent/src/os/linux/Makefile	Fri May 15 13:41:04 2009 -0700
@@ -60,6 +60,14 @@
   LFLAGS_LIBSA = -Xlinker --version-script=mapfile
 endif
 
+# If this is a --hash-style=gnu system, use --hash-style=both
+#   The gnu .hash section won't work on some Linux systems like SuSE 10.
+_HAS_HASH_STYLE_GNU:=$(shell $(CC) -dumpspecs | grep -- '--hash-style=gnu')
+ifneq ($(_HAS_HASH_STYLE_GNU),)
+  LDFLAGS_HASH_STYLE = -Wl,--hash-style=both
+endif
+LFLAGS_LIBSA += $(LDFLAGS_HASH_STYLE)
+
 $(LIBSA): $(OBJS) mapfile
 	if [ ! -d $(ARCH) ] ; then mkdir $(ARCH) ; fi
 	$(GCC) -shared $(LFLAGS_LIBSA) -o $(LIBSA) $(OBJS) $(LIBS)
--- a/agent/src/share/classes/sun/jvm/hotspot/HotSpotTypeDataBase.java	Fri May 08 14:33:58 2009 -0700
+++ b/agent/src/share/classes/sun/jvm/hotspot/HotSpotTypeDataBase.java	Fri May 15 13:41:04 2009 -0700
@@ -306,8 +306,6 @@
 
       entryAddr = entryAddr.addOffsetTo(intConstantEntryArrayStride);
     } while (nameAddr != null);
-      String symbol = "heapOopSize"; // global int constant and value is initialized at runtime.
-      addIntConstant(symbol, (int)lookupInProcess(symbol).getCIntegerAt(0, 4, false));
   }
 
   private void readVMLongConstants() {
--- a/agent/src/share/classes/sun/jvm/hotspot/runtime/VM.java	Fri May 08 14:33:58 2009 -0700
+++ b/agent/src/share/classes/sun/jvm/hotspot/runtime/VM.java	Fri May 15 13:41:04 2009 -0700
@@ -318,11 +318,17 @@
     logMinObjAlignmentInBytes = db.lookupIntConstant("LogMinObjAlignmentInBytes").intValue();
     heapWordSize = db.lookupIntConstant("HeapWordSize").intValue();
     oopSize  = db.lookupIntConstant("oopSize").intValue();
-    heapOopSize  = db.lookupIntConstant("heapOopSize").intValue();
 
     intxType = db.lookupType("intx");
     uintxType = db.lookupType("uintx");
     boolType = (CIntegerType) db.lookupType("bool");
+
+    if (isCompressedOopsEnabled()) {
+      // Size info for oops within java objects is fixed
+      heapOopSize = (int)getIntSize();
+    } else {
+      heapOopSize = (int)getOopSize();
+    }
   }
 
   /** This could be used by a reflective runtime system */
@@ -343,13 +349,12 @@
     }
     soleInstance = new VM(db, debugger, debugger.getMachineDescription().isBigEndian());
 
-    debugger.putHeapConst(soleInstance.getHeapOopSize(), Universe.getNarrowOopBase(),
-                          Universe.getNarrowOopShift());
-
     for (Iterator iter = vmInitializedObservers.iterator(); iter.hasNext(); ) {
       ((Observer) iter.next()).update(null, null);
     }
 
+    debugger.putHeapConst(soleInstance.getHeapOopSize(), Universe.getNarrowOopBase(),
+                          Universe.getNarrowOopShift());
   }
 
   /** This is used by the debugging system */
--- a/make/hotspot_version	Fri May 08 14:33:58 2009 -0700
+++ b/make/hotspot_version	Fri May 15 13:41:04 2009 -0700
@@ -35,7 +35,7 @@
 
 HS_MAJOR_VER=16
 HS_MINOR_VER=0
-HS_BUILD_NUMBER=02
+HS_BUILD_NUMBER=03
 
 JDK_MAJOR_VER=1
 JDK_MINOR_VER=7
--- a/make/jprt.config	Fri May 08 14:33:58 2009 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,275 +0,0 @@
-#!echo "This is not a shell script"
-#
-# Copyright 2006-2008 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
-# CA 95054 USA or visit www.sun.com if you need additional information or
-# have any questions.
-#  
-#
-
-#############################################################################
-# Error
-error() # message
-{
-  echo "ERROR: $1"
-  exit 6
-}
-# Directory must exist
-dirMustExist() # dir name
-{
-  if [ ! -d "$1" ] ; then
-    error "Directory for $2 does not exist: $1"
-  fi
-}
-# File must exist
-fileMustExist() # dir name
-{
-  if [ ! -f "$1" ] ; then
-    error "File for $2 does not exist: $1"
-  fi
-}
-#############################################################################
-
-# Should be set by JPRT as the 3 basic inputs
-bootdir="${ALT_BOOTDIR}"
-slashjava="${ALT_SLASH_JAVA}"
-jdk_import="${ALT_JDK_IMPORT_PATH}"
-
-# Check input
-dirMustExist "${bootdir}"    ALT_BOOTDIR
-dirMustExist "${slashjava}"  ALT_SLASH_JAVA
-dirMustExist "${jdk_import}" ALT_JDK_IMPORT_PATH
-
-# Uses 'uname -s', but only expect SunOS or Linux, assume Windows otherwise.
-osname=`uname -s`
-if [ "${osname}" = SunOS ] ; then
-   
-    # SOLARIS: Sparc or X86
-    osarch=`uname -p`
-    if [ "${osarch}" = sparc ] ; then
-	solaris_arch=sparc
-    else
-	solaris_arch=i386
-    fi
-
-    if [ "${JPRT_SOLARIS_COMPILER_NAME}" != "" ] ; then
-        compiler_name=${JPRT_SOLARIS_COMPILER_NAME}
-    else
-        if [ "${JPRT_JOB_PRODUCT_RELEASE}" = "jdk6"      -o \
-             "${JPRT_JOB_PRODUCT_RELEASE}" = "jdk6u10"   -o \
-             "${JPRT_JOB_PRODUCT_RELEASE}" = "jdk6u14"   -o \
-             "${JPRT_JOB_PRODUCT_RELEASE}" = "jdk6perf" ] ; then
-            # All jdk6 builds use SS11
-            compiler_name=SS11
-        else
-	    compiler_name=SS12
-        fi
-    fi
-    
-    # Get into path (make sure it matches ALT setting)
-    compiler_path=${slashjava}/devtools/${solaris_arch}/SUNWspro/${compiler_name}/bin
-    dirMustExist "${compiler_path}" COMPILER_PATH
-    path4sdk=${compiler_path}
-
-    # Add basic solaris system paths
-    path4sdk=${path4sdk}:/usr/ccs/bin:/usr/ccs/lib:/usr/bin:/bin:/usr/sfw/bin
-
-    # Get the previous JDK to be used to bootstrap the build
-    path4sdk=${bootdir}/bin:${path4sdk}
-
-    # Find GNU make
-    make=/usr/sfw/bin/gmake
-    if [ ! -f ${make} ] ; then
-	make=/opt/sfw/bin/gmake
-	if [ ! -f ${make} ] ; then
-	    make=${slashjava}/devtools/${solaris_arch}/bin/gnumake
-        fi 
-    fi
-    fileMustExist "${make}" make
-
-    # File creation mask
-    umask 002
-
-elif [ "${osname}" = Linux ] ; then
-   
-    # LINUX: X86, AMD64
-    osarch=`uname -m`
-    if [ "${osarch}" = i686 ] ; then
-	linux_arch=i586
-    elif [ "${osarch}" = x86_64 ] ; then
-	linux_arch=amd64
-    fi
-
-    # Get the compilers into path (make sure it matches ALT setting)
-    compiler_path=/usr/bin
-    dirMustExist "${compiler_path}" COMPILER_PATH
-    path4sdk=${compiler_path}
-    
-    # Add basic paths
-    path4sdk=${path4sdk}:/usr/bin:/bin:/usr/sbin:/sbin
-
-    # Get the previous JDK to be used to bootstrap the build
-    path4sdk=${bootdir}/bin:${path4sdk}
-    
-    # Find GNU make
-    make=/usr/bin/make
-    fileMustExist "${make}" make
-
-    umask 002
-
-else
-
-    # Windows: Differs on CYGWIN vs. MKS, and the compiler available.
-    #   Also, blanks in pathnames gives GNU make headaches, so anything placed
-    #   in any ALT_* variable should be the short windows dosname.
-   
-    # WINDOWS: Install and use MKS or CYGWIN (should have already been done)
-    #   Assumption here is that you are in a shell window via MKS or cygwin.
-    #   MKS install should have defined the environment variable ROOTDIR.
-    #   We also need to figure out which one we have: X86, AMD64
-    if [ "`echo ${PROCESSOR_IDENTIFIER} | fgrep AMD64`" != "" ] ; then
-	windows_arch=amd64
-    else
-	windows_arch=i586
-    fi
-    
-    # We need to determine if we are running a CYGWIN shell or an MKS shell
-    #    (if uname isn't available, then it will be unix_toolset=unknown)
-    unix_toolset=unknown
-    if [ "`uname -a | fgrep Cygwin`" = "" -a -d "${ROOTDIR}" ] ; then
-        # We kind of assume ROOTDIR is where MKS is and it's ok
-        unix_toolset=MKS
-        mkshome=`dosname -s "${ROOTDIR}"`
-	# Utility to convert to short pathnames without spaces
-	dosname="${mkshome}/mksnt/dosname -s"
-        # Most unix utilities are in the mksnt directory of ROOTDIR
-        unixcommand_path="${mkshome}/mksnt"
-        path4sdk="${unixcommand_path}"
-        dirMustExist "${unixcommand_path}" UNIXCOMMAND_PATH
-	devtools_path="${slashjava}/devtools/win32/bin"
-	path4sdk="${devtools_path};${path4sdk}"
-        dirMustExist "${devtools_path}" DEVTOOLS_PATH
-        # Find GNU make
-        make="${devtools_path}/gnumake.exe"
-        fileMustExist "${make}" make
-    elif [ "`uname -a | fgrep Cygwin`" != "" -a -f /bin/cygpath ] ; then
-        # For CYGWIN, uname will have "Cygwin" in it, and /bin/cygpath should exist
-        unix_toolset=CYGWIN
-	# Utility to convert to short pathnames without spaces
-	dosname="/usr/bin/cygpath -a -m -s"
-        # Most unix utilities are in the /usr/bin
-        unixcommand_path="/usr/bin"
-        path4sdk="${unixcommand_path}"
-        dirMustExist "${unixcommand_path}" UNIXCOMMAND_PATH
-        # Find GNU make
-        make="${unixcommand_path}/make.exe"
-        fileMustExist "${make}" make
-    else
-      echo "WARNING: Cannot figure out if this is MKS or CYGWIN"
-    fi
-
-    # WINDOWS: Compiler setup (nasty part)
-    #   NOTE: You can use vcvars32.bat to set PATH, LIB, and INCLUDE.
-    #   NOTE: CYGWIN has a link.exe too, make sure the compilers are first
-    if [ "${windows_arch}" = i586 ] ; then
-        # 32bit Windows compiler settings
-        # VisualStudio .NET 2003 VC++ 7.1 (VS71COMNTOOLS should be defined)
-        vs_root=`${dosname} "${VS71COMNTOOLS}/../.."`
-        # Fill in PATH, LIB, and INCLUDE (unset all others to make sure)
-        vc7_root="${vs_root}/Vc7"
-        compiler_path="${vc7_root}/bin"
-        platform_sdk="${vc7_root}/PlatformSDK"
-        # LIB and INCLUDE must use ; as a separator
-        include4sdk="${vc7_root}/atlmfc/include"
-        include4sdk="${include4sdk};${vc7_root}/include"
-        include4sdk="${include4sdk};${platform_sdk}/include/prerelease"
-        include4sdk="${include4sdk};${platform_sdk}/include"
-        include4sdk="${include4sdk};${vs_root}/SDK/v1.1/include"
-        lib4sdk="${vc7_root}/atlmfc/lib"
-        lib4sdk="${lib4sdk};${vc7_root}/lib"
-        lib4sdk="${lib4sdk};${platform_sdk}/lib/prerelease"
-        lib4sdk="${lib4sdk};${platform_sdk}/lib"
-        lib4sdk="${lib4sdk};${vs_root}/SDK/v1.1/lib"
-        # Search path and DLL locating path
-        #   WARNING: CYGWIN has a link.exe too, make sure compilers are first
-        path4sdk="${vs_root}/Common7/Tools/bin;${path4sdk}"
-	path4sdk="${vs_root}/SDK/v1.1/bin;${path4sdk}"
-        path4sdk="${vs_root}/Common7/Tools;${path4sdk}"
-	path4sdk="${vs_root}/Common7/Tools/bin/prerelease;${path4sdk}"
-        path4sdk="${vs_root}/Common7/IDE;${path4sdk}"
-	path4sdk="${compiler_path};${path4sdk}"
-    elif [ "${windows_arch}" = amd64 ] ; then
-        # AMD64 64bit Windows compiler settings
-	if [ "${MSSDK}" != "" ] ; then
-	    platform_sdk="${MSSDK}"
-	else
-	    platform_sdk=`${dosname} "C:/Program Files/Microsoft Platform SDK/"`
-	fi
-	compiler_path="${platform_sdk}/Bin/win64/x86/AMD64"
-        # LIB and INCLUDE must use ; as a separator
-        include4sdk="${platform_sdk}/Include"
-	include4sdk="${include4sdk};${platform_sdk}/Include/crt/sys"
-	include4sdk="${include4sdk};${platform_sdk}/Include/mfc"
-	include4sdk="${include4sdk};${platform_sdk}/Include/atl"
-	include4sdk="${include4sdk};${platform_sdk}/Include/crt"
-        lib4sdk="${platform_sdk}/Lib/AMD64"
-        lib4sdk="${lib4sdk};${platform_sdk}/Lib/AMD64/atlmfc"
-        # Search path and DLL locating path
-        #   WARNING: CYGWIN has a link.exe too, make sure compilers are first
-        path4sdk="${platform_sdk}/bin;${path4sdk}"
-        path4sdk="${compiler_path};${path4sdk}"
-    fi
-    # Export LIB and INCLUDE
-    unset lib
-    unset Lib
-    LIB="${lib4sdk}"
-    export LIB
-    unset include
-    unset Include
-    INCLUDE="${include4sdk}"
-    export INCLUDE
-    # Set the ALT variable
-    dirMustExist "${compiler_path}" COMPILER_PATH
-    
-    # WINDOWS: Get the previous JDK to be used to bootstrap the build
-    path4sdk="${bootdir}/bin;${path4sdk}"
-
-    # Turn all \\ into /, remove duplicates and trailing /
-    slash_path="`echo ${path4sdk} | sed -e 's@\\\\@/@g' -e 's@//@/@g' -e 's@/$@@' -e 's@/;@;@g'`"
-    
-    # For windows, it's hard to know where the system is, so we just add this
-    #    to PATH.
-    path4sdk="${slash_path};${PATH}"
-    
-    # Convert path4sdk to cygwin style
-    if [ "${unix_toolset}" = CYGWIN ] ; then
-	path4sdk="`/usr/bin/cygpath -p ${path4sdk}`"
-    fi
-
-fi
-
-# Export PATH setting
-PATH="${path4sdk}"
-export PATH
-
-# Unset certain vars
-unset LD_LIBRARY_PATH
-unset LD_LIBRARY_PATH_32
-unset LD_LIBRARY_PATH_64
-
--- a/make/jprt.properties	Fri May 08 14:33:58 2009 -0700
+++ b/make/jprt.properties	Fri May 15 13:41:04 2009 -0700
@@ -70,10 +70,33 @@
 jprt.my.solaris.x64.jdk6u14=solaris_x64_5.10
 jprt.my.solaris.x64=${jprt.my.solaris.x64.${jprt.tools.default.release}}
 
-jprt.my.linux.i586=linux_i586
-jprt.my.linux.x64=linux_x64
-jprt.my.windows.i586=windows_i586
-jprt.my.windows.x64=windows_x64
+jprt.my.linux.i586.jdk7=linux_i586_2.6
+jprt.my.linux.i586.jdk6=linux_i586_2.4
+jprt.my.linux.i586.jdk6perf=linux_i586_2.4
+jprt.my.linux.i586.jdk6u10=linux_i586_2.4
+jprt.my.linux.i586.jdk6u14=linux_i586_2.4
+jprt.my.linux.i586=${jprt.my.linux.i586.${jprt.tools.default.release}}
+
+jprt.my.linux.x64.jdk7=linux_x64_2.6
+jprt.my.linux.x64.jdk6=linux_x64_2.4
+jprt.my.linux.x64.jdk6perf=linux_x64_2.4
+jprt.my.linux.x64.jdk6u10=linux_x64_2.4
+jprt.my.linux.x64.jdk6u14=linux_x64_2.4
+jprt.my.linux.x64=${jprt.my.linux.x64.${jprt.tools.default.release}}
+
+jprt.my.windows.i586.jdk7=windows_i586_5.0
+jprt.my.windows.i586.jdk6=windows_i586_5.0
+jprt.my.windows.i586.jdk6perf=windows_i586_5.0
+jprt.my.windows.i586.jdk6u10=windows_i586_5.0
+jprt.my.windows.i586.jdk6u14=windows_i586_5.0
+jprt.my.windows.i586=${jprt.my.windows.i586.${jprt.tools.default.release}}
+
+jprt.my.windows.x64.jdk7=windows_x64_5.2
+jprt.my.windows.x64.jdk6=windows_x64_5.2
+jprt.my.windows.x64.jdk6perf=windows_x64_5.2
+jprt.my.windows.x64.jdk6u10=windows_x64_5.2
+jprt.my.windows.x64.jdk6u14=windows_x64_5.2
+jprt.my.windows.x64=${jprt.my.windows.x64.${jprt.tools.default.release}}
 
 # Standard list of jprt build targets for this source tree
 
--- a/make/linux/makefiles/gcc.make	Fri May 08 14:33:58 2009 -0700
+++ b/make/linux/makefiles/gcc.make	Fri May 15 13:41:04 2009 -0700
@@ -113,6 +113,11 @@
 
 OPT_CFLAGS/NOOPT=-O0
 
+# 6835796. Problem in GCC 4.3.0 with mulnode.o optimized compilation. 
+ifneq "$(shell expr \( \( $(CC_VER_MAJOR) = 4 \) \& \( $(CC_VER_MINOR) = 3 \) \))" "0"
+OPT_CFLAGS/mulnode.o += -O0
+endif
+
 #------------------------------------------------------------------------
 # Linker flags
 
--- a/make/linux/makefiles/jsig.make	Fri May 08 14:33:58 2009 -0700
+++ b/make/linux/makefiles/jsig.make	Fri May 15 13:41:04 2009 -0700
@@ -39,7 +39,7 @@
 # cause problems with interposing. See CR: 6466665
 # LFLAGS_JSIG += $(MAPFLAG:FILENAME=$(LIBJSIG_MAPFILE))
 
-LFLAGS_JSIG += -D_GNU_SOURCE -D_REENTRANT
+LFLAGS_JSIG += -D_GNU_SOURCE -D_REENTRANT $(LDFLAGS_HASH_STYLE)
 
 # DEBUG_BINARIES overrides everything, use full -g debug information
 ifeq ($(DEBUG_BINARIES), true)
--- a/make/linux/makefiles/saproc.make	Fri May 08 14:33:58 2009 -0700
+++ b/make/linux/makefiles/saproc.make	Fri May 15 13:41:04 2009 -0700
@@ -56,7 +56,7 @@
 	   $(MAKE) -f vm.make $(LIBSAPROC); \
 	fi
 
-SA_LFLAGS = $(MAPFLAG:FILENAME=$(SAMAPFILE))
+SA_LFLAGS = $(MAPFLAG:FILENAME=$(SAMAPFILE)) $(LDFLAGS_HASH_STYLE)
 
 $(LIBSAPROC): $(SASRCFILES) $(SAMAPFILE)
 	$(QUIETLY) if [ "$(BOOT_JAVA_HOME)" = "" ]; then \
--- a/src/os/linux/vm/os_linux.cpp	Fri May 08 14:33:58 2009 -0700
+++ b/src/os/linux/vm/os_linux.cpp	Fri May 15 13:41:04 2009 -0700
@@ -2314,7 +2314,8 @@
 void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { }
 
 void os::free_memory(char *addr, size_t bytes) {
-  uncommit_memory(addr, bytes);
+  ::mmap(addr, bytes, PROT_READ | PROT_WRITE,
+         MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0);
 }
 
 void os::numa_make_global(char *addr, size_t bytes) {
@@ -2361,6 +2362,19 @@
 extern "C" void numa_warn(int number, char *where, ...) { }
 extern "C" void numa_error(char *where) { }
 
+
+// If we are running with libnuma version > 2, then we should
+// be trying to use symbols with versions 1.1
+// If we are running with earlier version, which did not have symbol versions,
+// we should use the base version.
+void* os::Linux::libnuma_dlsym(void* handle, const char *name) {
+  void *f = dlvsym(handle, name, "libnuma_1.1");
+  if (f == NULL) {
+    f = dlsym(handle, name);
+  }
+  return f;
+}
+
 bool os::Linux::libnuma_init() {
   // sched_getcpu() should be in libc.
   set_sched_getcpu(CAST_TO_FN_PTR(sched_getcpu_func_t,
@@ -2370,19 +2384,19 @@
     void *handle = dlopen("libnuma.so.1", RTLD_LAZY);
     if (handle != NULL) {
       set_numa_node_to_cpus(CAST_TO_FN_PTR(numa_node_to_cpus_func_t,
-                                           dlsym(handle, "numa_node_to_cpus")));
+                                           libnuma_dlsym(handle, "numa_node_to_cpus")));
       set_numa_max_node(CAST_TO_FN_PTR(numa_max_node_func_t,
-                                       dlsym(handle, "numa_max_node")));
+                                       libnuma_dlsym(handle, "numa_max_node")));
       set_numa_available(CAST_TO_FN_PTR(numa_available_func_t,
-                                        dlsym(handle, "numa_available")));
+                                        libnuma_dlsym(handle, "numa_available")));
       set_numa_tonode_memory(CAST_TO_FN_PTR(numa_tonode_memory_func_t,
-                                            dlsym(handle, "numa_tonode_memory")));
+                                            libnuma_dlsym(handle, "numa_tonode_memory")));
       set_numa_interleave_memory(CAST_TO_FN_PTR(numa_interleave_memory_func_t,
-                                            dlsym(handle, "numa_interleave_memory")));
+                                            libnuma_dlsym(handle, "numa_interleave_memory")));
 
 
       if (numa_available() != -1) {
-        set_numa_all_nodes((unsigned long*)dlsym(handle, "numa_all_nodes"));
+        set_numa_all_nodes((unsigned long*)libnuma_dlsym(handle, "numa_all_nodes"));
         // Create a cpu -> node mapping
         _cpu_to_node = new (ResourceObj::C_HEAP) GrowableArray<int>(0, true);
         rebuild_cpu_to_node_map();
--- a/src/os/linux/vm/os_linux.hpp	Fri May 08 14:33:58 2009 -0700
+++ b/src/os/linux/vm/os_linux.hpp	Fri May 15 13:41:04 2009 -0700
@@ -147,7 +147,7 @@
 
   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;
--- a/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.cpp	Fri May 08 14:33:58 2009 -0700
+++ b/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.cpp	Fri May 15 13:41:04 2009 -0700
@@ -53,7 +53,9 @@
     ResourceMark rm;
     HandleMark   hm;
 
-    if (TraceG1Refine) gclog_or_tty->print_cr("G1-Refine starting pass");
+    if (G1TraceConcurrentRefinement) {
+      gclog_or_tty->print_cr("G1-Refine starting pass");
+    }
     _sts.join();
     bool no_sleep = _cg1r->refine();
     _sts.leave();
@@ -207,9 +209,9 @@
 
 
 void ConcurrentG1RefineThread::yield() {
-  if (TraceG1Refine) gclog_or_tty->print_cr("G1-Refine-yield");
+  if (G1TraceConcurrentRefinement) gclog_or_tty->print_cr("G1-Refine-yield");
   _sts.yield("G1 refine");
-  if (TraceG1Refine) gclog_or_tty->print_cr("G1-Refine-yield-end");
+  if (G1TraceConcurrentRefinement) gclog_or_tty->print_cr("G1-Refine-yield-end");
 }
 
 void ConcurrentG1RefineThread::stop() {
@@ -230,7 +232,7 @@
       Terminator_lock->wait();
     }
   }
-  if (TraceG1Refine) gclog_or_tty->print_cr("G1-Refine-stop");
+  if (G1TraceConcurrentRefinement) gclog_or_tty->print_cr("G1-Refine-stop");
 }
 
 void ConcurrentG1RefineThread::print() {
--- a/src/share/vm/gc_implementation/g1/concurrentMark.cpp	Fri May 08 14:33:58 2009 -0700
+++ b/src/share/vm/gc_implementation/g1/concurrentMark.cpp	Fri May 15 13:41:04 2009 -0700
@@ -448,8 +448,8 @@
     gclog_or_tty->print_cr("[global] init, heap start = "PTR_FORMAT", "
                            "heap end = "PTR_FORMAT, _heap_start, _heap_end);
 
-  _markStack.allocate(G1CMStackSize);
-  _regionStack.allocate(G1CMRegionStackSize);
+  _markStack.allocate(G1MarkStackSize);
+  _regionStack.allocate(G1MarkRegionStackSize);
 
   // Create & start a ConcurrentMark thread.
   if (G1ConcMark) {
@@ -499,20 +499,21 @@
     _marking_task_overhead    = 1.0;
   } else {
     if (ParallelMarkingThreads > 0) {
-      // notice that ParallelMarkingThreads overwrites G1MarkingOverheadPerc
+      // notice that ParallelMarkingThreads overwrites G1MarkingOverheadPercent
       // if both are set
 
       _parallel_marking_threads = ParallelMarkingThreads;
       _sleep_factor             = 0.0;
       _marking_task_overhead    = 1.0;
-    } else if (G1MarkingOverheadPerc > 0) {
+    } else if (G1MarkingOverheadPercent > 0) {
       // we will calculate the number of parallel marking threads
       // based on a target overhead with respect to the soft real-time
       // goal
 
-      double marking_overhead = (double) G1MarkingOverheadPerc / 100.0;
+      double marking_overhead = (double) G1MarkingOverheadPercent / 100.0;
       double overall_cm_overhead =
-        (double) G1MaxPauseTimeMS * marking_overhead / (double) G1TimeSliceMS;
+        (double) MaxGCPauseMillis * marking_overhead /
+        (double) GCPauseIntervalMillis;
       double cpu_ratio = 1.0 / (double) os::processor_count();
       double marking_thread_num = ceil(overall_cm_overhead / cpu_ratio);
       double marking_task_overhead =
@@ -1747,7 +1748,7 @@
   g1h->increment_total_collections();
 
 #ifndef PRODUCT
-  if (G1VerifyConcMark) {
+  if (VerifyDuringGC) {
     G1CollectedHeap::heap()->prepare_for_verify();
     G1CollectedHeap::heap()->verify(true,false);
   }
--- a/src/share/vm/gc_implementation/g1/concurrentMarkThread.cpp	Fri May 08 14:33:58 2009 -0700
+++ b/src/share/vm/gc_implementation/g1/concurrentMarkThread.cpp	Fri May 15 13:41:04 2009 -0700
@@ -136,9 +136,6 @@
         iter++;
         if (!cm()->has_aborted()) {
           _cm->markFromRoots();
-        } else {
-          if (TraceConcurrentMark)
-            gclog_or_tty->print_cr("CM-skip-mark-from-roots");
         }
 
         double mark_end_time = os::elapsedVTime();
@@ -163,9 +160,6 @@
           sprintf(verbose_str, "GC remark");
           VM_CGC_Operation op(&final_cl, verbose_str);
           VMThread::execute(&op);
-        } else {
-          if (TraceConcurrentMark)
-            gclog_or_tty->print_cr("CM-skip-remark");
         }
         if (cm()->restart_for_overflow() &&
             G1TraceMarkStackOverflow) {
@@ -208,8 +202,6 @@
                                    count_end_sec - count_start_sec);
           }
         }
-      } else {
-        if (TraceConcurrentMark) gclog_or_tty->print_cr("CM-skip-end-game");
       }
       double end_time = os::elapsedVTime();
       _vtime_count_accum += (end_time - counting_start_time);
@@ -230,7 +222,6 @@
         VM_CGC_Operation op(&cl_cl, verbose_str);
         VMThread::execute(&op);
       } else {
-        if (TraceConcurrentMark) gclog_or_tty->print_cr("CM-skip-cleanup");
         G1CollectedHeap::heap()->set_marking_complete();
       }
 
@@ -287,9 +278,7 @@
 
 
 void ConcurrentMarkThread::yield() {
-  if (TraceConcurrentMark) gclog_or_tty->print_cr("CM-yield");
   _sts.yield("Concurrent Mark");
-  if (TraceConcurrentMark) gclog_or_tty->print_cr("CM-yield-end");
 }
 
 void ConcurrentMarkThread::stop() {
@@ -299,7 +288,6 @@
   while (!_has_terminated) {
     Terminator_lock->wait();
   }
-  if (TraceConcurrentMark) gclog_or_tty->print_cr("CM-stop");
 }
 
 void ConcurrentMarkThread::print() {
@@ -314,12 +302,10 @@
   // below while the world is otherwise stopped.
   MutexLockerEx x(CGC_lock, Mutex::_no_safepoint_check_flag);
   while (!started()) {
-    if (TraceConcurrentMark) gclog_or_tty->print_cr("CM-sleeping");
     CGC_lock->wait(Mutex::_no_safepoint_check_flag);
   }
   set_in_progress();
   clear_started();
-  if (TraceConcurrentMark) gclog_or_tty->print_cr("CM-starting");
 }
 
 // Note: this method, although exported by the ConcurrentMarkSweepThread,
--- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp	Fri May 08 14:33:58 2009 -0700
+++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp	Fri May 15 13:41:04 2009 -0700
@@ -528,7 +528,7 @@
            res->zero_fill_state() == HeapRegion::Allocated)),
          "Non-young alloc Regions must be zero filled (and non-H)");
 
-  if (G1TraceRegions) {
+  if (G1PrintRegions) {
     if (res != NULL) {
       gclog_or_tty->print_cr("new alloc region %d:["PTR_FORMAT", "PTR_FORMAT"], "
                              "top "PTR_FORMAT,
@@ -2282,13 +2282,13 @@
     // to that.
     g1_policy()->print_tracing_info();
   }
-  if (SummarizeG1RSStats) {
+  if (G1SummarizeRSetStats) {
     g1_rem_set()->print_summary_info();
   }
-  if (SummarizeG1ConcMark) {
+  if (G1SummarizeConcurrentMark) {
     concurrent_mark()->print_summary_info();
   }
-  if (SummarizeG1ZFStats) {
+  if (G1SummarizeZFStats) {
     ConcurrentZFThread::print_summary_info();
   }
   g1_policy()->print_yg_surv_rate_info();
@@ -3255,7 +3255,7 @@
   HeapRegion* r = heap_region_containing(old);
   if (!r->evacuation_failed()) {
     r->set_evacuation_failed(true);
-    if (G1TraceRegions) {
+    if (G1PrintRegions) {
       gclog_or_tty->print("evacuation failed in heap region "PTR_FORMAT" "
                           "["PTR_FORMAT","PTR_FORMAT")\n",
                           r, r->bottom(), r->end());
@@ -3466,7 +3466,7 @@
   }
 
   static size_t gclab_word_size() {
-    return ParallelGCG1AllocBufferSize / HeapWordSize;
+    return G1ParallelGCAllocBufferSize / HeapWordSize;
   }
 
   static size_t bitmap_size_in_bits() {
@@ -3616,7 +3616,7 @@
 
 public:
   G1ParGCAllocBuffer() :
-    ParGCAllocBuffer(ParallelGCG1AllocBufferSize / HeapWordSize),
+    ParGCAllocBuffer(G1ParallelGCAllocBufferSize / HeapWordSize),
     _during_marking(G1CollectedHeap::heap()->mark_in_progress()),
     _bitmap(G1CollectedHeap::heap()->reserved_region().start()),
     _retired(false)
@@ -3812,14 +3812,14 @@
 
     HeapWord* obj = NULL;
     if (word_sz * 100 <
-        (size_t)(ParallelGCG1AllocBufferSize / HeapWordSize) *
+        (size_t)(G1ParallelGCAllocBufferSize / HeapWordSize) *
                                                   ParallelGCBufferWastePct) {
       G1ParGCAllocBuffer* alloc_buf = alloc_buffer(purpose);
       add_to_alloc_buffer_waste(alloc_buf->words_remaining());
       alloc_buf->retire(false, false);
 
       HeapWord* buf =
-        _g1h->par_allocate_during_gc(purpose, ParallelGCG1AllocBufferSize / HeapWordSize);
+        _g1h->par_allocate_during_gc(purpose, G1ParallelGCAllocBufferSize / HeapWordSize);
       if (buf == NULL) return NULL; // Let caller handle allocation failure.
       // Otherwise.
       alloc_buf->set_buf(buf);
@@ -4331,7 +4331,7 @@
       _g1h->g1_policy()->record_obj_copy_time(i, elapsed_ms-term_ms);
       _g1h->g1_policy()->record_termination_time(i, term_ms);
     }
-    if (G1UseSurvivorSpace) {
+    if (G1UseSurvivorSpaces) {
       _g1h->g1_policy()->record_thread_age_table(pss.age_table());
     }
     _g1h->update_surviving_young_words(pss.surviving_young_words()+1);
@@ -4435,28 +4435,6 @@
 
   // XXX What should this be doing in the parallel case?
   g1_policy()->record_collection_pause_end_CH_strong_roots();
-  if (G1VerifyRemSet) {
-    // :::: FIXME ::::
-    // The stupid remembered set doesn't know how to filter out dead
-    // objects, which the smart one does, and so when it is created
-    // and then compared the number of entries in each differs and
-    // the verification code fails.
-    guarantee(false, "verification code is broken, see note");
-
-    // Let's make sure that the current rem set agrees with the stupidest
-    // one possible!
-    bool refs_enabled = ref_processor()->discovery_enabled();
-    if (refs_enabled) ref_processor()->disable_discovery();
-    StupidG1RemSet stupid(this);
-    count_closure.n = 0;
-    stupid.oops_into_collection_set_do(&count_closure, worker_i);
-    int stupid_n = count_closure.n;
-    count_closure.n = 0;
-    g1_rem_set()->oops_into_collection_set_do(&count_closure, worker_i);
-    guarantee(count_closure.n == stupid_n, "Old and new rem sets differ.");
-    gclog_or_tty->print_cr("\nFound %d pointers in heap RS.", count_closure.n);
-    if (refs_enabled) ref_processor()->enable_discovery();
-  }
   if (scan_so != NULL) {
     scan_scan_only_set(scan_so, worker_i);
   }
--- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.inline.hpp	Fri May 08 14:33:58 2009 -0700
+++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.inline.hpp	Fri May 15 13:41:04 2009 -0700
@@ -37,8 +37,9 @@
 inline HeapRegion*
 G1CollectedHeap::heap_region_containing_raw(const void* addr) const {
   assert(_g1_reserved.contains(addr), "invariant");
-  size_t index = ((intptr_t) addr - (intptr_t) _g1_reserved.start())
-                                              >> HeapRegion::LogOfHRGrainBytes;
+  size_t index = pointer_delta(addr, _g1_reserved.start(), 1)
+                                        >> HeapRegion::LogOfHRGrainBytes;
+
   HeapRegion* res = _hrs->at(index);
   assert(res == _hrs->addr_to_region(addr), "sanity");
   return res;
--- a/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp	Fri May 08 14:33:58 2009 -0700
+++ b/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp	Fri May 15 13:41:04 2009 -0700
@@ -136,7 +136,7 @@
   _scanned_cards_seq(new TruncatedSeq(TruncatedSeqLength)),
   _rs_lengths_seq(new TruncatedSeq(TruncatedSeqLength)),
 
-  _pause_time_target_ms((double) G1MaxPauseTimeMS),
+  _pause_time_target_ms((double) MaxGCPauseMillis),
 
   // </NEW PREDICTION>
 
@@ -220,7 +220,7 @@
   _par_last_termination_times_ms = new double[_parallel_gc_threads];
 
   // start conservatively
-  _expensive_region_limit_ms = 0.5 * (double) G1MaxPauseTimeMS;
+  _expensive_region_limit_ms = 0.5 * (double) MaxGCPauseMillis;
 
   // <NEW PREDICTION>
 
@@ -249,12 +249,12 @@
 
   // </NEW PREDICTION>
 
-  double time_slice  = (double) G1TimeSliceMS / 1000.0;
-  double max_gc_time = (double) G1MaxPauseTimeMS / 1000.0;
+  double time_slice  = (double) GCPauseIntervalMillis / 1000.0;
+  double max_gc_time = (double) MaxGCPauseMillis / 1000.0;
   guarantee(max_gc_time < time_slice,
             "Max GC time should not be greater than the time slice");
   _mmu_tracker = new G1MMUTrackerQueue(time_slice, max_gc_time);
-  _sigma = (double) G1ConfidencePerc / 100.0;
+  _sigma = (double) G1ConfidencePercent / 100.0;
 
   // start conservatively (around 50ms is about right)
   _concurrent_mark_init_times_ms->add(0.05);
@@ -262,7 +262,7 @@
   _concurrent_mark_cleanup_times_ms->add(0.20);
   _tenuring_threshold = MaxTenuringThreshold;
 
-  if (G1UseSurvivorSpace) {
+  if (G1UseSurvivorSpaces) {
     // if G1FixedSurvivorSpaceSize is 0 which means the size is not
     // fixed, then _max_survivor_regions will be calculated at
     // calculate_young_list_target_config during initialization
@@ -451,7 +451,7 @@
   guarantee( adaptive_young_list_length(), "pre-condition" );
 
   double start_time_sec = os::elapsedTime();
-  size_t min_reserve_perc = MAX2((size_t)2, (size_t)G1MinReservePerc);
+  size_t min_reserve_perc = MAX2((size_t)2, (size_t)G1MinReservePercent);
   min_reserve_perc = MIN2((size_t) 50, min_reserve_perc);
   size_t reserve_regions =
     (size_t) ((double) min_reserve_perc * (double) _g1->n_regions() / 100.0);
@@ -1109,7 +1109,7 @@
   _short_lived_surv_rate_group->record_scan_only_prefix(short_lived_so_length);
   tag_scan_only(short_lived_so_length);
 
-  if (G1UseSurvivorSpace) {
+  if (G1UseSurvivorSpaces) {
     _survivors_age_table.clear();
   }
 
@@ -1826,11 +1826,11 @@
     _rs_lengths_seq->add((double) _max_rs_lengths);
 
     double expensive_region_limit_ms =
-      (double) G1MaxPauseTimeMS - predict_constant_other_time_ms();
+      (double) MaxGCPauseMillis - predict_constant_other_time_ms();
     if (expensive_region_limit_ms < 0.0) {
       // this means that the other time was predicted to be longer than
       // than the max pause time
-      expensive_region_limit_ms = (double) G1MaxPauseTimeMS;
+      expensive_region_limit_ms = (double) MaxGCPauseMillis;
     }
     _expensive_region_limit_ms = expensive_region_limit_ms;
 
@@ -2093,24 +2093,24 @@
 }
 
 double G1CollectorPolicy::recent_avg_time_for_pauses_ms() {
-  if (_recent_pause_times_ms->num() == 0) return (double) G1MaxPauseTimeMS;
+  if (_recent_pause_times_ms->num() == 0) return (double) MaxGCPauseMillis;
   else return _recent_pause_times_ms->avg();
 }
 
 double G1CollectorPolicy::recent_avg_time_for_CH_strong_ms() {
   if (_recent_CH_strong_roots_times_ms->num() == 0)
-    return (double)G1MaxPauseTimeMS/3.0;
+    return (double)MaxGCPauseMillis/3.0;
   else return _recent_CH_strong_roots_times_ms->avg();
 }
 
 double G1CollectorPolicy::recent_avg_time_for_G1_strong_ms() {
   if (_recent_G1_strong_roots_times_ms->num() == 0)
-    return (double)G1MaxPauseTimeMS/3.0;
+    return (double)MaxGCPauseMillis/3.0;
   else return _recent_G1_strong_roots_times_ms->avg();
 }
 
 double G1CollectorPolicy::recent_avg_time_for_evac_ms() {
-  if (_recent_evac_times_ms->num() == 0) return (double)G1MaxPauseTimeMS/3.0;
+  if (_recent_evac_times_ms->num() == 0) return (double)MaxGCPauseMillis/3.0;
   else return _recent_evac_times_ms->avg();
 }
 
@@ -2197,17 +2197,18 @@
 }
 
 size_t G1CollectorPolicy::expansion_amount() {
-  if ((int)(recent_avg_pause_time_ratio() * 100.0) > G1GCPct) {
-    // We will double the existing space, or take G1ExpandByPctOfAvail % of
-    // the available expansion space, whichever is smaller, bounded below
-    // by a minimum expansion (unless that's all that's left.)
+  if ((int)(recent_avg_pause_time_ratio() * 100.0) > G1GCPercent) {
+    // We will double the existing space, or take
+    // G1ExpandByPercentOfAvailable % of the available expansion
+    // space, whichever is smaller, bounded below by a minimum
+    // expansion (unless that's all that's left.)
     const size_t min_expand_bytes = 1*M;
     size_t reserved_bytes = _g1->g1_reserved_obj_bytes();
     size_t committed_bytes = _g1->capacity();
     size_t uncommitted_bytes = reserved_bytes - committed_bytes;
     size_t expand_bytes;
     size_t expand_bytes_via_pct =
-      uncommitted_bytes * G1ExpandByPctOfAvail / 100;
+      uncommitted_bytes * G1ExpandByPercentOfAvailable / 100;
     expand_bytes = MIN2(expand_bytes_via_pct, committed_bytes);
     expand_bytes = MAX2(expand_bytes, min_expand_bytes);
     expand_bytes = MIN2(expand_bytes, uncommitted_bytes);
@@ -2591,7 +2592,7 @@
 // Calculates survivor space parameters.
 void G1CollectorPolicy::calculate_survivors_policy()
 {
-  if (!G1UseSurvivorSpace) {
+  if (!G1UseSurvivorSpaces) {
     return;
   }
   if (G1FixedSurvivorSpaceSize == 0) {
@@ -2851,7 +2852,7 @@
 // estimate of the number of live bytes.
 void G1CollectorPolicy::
 add_to_collection_set(HeapRegion* hr) {
-  if (G1TraceRegions) {
+  if (G1PrintRegions) {
     gclog_or_tty->print_cr("added region to cset %d:["PTR_FORMAT", "PTR_FORMAT"], "
                   "top "PTR_FORMAT", young %s",
                   hr->hrs_index(), hr->bottom(), hr->end(),
--- a/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp	Fri May 08 14:33:58 2009 -0700
+++ b/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp	Fri May 15 13:41:04 2009 -0700
@@ -57,7 +57,7 @@
 
   mark_sweep_phase1(marked_for_unloading, clear_all_softrefs);
 
-  if (G1VerifyConcMark) {
+  if (VerifyDuringGC) {
       G1CollectedHeap* g1h = G1CollectedHeap::heap();
       g1h->checkConcurrentMark();
   }
--- a/src/share/vm/gc_implementation/g1/g1RemSet.cpp	Fri May 08 14:33:58 2009 -0700
+++ b/src/share/vm/gc_implementation/g1/g1RemSet.cpp	Fri May 15 13:41:04 2009 -0700
@@ -180,6 +180,7 @@
   CardTableModRefBS *_ct_bs;
   int _worker_i;
   bool _try_claimed;
+  size_t _min_skip_distance, _max_skip_distance;
 public:
   ScanRSClosure(OopsInHeapRegionClosure* oc, int worker_i) :
     _oc(oc),
@@ -191,6 +192,8 @@
     _g1h = G1CollectedHeap::heap();
     _bot_shared = _g1h->bot_shared();
     _ct_bs = (CardTableModRefBS*) (_g1h->barrier_set());
+    _min_skip_distance = 16;
+    _max_skip_distance = 2 * _g1h->n_par_threads() * _min_skip_distance;
   }
 
   void set_try_claimed() { _try_claimed = true; }
@@ -245,9 +248,13 @@
     HeapRegionRemSetIterator* iter = _g1h->rem_set_iterator(_worker_i);
     hrrs->init_iterator(iter);
     size_t card_index;
+    size_t skip_distance = 0, current_card = 0, jump_to_card = 0;
     while (iter->has_next(card_index)) {
+      if (current_card < jump_to_card) {
+        ++current_card;
+        continue;
+      }
       HeapWord* card_start = _g1h->bot_shared()->address_for_index(card_index);
-
 #if 0
       gclog_or_tty->print("Rem set iteration yielded card [" PTR_FORMAT ", " PTR_FORMAT ").\n",
                           card_start, card_start + CardTableModRefBS::card_size_in_words);
@@ -257,20 +264,28 @@
       assert(card_region != NULL, "Yielding cards not in the heap?");
       _cards++;
 
-      if (!card_region->in_collection_set()) {
-        // If the card is dirty, then we will scan it during updateRS.
-        if (!_ct_bs->is_card_claimed(card_index) &&
-            !_ct_bs->is_card_dirty(card_index)) {
-          assert(_ct_bs->is_card_clean(card_index) ||
-                 _ct_bs->is_card_claimed(card_index) ||
-                 _ct_bs->is_card_deferred(card_index),
-                 "Card is either clean, claimed or deferred");
-          if (_ct_bs->claim_card(card_index))
+       // If the card is dirty, then we will scan it during updateRS.
+      if (!card_region->in_collection_set() && !_ct_bs->is_card_dirty(card_index)) {
+          if (!_ct_bs->is_card_claimed(card_index) && _ct_bs->claim_card(card_index)) {
             scanCard(card_index, card_region);
-        }
+          } else if (_try_claimed) {
+            if (jump_to_card == 0 || jump_to_card != current_card) {
+              // We did some useful work in the previous iteration.
+              // Decrease the distance.
+              skip_distance = MAX2(skip_distance >> 1, _min_skip_distance);
+            } else {
+              // Previous iteration resulted in a claim failure.
+              // Increase the distance.
+              skip_distance = MIN2(skip_distance << 1, _max_skip_distance);
+            }
+            jump_to_card = current_card + skip_distance;
+          }
       }
+      ++current_card;
     }
-    hrrs->set_iter_complete();
+    if (!_try_claimed) {
+      hrrs->set_iter_complete();
+    }
     return false;
   }
   // Set all cards back to clean.
@@ -508,7 +523,7 @@
     // and they are causing failures. When we resolve said race
     // conditions, we'll revert back to parallel remembered set
     // updating and scanning. See CRs 6677707 and 6677708.
-    if (G1EnableParallelRSetUpdating || (worker_i == 0)) {
+    if (G1ParallelRSetUpdatingEnabled || (worker_i == 0)) {
       updateRS(worker_i);
       scanNewRefsRS(oc, worker_i);
     } else {
@@ -517,7 +532,7 @@
       _g1p->record_update_rs_time(worker_i, 0.0);
       _g1p->record_scan_new_refs_time(worker_i, 0.0);
     }
-    if (G1EnableParallelRSetScanning || (worker_i == 0)) {
+    if (G1ParallelRSetScanningEnabled || (worker_i == 0)) {
       scanRS(oc, worker_i);
     } else {
       _g1p->record_scan_rs_start_time(worker_i, os::elapsedTime());
--- a/src/share/vm/gc_implementation/g1/g1_globals.hpp	Fri May 08 14:33:58 2009 -0700
+++ b/src/share/vm/gc_implementation/g1/g1_globals.hpp	Fri May 15 13:41:04 2009 -0700
@@ -28,87 +28,65 @@
 
 #define G1_FLAGS(develop, develop_pd, product, product_pd, diagnostic, experimental, notproduct, manageable, product_rw) \
                                                                             \
-  product(intx, ParallelGCG1AllocBufferSize, 8*K,                           \
+  product(intx, G1ParallelGCAllocBufferSize, 8*K,                           \
           "Size of parallel G1 allocation buffers in to-space.")            \
                                                                             \
-  product(intx, G1TimeSliceMS, 500,                                         \
-          "Time slice for MMU specification")                               \
-                                                                            \
-  product(intx, G1MaxPauseTimeMS, 200,                                      \
-          "Max GC time per MMU time slice")                                 \
-                                                                            \
-  product(intx, G1ConfidencePerc, 50,                                       \
+  product(intx, G1ConfidencePercent, 50,                                    \
           "Confidence level for MMU/pause predictions")                     \
                                                                             \
-  product(intx, G1MarkingOverheadPerc, 0,                                   \
+  develop(intx, G1MarkingOverheadPercent, 0,                                   \
           "Overhead of concurrent marking")                                 \
                                                                             \
-  product(bool, G1AccountConcurrentOverhead, false,                         \
+  develop(bool, G1AccountConcurrentOverhead, false,                         \
           "Whether soft real-time compliance in G1 will take into account"  \
           "concurrent overhead")                                            \
                                                                             \
   product(intx, G1YoungGenSize, 0,                                          \
           "Size of the G1 young generation, 0 is the adaptive policy")      \
                                                                             \
-  product(bool, G1Gen, true,                                                \
+  develop(bool, G1Gen, true,                                                \
           "If true, it will enable the generational G1")                    \
                                                                             \
-  develop(intx, G1GCPct, 10,                                                \
+  develop(intx, G1GCPercent, 10,                                                \
           "The desired percent time spent on GC")                           \
                                                                             \
-  product(intx, G1PolicyVerbose, 0,                                         \
+  develop(intx, G1PolicyVerbose, 0,                                         \
           "The verbosity level on G1 policy decisions")                     \
                                                                             \
   develop(bool, G1UseHRIntoRS, true,                                        \
           "Determines whether the 'advanced' HR Into rem set is used.")     \
                                                                             \
-  product(bool, G1VerifyRemSet, false,                                      \
-          "If true, verify the rem set functioning at each GC")             \
-                                                                            \
-  product(bool, G1VerifyConcMark, false,                                    \
-          "If true, verify the conc marking code at full GC time")          \
-                                                                            \
   develop(intx, G1MarkingVerboseLevel, 0,                                   \
           "Level (0-4) of verboseness of the marking code")                 \
                                                                             \
-  develop(bool, G1VerifyConcMarkPrintReachable, true,                       \
+  develop(bool, G1VerifyConcMarkPrintReachable, false,                      \
           "If conc mark verification fails, print reachable objects")       \
                                                                             \
   develop(bool, G1TraceMarkStackOverflow, false,                            \
           "If true, extra debugging code for CM restart for ovflw.")        \
                                                                             \
-  product(bool, G1VerifyMarkingInEvac, false,                               \
-          "If true, verify marking info during evacuation")                 \
-                                                                            \
   develop(intx, G1PausesBtwnConcMark, -1,                                   \
           "If positive, fixed number of pauses between conc markings")      \
                                                                             \
-  product(intx, G1EfficiencyPctCausesMark, 80,                              \
-          "The cum gc efficiency since mark fall-off that causes "          \
-          "new marking")                                                    \
-                                                                            \
-  product(bool, TraceConcurrentMark, false,                                 \
-          "Trace concurrent mark")                                          \
-                                                                            \
-  product(bool, SummarizeG1ConcMark, false,                                 \
+  diagnostic(bool, G1SummarizeConcurrentMark, false,                        \
           "Summarize concurrent mark info")                                 \
                                                                             \
-  product(bool, SummarizeG1RSStats, false,                                  \
+  diagnostic(bool, G1SummarizeRSetStats, false,                             \
           "Summarize remembered set processing info")                       \
                                                                             \
-  product(bool, SummarizeG1ZFStats, false,                                  \
+  diagnostic(bool, G1SummarizeZFStats, false,                               \
           "Summarize zero-filling info")                                    \
                                                                             \
-  product(bool, TraceG1Refine, false,                                       \
+  develop(bool, G1TraceConcurrentRefinement, false,                         \
           "Trace G1 concurrent refinement")                                 \
                                                                             \
   develop(bool, G1ConcMark, true,                                           \
           "If true, run concurrent marking for G1")                         \
                                                                             \
-  product(intx, G1CMStackSize, 2 * 1024 * 1024,                             \
+  product(intx, G1MarkStackSize, 2 * 1024 * 1024,                           \
           "Size of the mark stack for concurrent marking.")                 \
                                                                             \
-  product(intx, G1CMRegionStackSize, 1024 * 1024,                           \
+  product(intx, G1MarkRegionStackSize, 1024 * 1024,                         \
           "Size of the region stack for concurrent marking.")               \
                                                                             \
   develop(bool, G1ConcRefine, true,                                         \
@@ -121,7 +99,7 @@
           "Number of heap regions of alloc ahead of starting collection "   \
           "pause to start concurrent refinement (initially)")               \
                                                                             \
-  product(bool, G1SmoothConcRefine, true,                                   \
+  develop(bool, G1SmoothConcRefine, true,                                   \
           "Attempts to smooth out the overhead of concurrent refinement")   \
                                                                             \
   develop(bool, G1ConcZeroFill, true,                                       \
@@ -157,7 +135,7 @@
   develop(bool, G1SATBPrintStubs, false,                                    \
           "If true, print generated stubs for the SATB barrier")            \
                                                                             \
-  product(intx, G1ExpandByPctOfAvail, 20,                                   \
+  product(intx, G1ExpandByPercentOfAvailable, 20,                           \
           "When expanding, % of uncommitted space to claim.")               \
                                                                             \
   develop(bool, G1RSBarrierRegionFilter, true,                              \
@@ -179,18 +157,9 @@
           "If true, verify that no dirty cards remain after RS log "        \
           "processing.")                                                    \
                                                                             \
-  product(intx, G1MinPausesBetweenMarks, 2,                                 \
-          "Number of inefficient pauses necessary to trigger marking.")     \
-                                                                            \
-  product(intx, G1InefficientPausePct, 80,                                  \
-          "Threshold of an 'inefficient' pauses (as % of cum efficiency.")  \
-                                                                            \
   develop(bool, G1RSCountHisto, false,                                      \
           "If true, print a histogram of RS occupancies after each pause")  \
                                                                             \
-  product(bool, G1TraceFileOverwrite, false,                                \
-          "Allow the trace file to be overwritten")                         \
-                                                                            \
   develop(intx, G1PrintRegionLivenessInfo, 0,                               \
           "When > 0, print the occupancies of the <n> best and worst"       \
           "regions.")                                                       \
@@ -198,9 +167,6 @@
   develop(bool, G1PrintParCleanupStats, false,                              \
           "When true, print extra stats about parallel cleanup.")           \
                                                                             \
-  product(bool, G1DoAgeCohortChecks, false,                                 \
-          "When true, check well-formedness of age cohort structures.")     \
-                                                                            \
   develop(bool, G1DisablePreBarrier, false,                                 \
           "Disable generation of pre-barrier (i.e., marking barrier)   ")   \
                                                                             \
@@ -214,17 +180,17 @@
   develop(intx, G1ConcRSLogCacheSize, 10,                                   \
           "Log base 2 of the length of conc RS hot-card cache.")            \
                                                                             \
-  product(bool, G1ConcRSCountTraversals, false,                             \
+  develop(bool, G1ConcRSCountTraversals, false,                             \
           "If true, gather data about the number of times CR traverses "    \
           "cards ")                                                         \
                                                                             \
-  product(intx, G1ConcRSHotCardLimit, 4,                                    \
+  develop(intx, G1ConcRSHotCardLimit, 4,                                    \
           "The threshold that defines (>=) a hot card.")                    \
                                                                             \
   develop(bool, G1PrintOopAppls, false,                                     \
           "When true, print applications of closures to external locs.")    \
                                                                             \
-  product(intx, G1LogRSRegionEntries, 7,                                    \
+  develop(intx, G1LogRSRegionEntries, 7,                                    \
           "Log_2 of max number of regions for which we keep bitmaps.")      \
                                                                             \
   develop(bool, G1RecordHRRSOops, false,                                    \
@@ -254,11 +220,11 @@
           "It determines whether the system will calculate an optimum "     \
           "scan-only set.")                                                 \
                                                                             \
-  product(intx, G1MinReservePerc, 10,                                       \
+  product(intx, G1MinReservePercent, 10,                                    \
           "It determines the minimum reserve we should have in the heap "   \
           "to minimize the probability of promotion failure.")              \
                                                                             \
-  product(bool, G1TraceRegions, false,                                      \
+  diagnostic(bool, G1PrintRegions, false,                                   \
           "If set G1 will print information on which regions are being "    \
           "allocated and which are reclaimed.")                             \
                                                                             \
@@ -268,24 +234,24 @@
   develop(bool, G1HRRSFlushLogBuffersOnVerify, false,                       \
           "Forces flushing of log buffers before verification.")            \
                                                                             \
-  product(bool, G1UseSurvivorSpace, true,                                   \
+  product(bool, G1UseSurvivorSpaces, true,                                  \
           "When true, use survivor space.")                                 \
                                                                             \
-  product(bool, G1FixedTenuringThreshold, false,                            \
+  develop(bool, G1FixedTenuringThreshold, false,                            \
           "When set, G1 will not adjust the tenuring threshold")            \
                                                                             \
-  product(bool, G1FixedEdenSize, false,                                     \
+  develop(bool, G1FixedEdenSize, false,                                     \
           "When set, G1 will not allocate unused survivor space regions")   \
                                                                             \
-  product(uintx, G1FixedSurvivorSpaceSize, 0,                               \
+  develop(uintx, G1FixedSurvivorSpaceSize, 0,                               \
           "If non-0 is the size of the G1 survivor space, "                 \
           "otherwise SurvivorRatio is used to determine the size")          \
                                                                             \
-  experimental(bool, G1EnableParallelRSetUpdating, false,                   \
+  experimental(bool, G1ParallelRSetUpdatingEnabled, false,                  \
           "Enables the parallelization of remembered set updating "         \
           "during evacuation pauses")                                       \
                                                                             \
-  experimental(bool, G1EnableParallelRSetScanning, false,                   \
+  experimental(bool, G1ParallelRSetScanningEnabled, false,                  \
           "Enables the parallelization of remembered set scanning "         \
           "during evacuation pauses")
 
--- a/src/share/vm/gc_implementation/g1/heapRegion.cpp	Fri May 08 14:33:58 2009 -0700
+++ b/src/share/vm/gc_implementation/g1/heapRegion.cpp	Fri May 15 13:41:04 2009 -0700
@@ -160,12 +160,6 @@
     if (!g1h->is_obj_dead(cur_oop, hr)) {
       // Bottom lies entirely below top, so we can call the
       // non-memRegion version of oop_iterate below.
-#ifndef PRODUCT
-      if (G1VerifyMarkingInEvac) {
-        VerifyLiveClosure vl_cl(g1h);
-        cur_oop->oop_iterate(&vl_cl);
-      }
-#endif
       cur_oop->oop_iterate(cl);
     }
     cur = next_obj;
@@ -197,12 +191,6 @@
   // or it was allocated after marking finished, then we add it. Otherwise
   // we can safely ignore the object.
   if (!g1h->is_obj_dead(oop(bottom), _hr)) {
-#ifndef PRODUCT
-    if (G1VerifyMarkingInEvac) {
-      VerifyLiveClosure vl_cl(g1h);
-      oop(bottom)->oop_iterate(&vl_cl, mr);
-    }
-#endif
     oop_size = oop(bottom)->oop_iterate(cl2, mr);
   } else {
     oop_size = oop(bottom)->size();
@@ -232,12 +220,6 @@
 
     // Last object. Need to do dead-obj filtering here too.
     if (!g1h->is_obj_dead(oop(bottom), _hr)) {
-#ifndef PRODUCT
-      if (G1VerifyMarkingInEvac) {
-        VerifyLiveClosure vl_cl(g1h);
-        oop(bottom)->oop_iterate(&vl_cl, mr);
-      }
-#endif
       oop(bottom)->oop_iterate(cl2, mr);
     }
   }
@@ -713,12 +695,12 @@
     G1CollectedHeap::heap()->print();
     gclog_or_tty->print_cr("");
   }
-  if (G1VerifyConcMark &&
+  if (VerifyDuringGC &&
       G1VerifyConcMarkPrintReachable &&
       vl_cl.failures()) {
     g1->concurrent_mark()->print_prev_bitmap_reachable();
   }
-  guarantee(!vl_cl.failures(), "should not have had any failures");
+  guarantee(!vl_cl.failures(), "region verification failed");
   guarantee(p == top(), "end of last object must match end of space");
 }
 
--- a/src/share/vm/opto/connode.cpp	Fri May 08 14:33:58 2009 -0700
+++ b/src/share/vm/opto/connode.cpp	Fri May 15 13:41:04 2009 -0700
@@ -128,6 +128,10 @@
       // Swapped Cmp is OK
       (phase->eqv(cmp->in(2),f) &&
        phase->eqv(cmp->in(1),t)) ) {
+    // Give up this identity check for floating points because it may choose incorrect
+    // value around 0.0 and -0.0
+    if ( cmp->Opcode()==Op_CmpF || cmp->Opcode()==Op_CmpD )
+      return NULL;
     // Check for "(t==f)?t:f;" and replace with "f"
     if( b->_test._test == BoolTest::eq )
       return f;
--- a/src/share/vm/opto/divnode.cpp	Fri May 08 14:33:58 2009 -0700
+++ b/src/share/vm/opto/divnode.cpp	Fri May 15 13:41:04 2009 -0700
@@ -298,8 +298,10 @@
 
   // 6732154: Construct both w1 and w2 before transforming, so t
   // doesn't go dead prematurely.
+  // 6837011: We need to transform w2 before w1 because the
+  // transformation of w1 could return t.
+  w2 = phase->transform(w2);
   w1 = phase->transform(w1);
-  w2 = phase->transform(w2);
 
   // w1 = u0*v1 + w1;
   Node* u0v1 = phase->transform(new (phase->C, 3) MulLNode(u0, v1));
--- a/src/share/vm/runtime/arguments.cpp	Fri May 08 14:33:58 2009 -0700
+++ b/src/share/vm/runtime/arguments.cpp	Fri May 15 13:41:04 2009 -0700
@@ -1288,10 +1288,14 @@
                      Abstract_VM_Version::parallel_worker_threads());
   if (ParallelGCThreads == 0) {
     FLAG_SET_DEFAULT(ParallelGCThreads,
-                     Abstract_VM_Version::parallel_worker_threads
-());
+                     Abstract_VM_Version::parallel_worker_threads());
   }
   no_shared_spaces();
+
+  // Set the maximum pause time goal to be a reasonable default.
+  if (FLAG_IS_DEFAULT(MaxGCPauseMillis)) {
+    FLAG_SET_DEFAULT(MaxGCPauseMillis, 200);
+  }
 }
 
 void Arguments::set_server_heap_size() {
--- a/src/share/vm/runtime/dtraceJSDT.cpp	Fri May 08 14:33:58 2009 -0700
+++ b/src/share/vm/runtime/dtraceJSDT.cpp	Fri May 15 13:41:04 2009 -0700
@@ -60,6 +60,11 @@
       methodHandle h_method =
         methodHandle(THREAD, JNIHandles::resolve_jmethod_id(probe->method));
       nmethod* nm = AdapterHandlerLibrary::create_dtrace_nmethod(h_method);
+      if (nm == NULL) {
+        delete probes;
+        THROW_MSG_0(vmSymbols::java_lang_RuntimeException(),
+          "Unable to register DTrace probes (CodeCache: no room for DTrace nmethods).");
+      }
       h_method()->set_not_compilable(CompLevel_highest_tier);
       h_method()->set_code(h_method, nm);
       probes->nmethod_at_put(count++, nm);
--- a/src/share/vm/runtime/globals.hpp	Fri May 08 14:33:58 2009 -0700
+++ b/src/share/vm/runtime/globals.hpp	Fri May 15 13:41:04 2009 -0700
@@ -1819,7 +1819,11 @@
           "Decay factor to TenuredGenerationSizeIncrement")                 \
                                                                             \
   product(uintx, MaxGCPauseMillis, max_uintx,                               \
-          "Adaptive size policy maximum GC pause time goal in msec")        \
+          "Adaptive size policy maximum GC pause time goal in msec, "       \
+          "or (G1 Only) the max. GC time per MMU time slice")               \
+                                                                            \
+  product(intx, GCPauseIntervalMillis, 500,                                 \
+          "Time slice for MMU specification")                               \
                                                                             \
   product(uintx, MaxGCMinorPauseMillis, max_uintx,                          \
           "Adaptive size policy maximum GC minor pause time goal in msec")  \
--- a/src/share/vm/runtime/sharedRuntime.cpp	Fri May 08 14:33:58 2009 -0700
+++ b/src/share/vm/runtime/sharedRuntime.cpp	Fri May 15 13:41:04 2009 -0700
@@ -1776,7 +1776,14 @@
 GrowableArray<uint64_t>* AdapterHandlerLibrary::_fingerprints = NULL;
 GrowableArray<AdapterHandlerEntry* >* AdapterHandlerLibrary::_handlers = NULL;
 const int AdapterHandlerLibrary_size = 16*K;
-u_char                   AdapterHandlerLibrary::_buffer[AdapterHandlerLibrary_size + 32];
+BufferBlob* AdapterHandlerLibrary::_buffer = NULL;
+
+BufferBlob* AdapterHandlerLibrary::buffer_blob() {
+  // Should be called only when AdapterHandlerLibrary_lock is active.
+  if (_buffer == NULL) // Initialize lazily
+      _buffer = BufferBlob::create("adapters", AdapterHandlerLibrary_size);
+  return _buffer;
+}
 
 void AdapterHandlerLibrary::initialize() {
   if (_fingerprints != NULL) return;
@@ -1812,7 +1819,9 @@
   assert(ic_miss != NULL, "must have handler");
 
   int result;
+  NOT_PRODUCT(int code_size);
   BufferBlob *B = NULL;
+  AdapterHandlerEntry* entry = NULL;
   uint64_t fingerprint;
   {
     MutexLocker mu(AdapterHandlerLibrary_lock);
@@ -1850,42 +1859,45 @@
 
     // Create I2C & C2I handlers
     ResourceMark rm;
-    // Improve alignment slightly
-    u_char *buf = (u_char*)(((intptr_t)_buffer + CodeEntryAlignment-1) & ~(CodeEntryAlignment-1));
-    CodeBuffer buffer(buf, AdapterHandlerLibrary_size);
-    short buffer_locs[20];
-    buffer.insts()->initialize_shared_locs((relocInfo*)buffer_locs,
-                                           sizeof(buffer_locs)/sizeof(relocInfo));
-    MacroAssembler _masm(&buffer);
 
-    // Fill in the signature array, for the calling-convention call.
-    int total_args_passed = method->size_of_parameters(); // All args on stack
+    BufferBlob*  buf = buffer_blob(); // the temporary code buffer in CodeCache
+    if (buf != NULL) {
+      CodeBuffer buffer(buf->instructions_begin(), buf->instructions_size());
+      short buffer_locs[20];
+      buffer.insts()->initialize_shared_locs((relocInfo*)buffer_locs,
+                                             sizeof(buffer_locs)/sizeof(relocInfo));
+      MacroAssembler _masm(&buffer);
 
-    BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType,total_args_passed);
-    VMRegPair  * regs   = NEW_RESOURCE_ARRAY(VMRegPair  ,total_args_passed);
-    int i=0;
-    if( !method->is_static() )  // Pass in receiver first
-      sig_bt[i++] = T_OBJECT;
-    for( SignatureStream ss(method->signature()); !ss.at_return_type(); ss.next()) {
-      sig_bt[i++] = ss.type();  // Collect remaining bits of signature
-      if( ss.type() == T_LONG || ss.type() == T_DOUBLE )
-        sig_bt[i++] = T_VOID;   // Longs & doubles take 2 Java slots
+      // Fill in the signature array, for the calling-convention call.
+      int total_args_passed = method->size_of_parameters(); // All args on stack
+
+      BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType,total_args_passed);
+      VMRegPair  * regs   = NEW_RESOURCE_ARRAY(VMRegPair  ,total_args_passed);
+      int i=0;
+      if( !method->is_static() )  // Pass in receiver first
+        sig_bt[i++] = T_OBJECT;
+      for( SignatureStream ss(method->signature()); !ss.at_return_type(); ss.next()) {
+        sig_bt[i++] = ss.type();  // Collect remaining bits of signature
+        if( ss.type() == T_LONG || ss.type() == T_DOUBLE )
+          sig_bt[i++] = T_VOID;   // Longs & doubles take 2 Java slots
+      }
+      assert( i==total_args_passed, "" );
+
+      // Now get the re-packed compiled-Java layout.
+      int comp_args_on_stack;
+
+      // Get a description of the compiled java calling convention and the largest used (VMReg) stack slot usage
+      comp_args_on_stack = SharedRuntime::java_calling_convention(sig_bt, regs, total_args_passed, false);
+
+      entry = SharedRuntime::generate_i2c2i_adapters(&_masm,
+                                                     total_args_passed,
+                                                     comp_args_on_stack,
+                                                     sig_bt,
+                                                     regs);
+
+      B = BufferBlob::create(AdapterHandlerEntry::name, &buffer);
+      NOT_PRODUCT(code_size = buffer.code_size());
     }
-    assert( i==total_args_passed, "" );
-
-    // Now get the re-packed compiled-Java layout.
-    int comp_args_on_stack;
-
-    // Get a description of the compiled java calling convention and the largest used (VMReg) stack slot usage
-    comp_args_on_stack = SharedRuntime::java_calling_convention(sig_bt, regs, total_args_passed, false);
-
-    AdapterHandlerEntry* entry = SharedRuntime::generate_i2c2i_adapters(&_masm,
-                                                                        total_args_passed,
-                                                                        comp_args_on_stack,
-                                                                        sig_bt,
-                                                                        regs);
-
-    B = BufferBlob::create(AdapterHandlerEntry::name, &buffer);
     if (B == NULL) {
       // CodeCache is full, disable compilation
       // Ought to log this but compile log is only per compile thread
@@ -1912,9 +1924,9 @@
       tty->cr();
       tty->print_cr("i2c argument handler #%d for: %s %s (fingerprint = 0x%llx, %d bytes generated)",
                     _handlers->length(), (method->is_static() ? "static" : "receiver"),
-                    method->signature()->as_C_string(), fingerprint, buffer.code_size() );
+                    method->signature()->as_C_string(), fingerprint, code_size );
       tty->print_cr("c2i argument handler starts at %p",entry->get_c2i_entry());
-      Disassembler::decode(entry->get_i2c_entry(), entry->get_i2c_entry() + buffer.code_size());
+      Disassembler::decode(entry->get_i2c_entry(), entry->get_i2c_entry() + code_size);
     }
 #endif
 
@@ -1982,42 +1994,44 @@
       return nm;
     }
 
-    // Improve alignment slightly
-    u_char* buf = (u_char*)(((intptr_t)_buffer + CodeEntryAlignment-1) & ~(CodeEntryAlignment-1));
-    CodeBuffer buffer(buf, AdapterHandlerLibrary_size);
-    // Need a few relocation entries
-    double locs_buf[20];
-    buffer.insts()->initialize_shared_locs((relocInfo*)locs_buf, sizeof(locs_buf) / sizeof(relocInfo));
-    MacroAssembler _masm(&buffer);
+    ResourceMark rm;
 
-    // Fill in the signature array, for the calling-convention call.
-    int total_args_passed = method->size_of_parameters();
+    BufferBlob*  buf = buffer_blob(); // the temporary code buffer in CodeCache
+    if (buf != NULL) {
+      CodeBuffer buffer(buf->instructions_begin(), buf->instructions_size());
+      double locs_buf[20];
+      buffer.insts()->initialize_shared_locs((relocInfo*)locs_buf, sizeof(locs_buf) / sizeof(relocInfo));
+      MacroAssembler _masm(&buffer);
 
-    BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType,total_args_passed);
-    VMRegPair  * regs   = NEW_RESOURCE_ARRAY(VMRegPair  ,total_args_passed);
-    int i=0;
-    if( !method->is_static() )  // Pass in receiver first
-      sig_bt[i++] = T_OBJECT;
-    SignatureStream ss(method->signature());
-    for( ; !ss.at_return_type(); ss.next()) {
-      sig_bt[i++] = ss.type();  // Collect remaining bits of signature
-      if( ss.type() == T_LONG || ss.type() == T_DOUBLE )
-        sig_bt[i++] = T_VOID;   // Longs & doubles take 2 Java slots
+      // Fill in the signature array, for the calling-convention call.
+      int total_args_passed = method->size_of_parameters();
+
+      BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType,total_args_passed);
+      VMRegPair*   regs = NEW_RESOURCE_ARRAY(VMRegPair,total_args_passed);
+      int i=0;
+      if( !method->is_static() )  // Pass in receiver first
+        sig_bt[i++] = T_OBJECT;
+      SignatureStream ss(method->signature());
+      for( ; !ss.at_return_type(); ss.next()) {
+        sig_bt[i++] = ss.type();  // Collect remaining bits of signature
+        if( ss.type() == T_LONG || ss.type() == T_DOUBLE )
+          sig_bt[i++] = T_VOID;   // Longs & doubles take 2 Java slots
+      }
+      assert( i==total_args_passed, "" );
+      BasicType ret_type = ss.type();
+
+      // Now get the compiled-Java layout as input arguments
+      int comp_args_on_stack;
+      comp_args_on_stack = SharedRuntime::java_calling_convention(sig_bt, regs, total_args_passed, false);
+
+      // Generate the compiled-to-native wrapper code
+      nm = SharedRuntime::generate_native_wrapper(&_masm,
+                                                  method,
+                                                  total_args_passed,
+                                                  comp_args_on_stack,
+                                                  sig_bt,regs,
+                                                  ret_type);
     }
-    assert( i==total_args_passed, "" );
-    BasicType ret_type = ss.type();
-
-    // Now get the compiled-Java layout as input arguments
-    int comp_args_on_stack;
-    comp_args_on_stack = SharedRuntime::java_calling_convention(sig_bt, regs, total_args_passed, false);
-
-    // Generate the compiled-to-native wrapper code
-    nm = SharedRuntime::generate_native_wrapper(&_masm,
-                                                method,
-                                                total_args_passed,
-                                                comp_args_on_stack,
-                                                sig_bt,regs,
-                                                ret_type);
   }
 
   // Must unlock before calling set_code
@@ -2077,18 +2091,20 @@
       return nm;
     }
 
-    // Improve alignment slightly
-    u_char* buf = (u_char*)
-        (((intptr_t)_buffer + CodeEntryAlignment-1) & ~(CodeEntryAlignment-1));
-    CodeBuffer buffer(buf, AdapterHandlerLibrary_size);
-    // Need a few relocation entries
-    double locs_buf[20];
-    buffer.insts()->initialize_shared_locs(
+    ResourceMark rm;
+
+    BufferBlob*  buf = buffer_blob(); // the temporary code buffer in CodeCache
+    if (buf != NULL) {
+      CodeBuffer buffer(buf->instructions_begin(), buf->instructions_size());
+      // Need a few relocation entries
+      double locs_buf[20];
+      buffer.insts()->initialize_shared_locs(
         (relocInfo*)locs_buf, sizeof(locs_buf) / sizeof(relocInfo));
-    MacroAssembler _masm(&buffer);
+      MacroAssembler _masm(&buffer);
 
-    // Generate the compiled-to-native wrapper code
-    nm = SharedRuntime::generate_dtrace_nmethod(&_masm, method);
+      // Generate the compiled-to-native wrapper code
+      nm = SharedRuntime::generate_dtrace_nmethod(&_masm, method);
+    }
   }
   return nm;
 }
--- a/src/share/vm/runtime/sharedRuntime.hpp	Fri May 08 14:33:58 2009 -0700
+++ b/src/share/vm/runtime/sharedRuntime.hpp	Fri May 15 13:41:04 2009 -0700
@@ -557,12 +557,13 @@
 
 class AdapterHandlerLibrary: public AllStatic {
  private:
-  static u_char                   _buffer[];  // the temporary code buffer
+  static BufferBlob* _buffer; // the temporary code buffer in CodeCache
   static GrowableArray<uint64_t>* _fingerprints; // the fingerprint collection
   static GrowableArray<AdapterHandlerEntry*> * _handlers; // the corresponding handlers
   enum {
     AbstractMethodHandler = 1 // special handler for abstract methods
   };
+  static BufferBlob* buffer_blob();
   static void initialize();
   static int get_create_adapter_index(methodHandle method);
   static address get_i2c_entry( int index ) {
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/compiler/6837011/Test6837011.java	Fri May 15 13:41:04 2009 -0700
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+/**
+ * @test
+ * @bug 6837011
+ * @summary SIGSEGV in PhaseIdealLoop in 32bit jvm
+ *
+ * @run main/othervm -Xcomp -XX:CompileOnly=Test6837011.main Test6837011
+ */
+
+public class Test6837011 {
+    static boolean var_3 = true;
+
+    public static void main(String[] args) {
+        double var_5;
+        char var_7 = 1;
+        double var_11 = 0;
+
+        do {
+            var_11++;
+            var_5 = (var_7 /= ( var_3 ? ~1L : 3 ) );
+        } while (var_11 < 1);
+    }
+}