# HG changeset patch # User acorn # Date 1331270900 18000 # Node ID d59a6302465aaac406880e4db711ea02305d7d75 # Parent fdf4deca44ecae384c550c7b666c20a8c751d8fc# Parent 8a48c2906f91e7c6e77edbae0b8ca5f6b5d44a09 Merge diff -r 8a48c2906f91 -r d59a6302465a .hgtags --- a/.hgtags Mon Mar 05 14:19:00 2012 -0500 +++ b/.hgtags Fri Mar 09 00:28:20 2012 -0500 @@ -226,3 +226,5 @@ 931e5f39e365a0d550d79148ff87a7f9e864d2e1 hs23-b16 3b24e7e01d20ca590d0f86b1222bb7c3f1a2aa2d jdk8-b27 975c4105f1e2ef1190a75b77124033f1fd4290b5 hs24-b01 +b183b0863611b85dbac16f3b08b40ba978756d19 jdk8-b28 +030b5306d60f140e822e4a6d301744cb110ff0c8 hs24-b02 diff -r 8a48c2906f91 -r d59a6302465a make/Makefile --- a/make/Makefile Mon Mar 05 14:19:00 2012 -0500 +++ b/make/Makefile Fri Mar 09 00:28:20 2012 -0500 @@ -378,6 +378,9 @@ $(EXPORT_LIB_DIR)/%.jar: $(GEN_DIR)/%.jar $(install-file) +$(EXPORT_JRE_LIB_DIR)/%.jar: $(GEN_DIR)/%.jar + $(install-file) + # Include files (jvmti.h, jvmticmlr.h, jni.h, $(JDK_INCLUDE_SUBDIR)/jni_md.h, jmm.h, jfr.h) $(EXPORT_INCLUDE_DIR)/%: $(GEN_DIR)/jvmtifiles/% $(install-file) diff -r 8a48c2906f91 -r d59a6302465a make/bsd/makefiles/defs.make --- a/make/bsd/makefiles/defs.make Mon Mar 05 14:19:00 2012 -0500 +++ b/make/bsd/makefiles/defs.make Fri Mar 09 00:28:20 2012 -0500 @@ -144,6 +144,8 @@ EXPORT_SERVER_DIR = $(EXPORT_JRE_LIB_ARCH_DIR)/server EXPORT_CLIENT_DIR = $(EXPORT_JRE_LIB_ARCH_DIR)/client +EXPORT_LIST += $(EXPORT_JRE_LIB_DIR)/wb.jar + ifndef BUILD_CLIENT_ONLY EXPORT_LIST += $(EXPORT_SERVER_DIR)/Xusage.txt EXPORT_LIST += $(EXPORT_SERVER_DIR)/libjvm.$(LIBRARY_SUFFIX) diff -r 8a48c2906f91 -r d59a6302465a make/bsd/makefiles/vm.make --- a/make/bsd/makefiles/vm.make Mon Mar 05 14:19:00 2012 -0500 +++ b/make/bsd/makefiles/vm.make Fri Mar 09 00:28:20 2012 -0500 @@ -1,5 +1,5 @@ # -# Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 1999, 2012, 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 @@ -335,6 +335,9 @@ # Serviceability agent include $(MAKEFILES_DIR)/saproc.make +# Whitebox testing API +include $(MAKEFILES_DIR)/wb.make + #---------------------------------------------------------------------- ifeq ($(OS_VENDOR), Darwin) @@ -342,10 +345,10 @@ dsymutil $(LIBJVM) # no libjvm_db for macosx -build: $(LIBJVM) $(LAUNCHER) $(LIBJSIG) $(BUILDLIBSAPROC) dtraceCheck $(LIBJVM).dSYM +build: $(LIBJVM) $(LAUNCHER) $(LIBJSIG) $(BUILDLIBSAPROC) dtraceCheck $(LIBJVM).dSYM $(WB_JAR) echo "Doing vm.make build:" else -build: $(LIBJVM) $(LAUNCHER) $(LIBJSIG) $(LIBJVM_DB) $(BUILDLIBSAPROC) +build: $(LIBJVM) $(LAUNCHER) $(LIBJSIG) $(LIBJVM_DB) $(BUILDLIBSAPROC) $(WB_JAR) endif install: install_jvm install_jsig install_saproc diff -r 8a48c2906f91 -r d59a6302465a make/bsd/makefiles/wb.make --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/make/bsd/makefiles/wb.make Fri Mar 09 00:28:20 2012 -0500 @@ -0,0 +1,46 @@ +# +# Copyright (c) 2012, 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. +# +# + +# Rules to build whitebox testing library, used by vm.make +WB = wb + +WBSRCDIR = $(GAMMADIR)/src/share/tools/whitebox + +WB_JAR = $(GENERATED)/$(WB).jar + +WB_JAVA_SRCS = $(shell find $(WBSRCDIR) -name '*.java') +WB_JAVA_CLASSDIR = $(GENERATED)/wb/classes + +WB_JAVA_CLASSES = $(patsubst $(WBSRCDIR)/%,$(WB_JAVA_CLASSDIR)/%, \ + $(patsubst %.java,%.class,$(WB_JAVA_SRCS))) + +$(WB_JAVA_CLASSDIR)/%.class: $(WBSRCDIR)/%.java $(WB_JAVA_CLASSDIR) + $(REMOTE) $(COMPILE.JAVAC) -nowarn -d $(WB_JAVA_CLASSDIR) $< + +$(WB_JAR): $(WB_JAVA_CLASSES) + $(QUIETLY) $(REMOTE) $(RUN.JAR) cf $@ -C $(WB_JAVA_CLASSDIR)/ . + +$(WB_JAVA_CLASSDIR): + $(QUIETLY) mkdir -p $@ + diff -r 8a48c2906f91 -r d59a6302465a make/hotspot_version --- a/make/hotspot_version Mon Mar 05 14:19:00 2012 -0500 +++ b/make/hotspot_version Fri Mar 09 00:28:20 2012 -0500 @@ -35,7 +35,7 @@ HS_MAJOR_VER=24 HS_MINOR_VER=0 -HS_BUILD_NUMBER=02 +HS_BUILD_NUMBER=03 JDK_MAJOR_VER=1 JDK_MINOR_VER=8 diff -r 8a48c2906f91 -r d59a6302465a make/jprt.properties --- a/make/jprt.properties Mon Mar 05 14:19:00 2012 -0500 +++ b/make/jprt.properties Fri Mar 09 00:28:20 2012 -0500 @@ -1,5 +1,5 @@ # -# Copyright (c) 2006, 2011, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2006, 2012, 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 @@ -54,58 +54,72 @@ # Define the Solaris platforms we want for the various releases jprt.my.solaris.sparc.jdk8=solaris_sparc_5.10 jprt.my.solaris.sparc.jdk7=solaris_sparc_5.10 +jprt.my.solaris.sparc.jdk7u4=${jprt.my.solaris.sparc.jdk7} jprt.my.solaris.sparc=${jprt.my.solaris.sparc.${jprt.tools.default.release}} jprt.my.solaris.sparcv9.jdk8=solaris_sparcv9_5.10 jprt.my.solaris.sparcv9.jdk7=solaris_sparcv9_5.10 +jprt.my.solaris.sparcv9.jdk7u4=${jprt.my.solaris.sparcv9.jdk7} jprt.my.solaris.sparcv9=${jprt.my.solaris.sparcv9.${jprt.tools.default.release}} jprt.my.solaris.i586.jdk8=solaris_i586_5.10 jprt.my.solaris.i586.jdk7=solaris_i586_5.10 +jprt.my.solaris.i586.jdk7u4=${jprt.my.solaris.i586.jdk7} jprt.my.solaris.i586=${jprt.my.solaris.i586.${jprt.tools.default.release}} jprt.my.solaris.x64.jdk8=solaris_x64_5.10 jprt.my.solaris.x64.jdk7=solaris_x64_5.10 +jprt.my.solaris.x64.jdk7u4=${jprt.my.solaris.x64.jdk7} jprt.my.solaris.x64=${jprt.my.solaris.x64.${jprt.tools.default.release}} jprt.my.linux.i586.jdk8=linux_i586_2.6 jprt.my.linux.i586.jdk7=linux_i586_2.6 +jprt.my.linux.i586.jdk7u4=${jprt.my.linux.i586.jdk7} jprt.my.linux.i586=${jprt.my.linux.i586.${jprt.tools.default.release}} jprt.my.linux.x64.jdk8=linux_x64_2.6 jprt.my.linux.x64.jdk7=linux_x64_2.6 +jprt.my.linux.x64.jdk7u4=${jprt.my.linux.x64.jdk7} jprt.my.linux.x64=${jprt.my.linux.x64.${jprt.tools.default.release}} jprt.my.linux.ppc.jdk8=linux_ppc_2.6 jprt.my.linux.ppc.jdk7=linux_ppc_2.6 +jprt.my.linux.ppc.jdk7u4=${jprt.my.linux.ppc.jdk7} jprt.my.linux.ppc=${jprt.my.linux.ppc.${jprt.tools.default.release}} jprt.my.linux.ppcv2.jdk8=linux_ppcv2_2.6 jprt.my.linux.ppcv2.jdk7=linux_ppcv2_2.6 +jprt.my.linux.ppcv2.jdk7u4=${jprt.my.linux.ppcv2.jdk7} jprt.my.linux.ppcv2=${jprt.my.linux.ppcv2.${jprt.tools.default.release}} jprt.my.linux.ppcsflt.jdk8=linux_ppcsflt_2.6 jprt.my.linux.ppcsflt.jdk7=linux_ppcsflt_2.6 +jprt.my.linux.ppcsflt.jdk7u4=${jprt.my.linux.ppcsflt.jdk7} jprt.my.linux.ppcsflt=${jprt.my.linux.ppcsflt.${jprt.tools.default.release}} jprt.my.linux.armvfp.jdk8=linux_armvfp_2.6 jprt.my.linux.armvfp.jdk7=linux_armvfp_2.6 +jprt.my.linux.armvfp.jdk7u4=${jprt.my.linux.armvfp.jdk7} jprt.my.linux.armvfp=${jprt.my.linux.armvfp.${jprt.tools.default.release}} jprt.my.linux.armsflt.jdk8=linux_armsflt_2.6 jprt.my.linux.armsflt.jdk7=linux_armsflt_2.6 +jprt.my.linux.armsflt.jdk7u4=${jprt.my.linux.armsflt.jdk7} jprt.my.linux.armsflt=${jprt.my.linux.armsflt.${jprt.tools.default.release}} jprt.my.macosx.x64.jdk8=macosx_x64_10.7 jprt.my.macosx.x64.jdk7=macosx_x64_10.7 +jprt.my.macosx.x64.jdk7u4=${jprt.my.macosx.x64.jdk7} jprt.my.macosx.x64=${jprt.my.macosx.x64.${jprt.tools.default.release}} jprt.my.windows.i586.jdk8=windows_i586_5.1 jprt.my.windows.i586.jdk7=windows_i586_5.1 +jprt.my.windows.i586.jdk7u4=${jprt.my.windows.i586.jdk7} jprt.my.windows.i586=${jprt.my.windows.i586.${jprt.tools.default.release}} jprt.my.windows.x64.jdk8=windows_x64_5.2 jprt.my.windows.x64.jdk7=windows_x64_5.2 +jprt.my.windows.x64.jdk7u4=${jprt.my.windows.x64.jdk7} jprt.my.windows.x64=${jprt.my.windows.x64.${jprt.tools.default.release}} # Standard list of jprt build targets for this source tree @@ -139,16 +153,7 @@ jprt.build.targets.jdk8=${jprt.build.targets.all} jprt.build.targets.jdk7=${jprt.build.targets.all} -jprt.build.targets.jdk7temp=${jprt.build.targets.all} -jprt.build.targets.jdk7b107=${jprt.build.targets.all} -jprt.build.targets.jdk6=${jprt.build.targets.standard} -jprt.build.targets.jdk6perf=${jprt.build.targets.standard} -jprt.build.targets.jdk6u10=${jprt.build.targets.standard} -jprt.build.targets.jdk6u14=${jprt.build.targets.standard} -jprt.build.targets.jdk6u18=${jprt.build.targets.standard} -jprt.build.targets.jdk6u20=${jprt.build.targets.standard} -jprt.build.targets.ejdk6=${jprt.build.targets.all} -jprt.build.targets.ejdk7=${jprt.build.targets.all} +jprt.build.targets.jdk7u4=${jprt.build.targets.all} jprt.build.targets=${jprt.build.targets.${jprt.tools.default.release}} # Subset lists of test targets for this source tree @@ -474,11 +479,26 @@ ${jprt.my.macosx.x64}-fastdebug-c2-internalvmtests, \ ${jprt.my.windows.i586}-fastdebug-c2-internalvmtests, \ ${jprt.my.windows.x64}-fastdebug-c2-internalvmtests - + +jprt.make.rule.test.targets.standard.wbapi = \ + ${jprt.my.solaris.sparc}-{product|fastdebug}-c2-wbapitest, \ + ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-wbapitest, \ + ${jprt.my.solaris.i586}-{product|fastdebug}-c2-wbapitest, \ + ${jprt.my.solaris.x64}-{product|fastdebug}-c2-wbapitest, \ + ${jprt.my.linux.i586}-{product|fastdebug}-c2-wbapitest, \ + ${jprt.my.linux.x64}-{product|fastdebug}-c2-wbapitest, \ + ${jprt.my.windows.i586}-{product|fastdebug}-c2-wbapitest, \ + ${jprt.my.windows.x64}-{product|fastdebug}-c2-wbapitest, \ + ${jprt.my.solaris.sparc}-{product|fastdebug}-c1-wbapitest, \ + ${jprt.my.solaris.i586}-{product|fastdebug}-c1-wbapitest, \ + ${jprt.my.linux.i586}-{product|fastdebug}-c1-wbapitest, \ + ${jprt.my.windows.i586}-{product|fastdebug}-c1-wbapitest + jprt.make.rule.test.targets.standard = \ ${jprt.make.rule.test.targets.standard.client}, \ ${jprt.make.rule.test.targets.standard.server}, \ - ${jprt.make.rule.test.targets.standard.internalvmtests} + ${jprt.make.rule.test.targets.standard.internalvmtests}, \ + ${jprt.make.rule.test.targets.standard.wbapi} jprt.make.rule.test.targets.embedded = \ ${jprt.make.rule.test.targets.standard.client} diff -r 8a48c2906f91 -r d59a6302465a make/linux/makefiles/defs.make --- a/make/linux/makefiles/defs.make Mon Mar 05 14:19:00 2012 -0500 +++ b/make/linux/makefiles/defs.make Fri Mar 09 00:28:20 2012 -0500 @@ -1,5 +1,5 @@ # -# Copyright (c) 2006, 2011, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2006, 2012, 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 @@ -193,6 +193,8 @@ EXPORT_SERVER_DIR = $(EXPORT_JRE_LIB_ARCH_DIR)/server EXPORT_CLIENT_DIR = $(EXPORT_JRE_LIB_ARCH_DIR)/client +EXPORT_LIST += $(EXPORT_JRE_LIB_DIR)/wb.jar + ifndef BUILD_CLIENT_ONLY EXPORT_LIST += $(EXPORT_SERVER_DIR)/Xusage.txt EXPORT_LIST += $(EXPORT_SERVER_DIR)/libjvm.$(LIBRARY_SUFFIX) diff -r 8a48c2906f91 -r d59a6302465a make/linux/makefiles/vm.make --- a/make/linux/makefiles/vm.make Mon Mar 05 14:19:00 2012 -0500 +++ b/make/linux/makefiles/vm.make Fri Mar 09 00:28:20 2012 -0500 @@ -1,5 +1,5 @@ # -# Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 1999, 2012, 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 @@ -368,9 +368,12 @@ # Serviceability agent include $(MAKEFILES_DIR)/saproc.make +# Whitebox testing API +include $(MAKEFILES_DIR)/wb.make + #---------------------------------------------------------------------- -build: $(LIBJVM) $(LAUNCHER) $(LIBJSIG) $(LIBJVM_DB) $(BUILDLIBSAPROC) +build: $(LIBJVM) $(LAUNCHER) $(LIBJSIG) $(LIBJVM_DB) $(BUILDLIBSAPROC) $(WB_JAR) install: install_jvm install_jsig install_saproc diff -r 8a48c2906f91 -r d59a6302465a make/linux/makefiles/wb.make --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/make/linux/makefiles/wb.make Fri Mar 09 00:28:20 2012 -0500 @@ -0,0 +1,46 @@ +# +# Copyright (c) 2012, 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. +# +# + +# Rules to build whitebox testing library, used by vm.make +WB = wb + +WBSRCDIR = $(GAMMADIR)/src/share/tools/whitebox + +WB_JAR = $(GENERATED)/$(WB).jar + +WB_JAVA_SRCS = $(shell find $(WBSRCDIR) -name '*.java') +WB_JAVA_CLASSDIR = $(GENERATED)/wb/classes + +WB_JAVA_CLASSES = $(patsubst $(WBSRCDIR)/%,$(WB_JAVA_CLASSDIR)/%, \ + $(patsubst %.java,%.class,$(WB_JAVA_SRCS))) + +$(WB_JAVA_CLASSDIR)/%.class: $(WBSRCDIR)/%.java $(WB_JAVA_CLASSDIR) + $(REMOTE) $(COMPILE.JAVAC) -nowarn -d $(WB_JAVA_CLASSDIR) $< + +$(WB_JAR): $(WB_JAVA_CLASSES) + $(QUIETLY) $(REMOTE) $(RUN.JAR) cf $@ -C $(WB_JAVA_CLASSDIR)/ . + +$(WB_JAVA_CLASSDIR): + $(QUIETLY) mkdir -p $@ + diff -r 8a48c2906f91 -r d59a6302465a make/solaris/makefiles/defs.make --- a/make/solaris/makefiles/defs.make Mon Mar 05 14:19:00 2012 -0500 +++ b/make/solaris/makefiles/defs.make Fri Mar 09 00:28:20 2012 -0500 @@ -1,5 +1,5 @@ # -# Copyright (c) 2006, 2011, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2006, 2012, 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 @@ -148,6 +148,8 @@ EXPORT_LIST += $(EXPORT_JRE_LIB_ARCH_DIR)/libjsig.debuginfo endif +EXPORT_LIST += $(EXPORT_JRE_LIB_DIR)/wb.jar + EXPORT_SERVER_DIR = $(EXPORT_JRE_LIB_ARCH_DIR)/server EXPORT_CLIENT_DIR = $(EXPORT_JRE_LIB_ARCH_DIR)/client diff -r 8a48c2906f91 -r d59a6302465a make/solaris/makefiles/vm.make --- a/make/solaris/makefiles/vm.make Mon Mar 05 14:19:00 2012 -0500 +++ b/make/solaris/makefiles/vm.make Fri Mar 09 00:28:20 2012 -0500 @@ -1,5 +1,5 @@ # -# Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 1998, 2012, 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 @@ -321,9 +321,12 @@ # Serviceability agent include $(MAKEFILES_DIR)/saproc.make +# Whitebox testing API +include $(MAKEFILES_DIR)/wb.make + #---------------------------------------------------------------------- -build: $(LIBJVM) $(LAUNCHER) $(LIBJSIG) $(LIBJVM_DB) $(LIBJVM_DTRACE) $(BUILDLIBSAPROC) dtraceCheck +build: $(LIBJVM) $(LAUNCHER) $(LIBJSIG) $(LIBJVM_DB) $(LIBJVM_DTRACE) $(BUILDLIBSAPROC) dtraceCheck $(WB_JAR) install: install_jvm install_jsig install_saproc diff -r 8a48c2906f91 -r d59a6302465a make/solaris/makefiles/wb.make --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/make/solaris/makefiles/wb.make Fri Mar 09 00:28:20 2012 -0500 @@ -0,0 +1,46 @@ +# +# Copyright (c) 2012, 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. +# + +# Rules to build whitebox testing library, used by vm.make + +WB = wb + +WBSRCDIR = $(GAMMADIR)/src/share/tools/whitebox + +WB_JAR = $(GENERATED)/$(WB).jar + +WB_JAVA_SRCS = $(shell find $(WBSRCDIR) -name '*.java') +WB_JAVA_CLASSDIR = $(GENERATED)/wb/classes + +WB_JAVA_CLASSES = $(patsubst $(WBSRCDIR)/%,$(WB_JAVA_CLASSDIR)/%, \ + $(patsubst %.java,%.class,$(WB_JAVA_SRCS))) + +$(WB_JAVA_CLASSDIR)/%.class: $(WBSRCDIR)/%.java $(WB_JAVA_CLASSDIR) + $(REMOTE) $(COMPILE.JAVAC) -nowarn -d $(WB_JAVA_CLASSDIR) $< + +$(WB_JAR): $(WB_JAVA_CLASSES) + $(QUIETLY) $(REMOTE) $(RUN.JAR) cf $@ -C $(WB_JAVA_CLASSDIR)/ . + +$(WB_JAVA_CLASSDIR): + $(QUIETLY) mkdir -p $@ + diff -r 8a48c2906f91 -r d59a6302465a make/windows/makefiles/debug.make --- a/make/windows/makefiles/debug.make Mon Mar 05 14:19:00 2012 -0500 +++ b/make/windows/makefiles/debug.make Fri Mar 09 00:28:20 2012 -0500 @@ -1,5 +1,5 @@ # -# Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # This code is free software; you can redistribute it and/or modify it @@ -33,7 +33,7 @@ BUILD_PCH_FILE=_build_pch_file.obj !endif -default:: $(BUILD_PCH_FILE) $(AOUT) launcher checkAndBuildSA +default:: $(BUILD_PCH_FILE) $(AOUT) launcher checkAndBuildSA wb !include ../local.make !include compile.make @@ -65,3 +65,4 @@ !include $(WorkSpace)/make/windows/makefiles/shared.make !include $(WorkSpace)/make/windows/makefiles/sa.make !include $(WorkSpace)/make/windows/makefiles/launcher.make +!include $(WorkSpace)/make/windows/makefiles/wb.make diff -r 8a48c2906f91 -r d59a6302465a make/windows/makefiles/defs.make --- a/make/windows/makefiles/defs.make Mon Mar 05 14:19:00 2012 -0500 +++ b/make/windows/makefiles/defs.make Fri Mar 09 00:28:20 2012 -0500 @@ -1,5 +1,5 @@ # -# Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2006, 2012, 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 @@ -194,6 +194,8 @@ EXPORT_LIST += $(EXPORT_KERNEL_DIR)/jvm.map endif +EXPORT_LIST += $(EXPORT_JRE_LIB_DIR)/wb.jar + ifeq ($(BUILD_WIN_SA), 1) EXPORT_LIST += $(EXPORT_JRE_BIN_DIR)/sawindbg.$(LIBRARY_SUFFIX) EXPORT_LIST += $(EXPORT_JRE_BIN_DIR)/sawindbg.pdb diff -r 8a48c2906f91 -r d59a6302465a make/windows/makefiles/fastdebug.make --- a/make/windows/makefiles/fastdebug.make Mon Mar 05 14:19:00 2012 -0500 +++ b/make/windows/makefiles/fastdebug.make Fri Mar 09 00:28:20 2012 -0500 @@ -1,5 +1,5 @@ # -# Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2005, 2012, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # This code is free software; you can redistribute it and/or modify it @@ -33,7 +33,7 @@ BUILD_PCH_FILE=_build_pch_file.obj !endif -default:: $(BUILD_PCH_FILE) $(AOUT) launcher checkAndBuildSA +default:: $(BUILD_PCH_FILE) $(AOUT) launcher checkAndBuildSA wb !include ../local.make !include compile.make @@ -65,3 +65,4 @@ !include $(WorkSpace)/make/windows/makefiles/shared.make !include $(WorkSpace)/make/windows/makefiles/sa.make !include $(WorkSpace)/make/windows/makefiles/launcher.make +!include $(WorkSpace)/make/windows/makefiles/wb.make diff -r 8a48c2906f91 -r d59a6302465a make/windows/makefiles/product.make --- a/make/windows/makefiles/product.make Mon Mar 05 14:19:00 2012 -0500 +++ b/make/windows/makefiles/product.make Fri Mar 09 00:28:20 2012 -0500 @@ -1,5 +1,5 @@ # -# Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2005, 2012, 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 @@ -32,7 +32,7 @@ BUILD_PCH_FILE=_build_pch_file.obj !endif -default:: $(BUILD_PCH_FILE) $(AOUT) launcher checkAndBuildSA +default:: $(BUILD_PCH_FILE) $(AOUT) launcher checkAndBuildSA wb !include ../local.make !include compile.make @@ -76,3 +76,4 @@ !include $(WorkSpace)/make/windows/makefiles/shared.make !include $(WorkSpace)/make/windows/makefiles/sa.make !include $(WorkSpace)/make/windows/makefiles/launcher.make +!include $(WorkSpace)/make/windows/makefiles/wb.make diff -r 8a48c2906f91 -r d59a6302465a make/windows/makefiles/wb.make --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/make/windows/makefiles/wb.make Fri Mar 09 00:28:20 2012 -0500 @@ -0,0 +1,54 @@ +# +# Copyright (c) 2012, 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. +# +# + +# This makefile is used to build the whitebox testing lib +# and compile the tests which use it + +!include $(WorkSpace)/make/windows/makefiles/rules.make + +WBSRCDIR = $(WorkSpace)/src/share/tools/whitebox + +# turn GENERATED into a windows path to get sane dependencies +WB_CLASSES=$(GENERATED:/=\)\wb\classes +WB_JAR=$(GENERATED:/=\)\wb.jar + +# call recursive make to do wildcard expansion +.SUFFIXES : .java .class +wb_java_srcs: $(WorkSpace)\src\share\tools\whitebox\sun\hotspot\*.java $(WB_CLASSES) + $(MAKE) -f $(WorkSpace)\make\windows\makefiles\$(BUILD_FLAVOR).make $(**:.java=.class) + + +{$(WorkSpace)\src\share\tools\whitebox\sun\hotspot}.java.class:: + $(COMPILE_JAVAC) -d $(WB_CLASSES) $< + +$(WB_JAR): wb_java_srcs + $(RUN_JAR) cf $@ -C $(WB_CLASSES) . + +# turn $@ to a unix path because mkdir in PATH is cygwin/mks mkdir +$(WB_CLASSES): + mkdir -p $(@:\=/) + +# main target to build wb +wb: $(WB_JAR) + diff -r 8a48c2906f91 -r d59a6302465a src/cpu/x86/vm/c1_Runtime1_x86.cpp --- a/src/cpu/x86/vm/c1_Runtime1_x86.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/cpu/x86/vm/c1_Runtime1_x86.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -47,6 +47,12 @@ assert(!(oop_result1->is_valid() || oop_result2->is_valid()) || oop_result1 != oop_result2, "registers must be different"); assert(oop_result1 != thread && oop_result2 != thread, "registers must be different"); assert(args_size >= 0, "illegal args_size"); + bool align_stack = false; +#ifdef _LP64 + // At a method handle call, the stack may not be properly aligned + // when returning with an exception. + align_stack = (stub_id() == Runtime1::handle_exception_from_callee_id); +#endif #ifdef _LP64 mov(c_rarg0, thread); @@ -59,11 +65,21 @@ push(thread); #endif // _LP64 - set_last_Java_frame(thread, noreg, rbp, NULL); + int call_offset; + if (!align_stack) { + set_last_Java_frame(thread, noreg, rbp, NULL); + } else { + address the_pc = pc(); + call_offset = offset(); + set_last_Java_frame(thread, noreg, rbp, the_pc); + andptr(rsp, -(StackAlignmentInBytes)); // Align stack + } // do the call call(RuntimeAddress(entry)); - int call_offset = offset(); + if (!align_stack) { + call_offset = offset(); + } // verify callee-saved register #ifdef ASSERT guarantee(thread != rax, "change this code"); @@ -78,7 +94,7 @@ } pop(rax); #endif - reset_last_Java_frame(thread, true, false); + reset_last_Java_frame(thread, true, align_stack); // discard thread and arguments NOT_LP64(addptr(rsp, num_rt_args()*BytesPerWord)); diff -r 8a48c2906f91 -r d59a6302465a src/cpu/x86/vm/sharedRuntime_x86_64.cpp --- a/src/cpu/x86/vm/sharedRuntime_x86_64.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/cpu/x86/vm/sharedRuntime_x86_64.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -1181,14 +1181,13 @@ BasicType* in_sig_bt) { // if map is non-NULL then the code should store the values, // otherwise it should load them. - int handle_index = 0; + int slot = arg_save_area; // Save down double word first for ( int i = 0; i < total_in_args; i++) { if (in_regs[i].first()->is_XMMRegister() && in_sig_bt[i] == T_DOUBLE) { - int slot = handle_index * VMRegImpl::slots_per_word + arg_save_area; int offset = slot * VMRegImpl::stack_slot_size; - handle_index += 2; - assert(handle_index <= stack_slots, "overflow"); + slot += VMRegImpl::slots_per_word; + assert(slot <= stack_slots, "overflow"); if (map != NULL) { __ movdbl(Address(rsp, offset), in_regs[i].first()->as_XMMRegister()); } else { @@ -1197,10 +1196,7 @@ } if (in_regs[i].first()->is_Register() && (in_sig_bt[i] == T_LONG || in_sig_bt[i] == T_ARRAY)) { - int slot = handle_index * VMRegImpl::slots_per_word + arg_save_area; int offset = slot * VMRegImpl::stack_slot_size; - handle_index += 2; - assert(handle_index <= stack_slots, "overflow"); if (map != NULL) { __ movq(Address(rsp, offset), in_regs[i].first()->as_Register()); if (in_sig_bt[i] == T_ARRAY) { @@ -1209,14 +1205,15 @@ } else { __ movq(in_regs[i].first()->as_Register(), Address(rsp, offset)); } + slot += VMRegImpl::slots_per_word; } } // Save or restore single word registers for ( int i = 0; i < total_in_args; i++) { if (in_regs[i].first()->is_Register()) { - int slot = handle_index++ * VMRegImpl::slots_per_word + arg_save_area; int offset = slot * VMRegImpl::stack_slot_size; - assert(handle_index <= stack_slots, "overflow"); + slot++; + assert(slot <= stack_slots, "overflow"); // Value is in an input register pass we must flush it to the stack const Register reg = in_regs[i].first()->as_Register(); @@ -1241,9 +1238,9 @@ } } else if (in_regs[i].first()->is_XMMRegister()) { if (in_sig_bt[i] == T_FLOAT) { - int slot = handle_index++ * VMRegImpl::slots_per_word + arg_save_area; int offset = slot * VMRegImpl::stack_slot_size; - assert(handle_index <= stack_slots, "overflow"); + slot++; + assert(slot <= stack_slots, "overflow"); if (map != NULL) { __ movflt(Address(rsp, offset), in_regs[i].first()->as_XMMRegister()); } else { @@ -1368,6 +1365,174 @@ __ bind(done); } + +class ComputeMoveOrder: public StackObj { + class MoveOperation: public ResourceObj { + friend class ComputeMoveOrder; + private: + VMRegPair _src; + VMRegPair _dst; + int _src_index; + int _dst_index; + bool _processed; + MoveOperation* _next; + MoveOperation* _prev; + + static int get_id(VMRegPair r) { + return r.first()->value(); + } + + public: + MoveOperation(int src_index, VMRegPair src, int dst_index, VMRegPair dst): + _src(src) + , _src_index(src_index) + , _dst(dst) + , _dst_index(dst_index) + , _next(NULL) + , _prev(NULL) + , _processed(false) { + } + + VMRegPair src() const { return _src; } + int src_id() const { return get_id(src()); } + int src_index() const { return _src_index; } + VMRegPair dst() const { return _dst; } + void set_dst(int i, VMRegPair dst) { _dst_index = i, _dst = dst; } + int dst_index() const { return _dst_index; } + int dst_id() const { return get_id(dst()); } + MoveOperation* next() const { return _next; } + MoveOperation* prev() const { return _prev; } + void set_processed() { _processed = true; } + bool is_processed() const { return _processed; } + + // insert + void break_cycle(VMRegPair temp_register) { + // create a new store following the last store + // to move from the temp_register to the original + MoveOperation* new_store = new MoveOperation(-1, temp_register, dst_index(), dst()); + + // break the cycle of links and insert new_store at the end + // break the reverse link. + MoveOperation* p = prev(); + assert(p->next() == this, "must be"); + _prev = NULL; + p->_next = new_store; + new_store->_prev = p; + + // change the original store to save it's value in the temp. + set_dst(-1, temp_register); + } + + void link(GrowableArray& killer) { + // link this store in front the store that it depends on + MoveOperation* n = killer.at_grow(src_id(), NULL); + if (n != NULL) { + assert(_next == NULL && n->_prev == NULL, "shouldn't have been set yet"); + _next = n; + n->_prev = this; + } + } + }; + + private: + GrowableArray edges; + + public: + ComputeMoveOrder(int total_in_args, VMRegPair* in_regs, int total_c_args, VMRegPair* out_regs, + BasicType* in_sig_bt, GrowableArray& arg_order, VMRegPair tmp_vmreg) { + // Move operations where the dest is the stack can all be + // scheduled first since they can't interfere with the other moves. + for (int i = total_in_args - 1, c_arg = total_c_args - 1; i >= 0; i--, c_arg--) { + if (in_sig_bt[i] == T_ARRAY) { + c_arg--; + if (out_regs[c_arg].first()->is_stack() && + out_regs[c_arg + 1].first()->is_stack()) { + arg_order.push(i); + arg_order.push(c_arg); + } else { + if (out_regs[c_arg].first()->is_stack() || + in_regs[i].first() == out_regs[c_arg].first()) { + add_edge(i, in_regs[i].first(), c_arg, out_regs[c_arg + 1]); + } else { + add_edge(i, in_regs[i].first(), c_arg, out_regs[c_arg]); + } + } + } else if (in_sig_bt[i] == T_VOID) { + arg_order.push(i); + arg_order.push(c_arg); + } else { + if (out_regs[c_arg].first()->is_stack() || + in_regs[i].first() == out_regs[c_arg].first()) { + arg_order.push(i); + arg_order.push(c_arg); + } else { + add_edge(i, in_regs[i].first(), c_arg, out_regs[c_arg]); + } + } + } + // Break any cycles in the register moves and emit the in the + // proper order. + GrowableArray* stores = get_store_order(tmp_vmreg); + for (int i = 0; i < stores->length(); i++) { + arg_order.push(stores->at(i)->src_index()); + arg_order.push(stores->at(i)->dst_index()); + } + } + + // Collected all the move operations + void add_edge(int src_index, VMRegPair src, int dst_index, VMRegPair dst) { + if (src.first() == dst.first()) return; + edges.append(new MoveOperation(src_index, src, dst_index, dst)); + } + + // Walk the edges breaking cycles between moves. The result list + // can be walked in order to produce the proper set of loads + GrowableArray* get_store_order(VMRegPair temp_register) { + // Record which moves kill which values + GrowableArray killer; + for (int i = 0; i < edges.length(); i++) { + MoveOperation* s = edges.at(i); + assert(killer.at_grow(s->dst_id(), NULL) == NULL, "only one killer"); + killer.at_put_grow(s->dst_id(), s, NULL); + } + assert(killer.at_grow(MoveOperation::get_id(temp_register), NULL) == NULL, + "make sure temp isn't in the registers that are killed"); + + // create links between loads and stores + for (int i = 0; i < edges.length(); i++) { + edges.at(i)->link(killer); + } + + // at this point, all the move operations are chained together + // in a doubly linked list. Processing it backwards finds + // the beginning of the chain, forwards finds the end. If there's + // a cycle it can be broken at any point, so pick an edge and walk + // backward until the list ends or we end where we started. + GrowableArray* stores = new GrowableArray(); + for (int e = 0; e < edges.length(); e++) { + MoveOperation* s = edges.at(e); + if (!s->is_processed()) { + MoveOperation* start = s; + // search for the beginning of the chain or cycle + while (start->prev() != NULL && start->prev() != s) { + start = start->prev(); + } + if (start->prev() == s) { + start->break_cycle(temp_register); + } + // walk the chain forward inserting to store list + while (start != NULL) { + stores->append(start); + start->set_processed(); + start = start->next(); + } + } + } + return stores; + } +}; + + // --------------------------------------------------------------------------- // Generate a native wrapper for a given method. The method takes arguments // in the Java compiled code convention, marshals them to the native @@ -1488,12 +1653,12 @@ if (in_regs[i].first()->is_Register()) { const Register reg = in_regs[i].first()->as_Register(); switch (in_sig_bt[i]) { - case T_ARRAY: case T_BOOLEAN: case T_BYTE: case T_SHORT: case T_CHAR: case T_INT: single_slots++; break; + case T_ARRAY: case T_LONG: double_slots++; break; default: ShouldNotReachHere(); } @@ -1690,36 +1855,43 @@ #endif /* ASSERT */ - if (is_critical_native) { - // The mapping of Java and C arguments passed in registers are - // rotated by one, which helps when passing arguments to regular - // Java method but for critical natives that creates a cycle which - // can cause arguments to be killed before they are used. Break - // the cycle by moving the first argument into a temporary - // register. - for (int i = 0; i < total_c_args; i++) { - if (in_regs[i].first()->is_Register() && - in_regs[i].first()->as_Register() == rdi) { - __ mov(rbx, rdi); - in_regs[i].set1(rbx->as_VMReg()); - } - } - } - // This may iterate in two different directions depending on the // kind of native it is. The reason is that for regular JNI natives // the incoming and outgoing registers are offset upwards and for // critical natives they are offset down. - int c_arg = total_c_args - 1; - int stride = -1; - int init = total_in_args - 1; - if (is_critical_native) { - // stride forwards - c_arg = 0; - stride = 1; - init = 0; + GrowableArray arg_order(2 * total_in_args); + VMRegPair tmp_vmreg; + tmp_vmreg.set1(rbx->as_VMReg()); + + if (!is_critical_native) { + for (int i = total_in_args - 1, c_arg = total_c_args - 1; i >= 0; i--, c_arg--) { + arg_order.push(i); + arg_order.push(c_arg); + } + } else { + // Compute a valid move order, using tmp_vmreg to break any cycles + ComputeMoveOrder cmo(total_in_args, in_regs, total_c_args, out_regs, in_sig_bt, arg_order, tmp_vmreg); } - for (int i = init, count = 0; count < total_in_args; i += stride, c_arg += stride, count++ ) { + + int temploc = -1; + for (int ai = 0; ai < arg_order.length(); ai += 2) { + int i = arg_order.at(ai); + int c_arg = arg_order.at(ai + 1); + __ block_comment(err_msg("move %d -> %d", i, c_arg)); + if (c_arg == -1) { + assert(is_critical_native, "should only be required for critical natives"); + // This arg needs to be moved to a temporary + __ mov(tmp_vmreg.first()->as_Register(), in_regs[i].first()->as_Register()); + in_regs[i] = tmp_vmreg; + temploc = i; + continue; + } else if (i == -1) { + assert(is_critical_native, "should only be required for critical natives"); + // Read from the temporary location + assert(temploc != -1, "must be valid"); + i = temploc; + temploc = -1; + } #ifdef ASSERT if (in_regs[i].first()->is_Register()) { assert(!reg_destroyed[in_regs[i].first()->as_Register()->encoding()], "destroyed reg!"); @@ -1779,7 +1951,7 @@ // point c_arg at the first arg that is already loaded in case we // need to spill before we call out - c_arg++; + int c_arg = total_c_args - total_in_args; // Pre-load a static method's oop into r14. Used both by locking code and // the normal JNI call code. @@ -3620,8 +3792,12 @@ // // address OptoRuntime::handle_exception_C(JavaThread* thread) - __ set_last_Java_frame(noreg, noreg, NULL); + // At a method handle call, the stack may not be properly aligned + // when returning with an exception. + address the_pc = __ pc(); + __ set_last_Java_frame(noreg, noreg, the_pc); __ mov(c_rarg0, r15_thread); + __ andptr(rsp, -(StackAlignmentInBytes)); // Align stack __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, OptoRuntime::handle_exception_C))); // Set an oopmap for the call site. This oopmap will only be used if we @@ -3632,9 +3808,9 @@ OopMapSet* oop_maps = new OopMapSet(); - oop_maps->add_gc_map( __ pc()-start, new OopMap(SimpleRuntimeFrame::framesize, 0)); - - __ reset_last_Java_frame(false, false); + oop_maps->add_gc_map(the_pc - start, new OopMap(SimpleRuntimeFrame::framesize, 0)); + + __ reset_last_Java_frame(false, true); // Restore callee-saved registers diff -r 8a48c2906f91 -r d59a6302465a src/cpu/x86/vm/stubGenerator_x86_64.cpp --- a/src/cpu/x86/vm/stubGenerator_x86_64.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/cpu/x86/vm/stubGenerator_x86_64.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -710,6 +710,21 @@ return start; } + // Support for intptr_t get_previous_sp() + // + // This routine is used to find the previous stack pointer for the + // caller. + address generate_get_previous_sp() { + StubCodeMark mark(this, "StubRoutines", "get_previous_sp"); + address start = __ pc(); + + __ movptr(rax, rsp); + __ addptr(rax, 8); // return address is at the top of the stack. + __ ret(0); + + return start; + } + //---------------------------------------------------------------------------------------------------- // Support for void verify_mxcsr() // @@ -3060,6 +3075,7 @@ // platform dependent StubRoutines::x86::_get_previous_fp_entry = generate_get_previous_fp(); + StubRoutines::x86::_get_previous_sp_entry = generate_get_previous_sp(); StubRoutines::x86::_verify_mxcsr_entry = generate_verify_mxcsr(); diff -r 8a48c2906f91 -r d59a6302465a src/cpu/x86/vm/stubRoutines_x86_64.cpp --- a/src/cpu/x86/vm/stubRoutines_x86_64.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/cpu/x86/vm/stubRoutines_x86_64.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -43,6 +43,7 @@ // a description of how to extend it, see the stubRoutines.hpp file. address StubRoutines::x86::_get_previous_fp_entry = NULL; +address StubRoutines::x86::_get_previous_sp_entry = NULL; address StubRoutines::x86::_verify_mxcsr_entry = NULL; diff -r 8a48c2906f91 -r d59a6302465a src/cpu/x86/vm/stubRoutines_x86_64.hpp --- a/src/cpu/x86/vm/stubRoutines_x86_64.hpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/cpu/x86/vm/stubRoutines_x86_64.hpp Fri Mar 09 00:28:20 2012 -0500 @@ -41,6 +41,7 @@ private: static address _get_previous_fp_entry; + static address _get_previous_sp_entry; static address _verify_mxcsr_entry; static address _f2i_fixup; @@ -61,6 +62,11 @@ return _get_previous_fp_entry; } + static address get_previous_sp_entry() + { + return _get_previous_sp_entry; + } + static address verify_mxcsr_entry() { return _verify_mxcsr_entry; diff -r 8a48c2906f91 -r d59a6302465a src/os/bsd/vm/os_bsd.cpp diff -r 8a48c2906f91 -r d59a6302465a src/os/linux/vm/os_linux.cpp --- a/src/os/linux/vm/os_linux.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/os/linux/vm/os_linux.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -4690,14 +4690,12 @@ char *addr, size_t bytes, bool read_only, bool allow_exec) { int prot; - int flags; + int flags = MAP_PRIVATE; if (read_only) { prot = PROT_READ; - flags = MAP_SHARED; } else { prot = PROT_READ | PROT_WRITE; - flags = MAP_PRIVATE; } if (allow_exec) { diff -r 8a48c2906f91 -r d59a6302465a src/os/solaris/vm/os_solaris.cpp --- a/src/os/solaris/vm/os_solaris.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/os/solaris/vm/os_solaris.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -1013,15 +1013,6 @@ // use debugger to set breakpoint here } -// Returns an estimate of the current stack pointer. Result must be guaranteed to -// point into the calling threads stack, and be no lower than the current stack -// pointer. -address os::current_stack_pointer() { - volatile int dummy; - address sp = (address)&dummy + 8; // %%%% need to confirm if this is right - return sp; -} - static thread_t main_thread; // Thread start routine for all new Java threads diff -r 8a48c2906f91 -r d59a6302465a src/os/windows/vm/os_windows.cpp --- a/src/os/windows/vm/os_windows.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/os/windows/vm/os_windows.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -324,16 +324,6 @@ os::breakpoint(); } -// Returns an estimate of the current stack pointer. Result must be guaranteed -// to point into the calling threads stack, and be no lower than the current -// stack pointer. - -address os::current_stack_pointer() { - int dummy; - address sp = (address)&dummy; - return sp; -} - // os::current_stack_base() // // Returns the base of the stack, which is the stack's diff -r 8a48c2906f91 -r d59a6302465a src/os_cpu/bsd_x86/vm/os_bsd_x86.cpp --- a/src/os_cpu/bsd_x86/vm/os_bsd_x86.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/os_cpu/bsd_x86/vm/os_bsd_x86.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -1126,3 +1126,8 @@ : "r" (fpu_cntrl) : "memory"); #endif // !AMD64 } + +#ifndef PRODUCT +void os::verify_stack_alignment() { +} +#endif diff -r 8a48c2906f91 -r d59a6302465a src/os_cpu/bsd_zero/vm/os_bsd_zero.cpp --- a/src/os_cpu/bsd_zero/vm/os_bsd_zero.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/os_cpu/bsd_zero/vm/os_bsd_zero.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -562,3 +562,8 @@ } }; #endif // !_LP64 + +#ifndef PRODUCT +void os::verify_stack_alignment() { +} +#endif diff -r 8a48c2906f91 -r d59a6302465a src/os_cpu/linux_sparc/vm/os_linux_sparc.cpp --- a/src/os_cpu/linux_sparc/vm/os_linux_sparc.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/os_cpu/linux_sparc/vm/os_linux_sparc.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -756,3 +756,8 @@ // guard page, only enable glibc guard page for non-Java threads. return (thr_type == java_thread ? 0 : page_size()); } + +#ifndef PRODUCT +void os::verify_stack_alignment() { +} +#endif diff -r 8a48c2906f91 -r d59a6302465a src/os_cpu/linux_x86/vm/os_linux_x86.cpp --- a/src/os_cpu/linux_x86/vm/os_linux_x86.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/os_cpu/linux_x86/vm/os_linux_x86.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -862,3 +862,11 @@ : "r" (fpu_cntrl) : "memory"); #endif // !AMD64 } + +#ifndef PRODUCT +void os::verify_stack_alignment() { +#ifdef AMD64 + assert(((intptr_t)os::current_stack_pointer() & (StackAlignmentInBytes-1)) == 0, "incorrect stack alignment"); +#endif +} +#endif diff -r 8a48c2906f91 -r d59a6302465a src/os_cpu/linux_zero/vm/os_linux_zero.cpp --- a/src/os_cpu/linux_zero/vm/os_linux_zero.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/os_cpu/linux_zero/vm/os_linux_zero.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -506,3 +506,8 @@ } }; #endif // !_LP64 + +#ifndef PRODUCT +void os::verify_stack_alignment() { +} +#endif diff -r 8a48c2906f91 -r d59a6302465a src/os_cpu/solaris_sparc/vm/os_solaris_sparc.cpp --- a/src/os_cpu/solaris_sparc/vm/os_solaris_sparc.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/os_cpu/solaris_sparc/vm/os_solaris_sparc.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -251,6 +251,15 @@ return frame(fr->sender_sp(), frame::unpatchable, fr->sender_pc()); } +// Returns an estimate of the current stack pointer. Result must be guaranteed to +// point into the calling threads stack, and be no lower than the current stack +// pointer. +address os::current_stack_pointer() { + volatile int dummy; + address sp = (address)&dummy + 8; // %%%% need to confirm if this is right + return sp; +} + frame os::current_frame() { intptr_t* sp = StubRoutines::Sparc::flush_callers_register_windows_func()(); frame myframe(sp, frame::unpatchable, @@ -815,3 +824,8 @@ __asm__ __volatile__ ("wr %%g0, 0, %%fprs \n\t" : : :); } #endif //defined(__sparc) && defined(COMPILER2) + +#ifndef PRODUCT +void os::verify_stack_alignment() { +} +#endif diff -r 8a48c2906f91 -r d59a6302465a src/os_cpu/solaris_x86/vm/os_solaris_x86.cpp --- a/src/os_cpu/solaris_x86/vm/os_solaris_x86.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/os_cpu/solaris_x86/vm/os_solaris_x86.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -237,6 +237,12 @@ return frame(fr->sender_sp(), fr->link(), fr->sender_pc()); } +extern "C" intptr_t *_get_current_sp(); // in .il file + +address os::current_stack_pointer() { + return (address)_get_current_sp(); +} + extern "C" intptr_t *_get_current_fp(); // in .il file frame os::current_frame() { @@ -954,3 +960,11 @@ _solaris_raw_setup_fpu(fpu_cntrl); } #endif // AMD64 + +#ifndef PRODUCT +void os::verify_stack_alignment() { +#ifdef AMD64 + assert(((intptr_t)os::current_stack_pointer() & (StackAlignmentInBytes-1)) == 0, "incorrect stack alignment"); +#endif +} +#endif diff -r 8a48c2906f91 -r d59a6302465a src/os_cpu/solaris_x86/vm/solaris_x86_32.il --- a/src/os_cpu/solaris_x86/vm/solaris_x86_32.il Mon Mar 05 14:19:00 2012 -0500 +++ b/src/os_cpu/solaris_x86/vm/solaris_x86_32.il Fri Mar 09 00:28:20 2012 -0500 @@ -37,6 +37,12 @@ movl %gs:0, %eax .end + // Get current sp + .inline _get_current_sp,0 + .volatile + movl %esp, %eax + .end + // Get current fp .inline _get_current_fp,0 .volatile diff -r 8a48c2906f91 -r d59a6302465a src/os_cpu/solaris_x86/vm/solaris_x86_64.il --- a/src/os_cpu/solaris_x86/vm/solaris_x86_64.il Mon Mar 05 14:19:00 2012 -0500 +++ b/src/os_cpu/solaris_x86/vm/solaris_x86_64.il Fri Mar 09 00:28:20 2012 -0500 @@ -30,6 +30,12 @@ movq %fs:0, %rax .end + // Get current sp + .inline _get_current_sp,0 + .volatile + movq %rsp, %rax + .end + // Get current fp .inline _get_current_fp,0 .volatile diff -r 8a48c2906f91 -r d59a6302465a src/os_cpu/windows_x86/vm/os_windows_x86.cpp --- a/src/os_cpu/windows_x86/vm/os_windows_x86.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/os_cpu/windows_x86/vm/os_windows_x86.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -370,6 +370,26 @@ return frame(fr->sender_sp(), fr->link(), fr->sender_pc()); } +#ifndef AMD64 +// Returns an estimate of the current stack pointer. Result must be guaranteed +// to point into the calling threads stack, and be no lower than the current +// stack pointer. +address os::current_stack_pointer() { + int dummy; + address sp = (address)&dummy; + return sp; +} +#else +// Returns the current stack pointer. Accurate value needed for +// os::verify_stack_alignment(). +address os::current_stack_pointer() { + typedef address get_sp_func(); + get_sp_func* func = CAST_TO_FN_PTR(get_sp_func*, + StubRoutines::x86::get_previous_sp_entry()); + return (*func)(); +} +#endif + #ifndef AMD64 intptr_t* _get_previous_fp() { @@ -546,3 +566,11 @@ __asm fldcw fpu_cntrl_word; #endif // !AMD64 } + +#ifndef PRODUCT +void os::verify_stack_alignment() { +#ifdef AMD64 + assert(((intptr_t)os::current_stack_pointer() & (StackAlignmentInBytes-1)) == 0, "incorrect stack alignment"); +#endif +} +#endif diff -r 8a48c2906f91 -r d59a6302465a src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/Compilation.java --- a/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/Compilation.java Mon Mar 05 14:19:00 2012 -0500 +++ b/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/Compilation.java Fri Mar 09 00:28:20 2012 -0500 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -33,6 +33,7 @@ private boolean osr; private Method method; private CallSite call = new CallSite(); + private CallSite lateInlineCall = new CallSite(); private int osrBci; private String icount; private String bcount; @@ -80,6 +81,13 @@ sb.append(site); sb.append("\n"); } + if (getLateInlineCall().getCalls() != null) { + sb.append("late inline:\n"); + for (CallSite site : getLateInlineCall().getCalls()) { + sb.append(site); + sb.append("\n"); + } + } return sb.toString(); } @@ -115,6 +123,12 @@ site.print(stream, indent + 2); } } + if (printInlining && lateInlineCall.getCalls() != null) { + stream.println("late inline:"); + for (CallSite site : lateInlineCall.getCalls()) { + site.print(stream, indent + 2); + } + } } } @@ -215,7 +229,11 @@ } public void setMethod(Method method) { - this.method = method; + // Don't change method if it is already set to avoid changing + // it by post parse inlining info. + if (getMethod() == null) { + this.method = method; + } } public CallSite getCall() { @@ -226,6 +244,10 @@ this.call = call; } + public CallSite getLateInlineCall() { + return lateInlineCall; + } + public double getElapsedTime() { return end - start; } diff -r 8a48c2906f91 -r d59a6302465a src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/LogParser.java --- a/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/LogParser.java Mon Mar 05 14:19:00 2012 -0500 +++ b/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/LogParser.java Fri Mar 09 00:28:20 2012 -0500 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2009, 2012, 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 @@ -146,6 +146,7 @@ private CallSite site; private Stack phaseStack = new Stack(); private UncommonTrapEvent currentTrap; + private Stack late_inline_scope; long parseLong(String l) { try { @@ -302,6 +303,7 @@ } events.add(compile); compiles.put(makeId(atts), compile); + site = compile.getCall(); } else if (qname.equals("type")) { type(search(atts, "id"), search(atts, "name")); } else if (qname.equals("bc")) { @@ -360,12 +362,22 @@ // uncommon trap inserted during parsing. // ignore for now } + } else if (qname.equals("late_inline")) { + late_inline_scope = new Stack(); + site = new CallSite(-999, method(search(atts, "method"))); + late_inline_scope.push(site); } else if (qname.equals("jvms")) { // if (currentTrap != null) { currentTrap.addJVMS(atts.getValue("method"), Integer.parseInt(atts.getValue("bci"))); + } else if (late_inline_scope != null) { + bci = Integer.parseInt(search(atts, "bci")); + site = new CallSite(bci, method(search(atts, "method"))); + late_inline_scope.push(site); } else { - // Ignore and + // Ignore , + // , + // } } else if (qname.equals("nmethod")) { String id = makeId(atts); @@ -379,7 +391,7 @@ Method m = method(search(atts, "method")); if (scopes.size() == 0) { compile.setMethod(m); - scopes.push(compile.getCall()); + scopes.push(site); } else { if (site.getMethod() == m) { scopes.push(site); @@ -393,7 +405,7 @@ } } else if (qname.equals("parse_done")) { CallSite call = scopes.pop(); - call.setEndNodes(Integer.parseInt(search(atts, "nodes"))); + call.setEndNodes(Integer.parseInt(search(atts, "nodes", "1"))); call.setTimeStamp(Double.parseDouble(search(atts, "stamp"))); scopes.push(call); } @@ -408,6 +420,43 @@ scopes.pop(); } else if (qname.equals("uncommon_trap")) { currentTrap = null; + } else if (qname.equals("late_inline")) { + // Populate late inlining info. + + // late_inline scopes are specified in reverse order: + // compiled method should be on top of stack. + CallSite caller = late_inline_scope.pop(); + Method m = compile.getMethod(); + if (m != caller.getMethod()) { + System.out.println(m); + System.out.println(caller.getMethod() + " bci: " + bci); + throw new InternalError("call site and late_inline info don't match"); + } + + // late_inline contains caller+bci info, convert it + // to bci+callee info used by LogCompilation. + site = compile.getLateInlineCall(); + do { + bci = caller.getBci(); + // Next inlined call. + caller = late_inline_scope.pop(); + CallSite callee = new CallSite(bci, caller.getMethod()); + site.add(callee); + site = callee; + } while (!late_inline_scope.empty()); + + if (caller.getBci() != -999) { + System.out.println(caller.getMethod()); + throw new InternalError("broken late_inline info"); + } + if (site.getMethod() != caller.getMethod()) { + System.out.println(site.getMethod()); + System.out.println(caller.getMethod()); + throw new InternalError("call site and late_inline info don't match"); + } + // late_inline is followed by parse with scopes.size() == 0, + // 'site' will be pushed to scopes. + late_inline_scope = null; } else if (qname.equals("task")) { types.clear(); methods.clear(); diff -r 8a48c2906f91 -r d59a6302465a src/share/tools/whitebox/sun/hotspot/WhiteBox.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/tools/whitebox/sun/hotspot/WhiteBox.java Fri Mar 09 00:28:20 2012 -0500 @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2012, 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. + * + */ + +package sun.hotspot; +import java.security.BasicPermission; + +public class WhiteBox { + + @SuppressWarnings("serial") + public static class WhiteBoxPermission extends BasicPermission { + public WhiteBoxPermission(String s) { + super(s); + } + } + + private WhiteBox() {} + private static final WhiteBox instance = new WhiteBox(); + private static native void registerNatives(); + + /** + * Returns the singleton WhiteBox instance. + * + * The returned WhiteBox object should be carefully guarded + * by the caller, since it can be used to read and write data + * at arbitrary memory addresses. It must never be passed to + * untrusted code. + */ + public synchronized static WhiteBox getWhiteBox() { + SecurityManager sm = System.getSecurityManager(); + if (sm != null) { + sm.checkPermission(new WhiteBoxPermission("getInstance")); + } + return instance; + } + + static { + registerNatives(); + } + + // Memory + public native long getObjectAddress(Object o); + public native int getHeapOopSize(); + + // G1 + public native boolean g1InConcurrentMark(); + public native boolean g1IsHumongous(Object o); + public native long g1NumFreeRegions(); + public native int g1RegionSize(); +} diff -r 8a48c2906f91 -r d59a6302465a src/share/vm/c1/c1_LinearScan.cpp --- a/src/share/vm/c1/c1_LinearScan.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/share/vm/c1/c1_LinearScan.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -1884,7 +1884,7 @@ if (move_resolver.has_mappings()) { // insert moves after first instruction - move_resolver.set_insert_position(block->lir(), 1); + move_resolver.set_insert_position(block->lir(), 0); move_resolver.resolve_and_append_moves(); } } diff -r 8a48c2906f91 -r d59a6302465a src/share/vm/gc_implementation/g1/g1MonitoringSupport.cpp --- a/src/share/vm/gc_implementation/g1/g1MonitoringSupport.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/share/vm/gc_implementation/g1/g1MonitoringSupport.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2011, 2012 Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -44,7 +44,9 @@ G1MonitoringSupport::pad_capacity(0, 3) /* min_capacity */, G1MonitoringSupport::pad_capacity(g1mm->young_gen_max(), 3), G1MonitoringSupport::pad_capacity(0, 3) /* curr_capacity */) { - update_all(); + if (UsePerfData) { + update_all(); + } } G1OldGenerationCounters::G1OldGenerationCounters(G1MonitoringSupport* g1mm, @@ -53,7 +55,9 @@ G1MonitoringSupport::pad_capacity(0) /* min_capacity */, G1MonitoringSupport::pad_capacity(g1mm->old_gen_max()), G1MonitoringSupport::pad_capacity(0) /* curr_capacity */) { - update_all(); + if (UsePerfData) { + update_all(); + } } void G1YoungGenerationCounters::update_all() { @@ -149,10 +153,6 @@ pad_capacity(0) /* max_capacity */, pad_capacity(0) /* init_capacity */, _young_collection_counters); - // Given that this survivor space is not used, we update it here - // once to reflect that its used space is 0 so that we don't have to - // worry about updating it again later. - _from_counters->update_used(0); // name "generation.0.space.2" // See _old_space_counters for additional counters @@ -160,6 +160,13 @@ pad_capacity(overall_reserved()) /* max_capacity */, pad_capacity(survivor_space_committed()) /* init_capacity */, _young_collection_counters); + + if (UsePerfData) { + // Given that this survivor space is not used, we update it here + // once to reflect that its used space is 0 so that we don't have to + // worry about updating it again later. + _from_counters->update_used(0); + } } void G1MonitoringSupport::recalculate_sizes() { diff -r 8a48c2906f91 -r d59a6302465a src/share/vm/opto/connode.cpp --- a/src/share/vm/opto/connode.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/share/vm/opto/connode.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, 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 @@ -1051,6 +1051,7 @@ //------------------------------Value------------------------------------------ const Type *CastX2PNode::Value( PhaseTransform *phase ) const { const Type* t = phase->type(in(1)); + if (t == Type::TOP) return Type::TOP; if (t->base() == Type_X && t->singleton()) { uintptr_t bits = (uintptr_t) t->is_intptr_t()->get_con(); if (bits == 0) return TypePtr::NULL_PTR; @@ -1121,6 +1122,7 @@ //------------------------------Value------------------------------------------ const Type *CastP2XNode::Value( PhaseTransform *phase ) const { const Type* t = phase->type(in(1)); + if (t == Type::TOP) return Type::TOP; if (t->base() == Type::RawPtr && t->singleton()) { uintptr_t bits = (uintptr_t) t->is_rawptr()->get_con(); return TypeX::make(bits); diff -r 8a48c2906f91 -r d59a6302465a src/share/vm/opto/escape.cpp --- a/src/share/vm/opto/escape.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/share/vm/opto/escape.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -2035,40 +2035,14 @@ Node* store = ini->find_captured_store(offset, type2aelembytes(ft), phase); if (store != NULL && store->is_Store()) { value = store->in(MemNode::ValueIn); - } else if (ptn->edge_count() > 0) { // Are there oop stores? - // Check for a store which follows allocation without branches. + } else { + // There could be initializing stores which follow allocation. // For example, a volatile field store is not collected - // by Initialize node. TODO: it would be nice to use idom() here. - // - // Search all references to the same field which use different - // AddP nodes, for example, in the next case: - // - // Point p[] = new Point[1]; - // if ( x ) { p[0] = new Point(); p[0].x = x; } - // if ( p[0] != null ) { y = p[0].x; } // has CastPP + // by Initialize node. // - for (uint next = ei; (next < ae_cnt) && (value == NULL); next++) { - uint fpi = pta->edge_target(next); // Field (AddP) - PointsToNode *ptf = ptnode_adr(fpi); - if (ptf->offset() == offset) { - Node* nf = ptf->_node; - for (DUIterator_Fast imax, i = nf->fast_outs(imax); i < imax; i++) { - store = nf->fast_out(i); - if (store->is_Store() && store->in(0) != NULL) { - Node* ctrl = store->in(0); - while(!(ctrl == ini || ctrl == alloc || ctrl == NULL || - ctrl == C->root() || ctrl == C->top() || ctrl->is_Region() || - ctrl->is_IfTrue() || ctrl->is_IfFalse())) { - ctrl = ctrl->in(0); - } - if (ctrl == ini || ctrl == alloc) { - value = store->in(MemNode::ValueIn); - break; - } - } - } - } - } + // Need to check for dependent loads to separate such stores from + // stores which follow loads. For now, add initial value NULL so + // that compare pointers optimization works correctly. } } if (value == NULL || value != ptnode_adr(value->_idx)->_node) { diff -r 8a48c2906f91 -r d59a6302465a src/share/vm/prims/nativeLookup.cpp --- a/src/share/vm/prims/nativeLookup.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/share/vm/prims/nativeLookup.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -121,6 +121,7 @@ void JNICALL JVM_RegisterUnsafeMethods(JNIEnv *env, jclass unsafecls); void JNICALL JVM_RegisterMethodHandleMethods(JNIEnv *env, jclass unsafecls); void JNICALL JVM_RegisterPerfMethods(JNIEnv *env, jclass perfclass); + void JNICALL JVM_RegisterWhiteBoxMethods(JNIEnv *env, jclass wbclass); } #define CC (char*) /* cast a literal from (const char*) */ @@ -133,7 +134,8 @@ { CC"Java_sun_misc_Unsafe_registerNatives", NULL, FN_PTR(JVM_RegisterUnsafeMethods) }, { CC"Java_java_lang_invoke_MethodHandleNatives_registerNatives", NULL, FN_PTR(JVM_RegisterMethodHandleMethods) }, - { CC"Java_sun_misc_Perf_registerNatives", NULL, FN_PTR(JVM_RegisterPerfMethods) } + { CC"Java_sun_misc_Perf_registerNatives", NULL, FN_PTR(JVM_RegisterPerfMethods) }, + { CC"Java_sun_hotspot_WhiteBox_registerNatives", NULL, FN_PTR(JVM_RegisterWhiteBoxMethods) }, }; static address lookup_special_native(char* jni_name) { diff -r 8a48c2906f91 -r d59a6302465a src/share/vm/prims/whitebox.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/prims/whitebox.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2012, 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 "precompiled.hpp" + +#include "jni.h" + +#include "memory/universe.hpp" +#include "oops/oop.inline.hpp" +#include "prims/whitebox.hpp" +#include "runtime/interfaceSupport.hpp" +#include "runtime/os.hpp" +#include "utilities/debug.hpp" + +#ifndef SERIALGC +#include "gc_implementation/g1/concurrentMark.hpp" +#include "gc_implementation/g1/g1CollectedHeap.inline.hpp" +#include "gc_implementation/g1/heapRegionRemSet.hpp" +#endif // !SERIALGC + +bool WhiteBox::_used = false; + +// Entry macro to transition from JNI to VM state. + +#define WB_ENTRY(result_type, header) JNI_ENTRY(result_type, header) +#define WB_END JNI_END + +// Definitions of functions exposed via Whitebox API + +WB_ENTRY(jlong, WB_GetObjectAddress(JNIEnv* env, jobject o, jobject obj)) + return (jlong)(void*)JNIHandles::resolve(obj); +WB_END + +WB_ENTRY(jint, WB_GetHeapOopSize(JNIEnv* env, jobject o)) + return heapOopSize; +WB_END + +#ifndef SERIALGC +WB_ENTRY(jboolean, WB_G1IsHumongous(JNIEnv* env, jobject o, jobject obj)) + G1CollectedHeap* g1 = G1CollectedHeap::heap(); + oop result = JNIHandles::resolve(obj); + const HeapRegion* hr = g1->heap_region_containing(result); + return hr->isHumongous(); +WB_END + +WB_ENTRY(jlong, WB_G1NumFreeRegions(JNIEnv* env, jobject o)) + G1CollectedHeap* g1 = G1CollectedHeap::heap(); + size_t nr = g1->free_regions(); + return (jlong)nr; +WB_END + +WB_ENTRY(jboolean, WB_G1InConcurrentMark(JNIEnv* env, jobject o)) + G1CollectedHeap* g1 = G1CollectedHeap::heap(); + ConcurrentMark* cm = g1->concurrent_mark(); + return cm->concurrent_marking_in_progress(); +WB_END + +WB_ENTRY(jint, WB_G1RegionSize(JNIEnv* env, jobject o)) + return (jint)HeapRegion::GrainBytes; +WB_END +#endif // !SERIALGC + +#define CC (char*) + +static JNINativeMethod methods[] = { + {CC"getObjectAddress", CC"(Ljava/lang/Object;)J", (void*)&WB_GetObjectAddress }, + {CC"getHeapOopSize", CC"()I", (void*)&WB_GetHeapOopSize }, +#ifndef SERIALGC + {CC"g1InConcurrentMark", CC"()Z", (void*)&WB_G1InConcurrentMark}, + {CC"g1IsHumongous", CC"(Ljava/lang/Object;)Z", (void*)&WB_G1IsHumongous }, + {CC"g1NumFreeRegions", CC"()J", (void*)&WB_G1NumFreeRegions }, + {CC"g1RegionSize", CC"()I", (void*)&WB_G1RegionSize }, +#endif // !SERIALGC +}; + +#undef CC + +JVM_ENTRY(void, JVM_RegisterWhiteBoxMethods(JNIEnv* env, jclass wbclass)) + { + if (WhiteBoxAPI) { + // Make sure that wbclass is loaded by the null classloader + instanceKlassHandle ikh = instanceKlassHandle(JNIHandles::resolve(wbclass)->klass()); + Handle loader(ikh->class_loader()); + if (loader.is_null()) { + ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI + jint result = env->RegisterNatives(wbclass, methods, sizeof(methods)/sizeof(methods[0])); + if (result == 0) { + WhiteBox::set_used(); + } + } + } + } +JVM_END diff -r 8a48c2906f91 -r d59a6302465a src/share/vm/prims/whitebox.hpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/prims/whitebox.hpp Fri Mar 09 00:28:20 2012 -0500 @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2012, 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. + * + */ + +#ifndef SHARE_VM_PRIMS_WHITEBOX_HPP +#define SHARE_VM_PRIMS_WHITEBOX_HPP + +class WhiteBox : public AllStatic { + private: + static bool _used; + public: + static bool used() { return _used; } + static void set_used() { _used = true; } +}; + +#endif // SHARE_VM_PRIMS_WHITEBOX_HPP diff -r 8a48c2906f91 -r d59a6302465a src/share/vm/runtime/arguments.cpp --- a/src/share/vm/runtime/arguments.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/share/vm/runtime/arguments.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -2050,6 +2050,19 @@ FREE_C_HEAP_ARRAY(char, altclasses_path); } + if (WhiteBoxAPI) { + // Append wb.jar to bootclasspath if enabled + const char* wb_jar = "wb.jar"; + size_t wb_path_len = strlen(get_meta_index_dir()) + 1 + + strlen(wb_jar); + char* wb_path = NEW_C_HEAP_ARRAY(char, wb_path_len); + strcpy(wb_path, get_meta_index_dir()); + strcat(wb_path, wb_jar); + scp.add_suffix(wb_path); + scp_assembly_required = true; + FREE_C_HEAP_ARRAY(char, wb_path); + } + // Parse _JAVA_OPTIONS environment variable (if present) (mimics classic VM) result = parse_java_options_environment_variable(&scp, &scp_assembly_required); if (result != JNI_OK) { diff -r 8a48c2906f91 -r d59a6302465a src/share/vm/runtime/globals.hpp --- a/src/share/vm/runtime/globals.hpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/share/vm/runtime/globals.hpp Fri Mar 09 00:28:20 2012 -0500 @@ -3896,7 +3896,10 @@ product(bool, UseVMInterruptibleIO, false, \ "(Unstable, Solaris-specific) Thread interrupt before or with " \ "EINTR for I/O operations results in OS_INTRPT. The default value"\ - " of this flag is true for JDK 6 and earlier") + " of this flag is true for JDK 6 and earlier") \ + \ + diagnostic(bool, WhiteBoxAPI, false, \ + "Enable internal testing APIs") /* * Macros for factoring of globals diff -r 8a48c2906f91 -r d59a6302465a src/share/vm/runtime/interfaceSupport.hpp --- a/src/share/vm/runtime/interfaceSupport.hpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/share/vm/runtime/interfaceSupport.hpp Fri Mar 09 00:28:20 2012 -0500 @@ -436,6 +436,7 @@ #define VM_LEAF_BASE(result_type, header) \ TRACE_CALL(result_type, header) \ debug_only(NoHandleMark __hm;) \ + os::verify_stack_alignment(); \ /* begin of body */ @@ -445,6 +446,7 @@ TRACE_CALL(result_type, header) \ HandleMarkCleaner __hm(thread); \ Thread* THREAD = thread; \ + os::verify_stack_alignment(); \ /* begin of body */ @@ -454,6 +456,7 @@ TRACE_CALL(result_type, header) \ debug_only(NoHandleMark __hm;) \ Thread* THREAD = thread; \ + os::verify_stack_alignment(); \ /* begin of body */ diff -r 8a48c2906f91 -r d59a6302465a src/share/vm/runtime/os.hpp --- a/src/share/vm/runtime/os.hpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/share/vm/runtime/os.hpp Fri Mar 09 00:28:20 2012 -0500 @@ -404,6 +404,8 @@ static address current_stack_base(); static size_t current_stack_size(); + static void verify_stack_alignment() PRODUCT_RETURN; + static int message_box(const char* title, const char* message); static char* do_you_want_to_debug(const char* message); diff -r 8a48c2906f91 -r d59a6302465a src/share/vm/utilities/vmError.cpp --- a/src/share/vm/utilities/vmError.cpp Mon Mar 05 14:19:00 2012 -0500 +++ b/src/share/vm/utilities/vmError.cpp Fri Mar 09 00:28:20 2012 -0500 @@ -25,6 +25,7 @@ #include "precompiled.hpp" #include "compiler/compileBroker.hpp" #include "gc_interface/collectedHeap.hpp" +#include "prims/whitebox.hpp" #include "runtime/arguments.hpp" #include "runtime/frame.inline.hpp" #include "runtime/init.hpp" @@ -717,6 +718,13 @@ st->cr(); } + STEP(215, "(printing warning if internal testing API used)" ) + + if (WhiteBox::used()) { + st->print_cr("Unsupported internal testing APIs have been used."); + st->cr(); + } + STEP(220, "(printing environment variables)" ) if (_verbose) { diff -r 8a48c2906f91 -r d59a6302465a test/Makefile --- a/test/Makefile Mon Mar 05 14:19:00 2012 -0500 +++ b/test/Makefile Fri Mar 09 00:28:20 2012 -0500 @@ -1,5 +1,5 @@ # -# Copyright (c) 1995, 2011, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 1995, 2012, 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 @@ -228,6 +228,24 @@ ################################################################ +# wbapitest (make sure the whitebox testing api classes work + +wbapitest: prep $(JT_HOME) $(PRODUCT_HOME) $(JTREG) + $(JTREG) -a -v:fail,error \ + $(JTREG_KEY_OPTION) \ + $(EXTRA_JTREG_OPTIONS) \ + -r:$(ABS_TEST_OUTPUT_DIR)/JTreport \ + -w:$(ABS_TEST_OUTPUT_DIR)/JTwork \ + -jdk:$(PRODUCT_HOME) \ + $(JAVA_OPTIONS:%=-vmoption:%) \ + $(TEST_ROOT)/sanity \ + || $(BUNDLE_UP_FAILED) + $(BUNDLE_UP) + +PHONY_LIST += wbapitest + +################################################################ + # packtest # Expect JPRT to set JPRT_PACKTEST_HOME. diff -r 8a48c2906f91 -r d59a6302465a test/sanity/WBApi.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/sanity/WBApi.java Fri Mar 09 00:28:20 2012 -0500 @@ -0,0 +1,13 @@ +/* + * @test WBApi + * @summary verify that whitebox functions can be linked and executed + * @run compile -J-XX:+UnlockDiagnosticVMOptions -J-XX:+WhiteBoxAPI WBApi.java + * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI WBApi + */ + +import sun.hotspot.WhiteBox; +public class WBApi { + public static void main(String... args) { + System.out.printf("args at: %x\n",WhiteBox.getWhiteBox().getObjectAddress(args)); + } +}