--- a/hotspot/make/Makefile Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/make/Makefile Thu May 16 13:47:55 2013 -0700
@@ -151,32 +151,43 @@
$(MAKE_ARGS) BUILD_FLAVOR=product docs
endif
+# Output directories
+C1_DIR =$(OUTPUTDIR)/$(VM_PLATFORM)_compiler1
+C2_DIR =$(OUTPUTDIR)/$(VM_PLATFORM)_compiler2
+MINIMAL1_DIR=$(OUTPUTDIR)/$(VM_PLATFORM)_minimal1
+ZERO_DIR =$(OUTPUTDIR)/$(VM_PLATFORM)_zero
+SHARK_DIR =$(OUTPUTDIR)/$(VM_PLATFORM)_shark
+
# Build variation of hotspot
$(C1_VM_TARGETS):
$(CD) $(GAMMADIR)/make; \
- $(MAKE) BUILD_FLAVOR=$(@:%1=%) VM_TARGET=$@ generic_build1 $(ALT_OUT)
+ $(MAKE) BUILD_DIR=$(C1_DIR) BUILD_FLAVOR=$(@:%1=%) VM_TARGET=$@ generic_build1 $(ALT_OUT)
$(C2_VM_TARGETS):
$(CD) $(GAMMADIR)/make; \
- $(MAKE) BUILD_FLAVOR=$@ VM_TARGET=$@ generic_build2 $(ALT_OUT)
+ $(MAKE) BUILD_DIR=$(C2_DIR) BUILD_FLAVOR=$@ VM_TARGET=$@ generic_build2 $(ALT_OUT)
$(ZERO_VM_TARGETS):
$(CD) $(GAMMADIR)/make; \
- $(MAKE) BUILD_FLAVOR=$(@:%zero=%) VM_TARGET=$@ \
- generic_buildzero $(ALT_OUT)
+ $(MAKE) BUILD_DIR=$(ZERO_DIR) BUILD_FLAVOR=$(@:%zero=%) VM_TARGET=$@ generic_buildzero $(ALT_OUT)
$(SHARK_VM_TARGETS):
$(CD) $(GAMMADIR)/make; \
- $(MAKE) BUILD_FLAVOR=$(@:%shark=%) VM_TARGET=$@ \
- generic_buildshark $(ALT_OUT)
+ $(MAKE) BUILD_DIR=$(SHARK_DIR) BUILD_FLAVOR=$(@:%shark=%) VM_TARGET=$@ generic_buildshark $(ALT_OUT)
$(MINIMAL1_VM_TARGETS):
$(CD) $(GAMMADIR)/make; \
- $(MAKE) BUILD_FLAVOR=$(@:%minimal1=%) VM_TARGET=$@ \
- generic_buildminimal1 $(ALT_OUT)
+ $(MAKE) BUILD_DIR=$(MINIMAL1_DIR) BUILD_FLAVOR=$(@:%minimal1=%) VM_TARGET=$@ generic_buildminimal1 $(ALT_OUT)
+
+# Install hotspot script in build directory
+HOTSPOT_SCRIPT=$(BUILD_DIR)/$(BUILD_FLAVOR)/hotspot
+$(HOTSPOT_SCRIPT): $(GAMMADIR)/make/hotspot.script
+ $(QUIETLY) $(MKDIR) -p $(BUILD_DIR)/$(BUILD_FLAVOR)
+ $(QUIETLY) cat $< | sed -e 's|@@LIBARCH@@|$(LIBARCH)|g' | sed -e 's|@@JDK_IMPORT_PATH@@|$(JDK_IMPORT_PATH)|g' > $@
+ $(QUIETLY) chmod +x $@
# Build compiler1 (client) rule, different for platforms
-generic_build1:
+generic_build1: $(HOTSPOT_SCRIPT)
$(MKDIR) -p $(OUTPUTDIR)
ifeq ($(OSNAME),windows)
ifeq ($(ARCH_DATA_MODEL), 32)
@@ -201,7 +212,7 @@
endif
# Build compiler2 (server) rule, different for platforms
-generic_build2:
+generic_build2: $(HOTSPOT_SCRIPT)
$(MKDIR) -p $(OUTPUTDIR)
ifeq ($(OSNAME),windows)
$(CD) $(OUTPUTDIR); \
@@ -217,19 +228,19 @@
$(MAKE_ARGS) $(VM_TARGET)
endif
-generic_buildzero:
+generic_buildzero: $(HOTSPOT_SCRIPT)
$(MKDIR) -p $(OUTPUTDIR)
$(CD) $(OUTPUTDIR); \
$(MAKE) -f $(ABS_OS_MAKEFILE) \
$(MAKE_ARGS) $(VM_TARGET)
-generic_buildshark:
+generic_buildshark: $(HOTSPOT_SCRIPT)
$(MKDIR) -p $(OUTPUTDIR)
$(CD) $(OUTPUTDIR); \
$(MAKE) -f $(ABS_OS_MAKEFILE) \
$(MAKE_ARGS) $(VM_TARGET)
-generic_buildminimal1:
+generic_buildminimal1: $(HOTSPOT_SCRIPT)
ifeq ($(JVM_VARIANT_MINIMAL1),true)
$(MKDIR) -p $(OUTPUTDIR)
ifeq ($(ARCH_DATA_MODEL), 32)
@@ -252,224 +263,210 @@
# Export file rule
generic_export: $(EXPORT_LIST)
+
export_product:
- $(MAKE) BUILD_FLAVOR=$(@:export_%=%) VM_SUBDIR=$(@:export_%=%) \
- generic_export
+ $(MAKE) BUILD_FLAVOR=$(@:export_%=%) generic_export
export_fastdebug:
- $(MAKE) BUILD_FLAVOR=$(@:export_%=%) VM_SUBDIR=$(@:export_%=%) \
- EXPORT_SUBDIR=/$(@:export_%=%) \
- generic_export
+ $(MAKE) BUILD_FLAVOR=$(@:export_%=%) EXPORT_SUBDIR=/$(@:export_%=%) generic_export
export_debug:
- $(MAKE) BUILD_FLAVOR=$(@:export_%=%) VM_SUBDIR=$(@:export_%=%) \
- EXPORT_SUBDIR=/$(@:export_%=%) \
- generic_export
+ $(MAKE) BUILD_FLAVOR=$(@:export_%=%) EXPORT_SUBDIR=/$(@:export_%=%) generic_export
export_optimized:
- $(MAKE) BUILD_FLAVOR=$(@:export_%=%) VM_SUBDIR=$(@:export_%=%) \
- EXPORT_SUBDIR=/$(@:export_%=%) \
- generic_export
+ $(MAKE) BUILD_FLAVOR=$(@:export_%=%) EXPORT_SUBDIR=/$(@:export_%=%) generic_export
+
export_product_jdk::
- $(MAKE) BUILD_FLAVOR=$(@:export_%_jdk=%) \
- VM_SUBDIR=$(@:export_%_jdk=%) ALT_EXPORT_PATH=$(JDK_IMAGE_DIR) \
- generic_export
+ $(MAKE) BUILD_FLAVOR=$(@:export_%_jdk=%) ALT_EXPORT_PATH=$(JDK_IMAGE_DIR) generic_export
export_optimized_jdk::
- $(MAKE) BUILD_FLAVOR=$(@:export_%_jdk=%) \
- VM_SUBDIR=$(@:export_%_jdk=%) ALT_EXPORT_PATH=$(JDK_IMAGE_DIR) \
- generic_export
+ $(MAKE) BUILD_FLAVOR=$(@:export_%_jdk=%) ALT_EXPORT_PATH=$(JDK_IMAGE_DIR) generic_export
export_fastdebug_jdk::
- $(MAKE) BUILD_FLAVOR=$(@:export_%_jdk=%) \
- VM_SUBDIR=$(@:export_%_jdk=%) \
- ALT_EXPORT_PATH=$(JDK_IMAGE_DIR)/$(@:export_%_jdk=%) \
- generic_export
+ $(MAKE) BUILD_FLAVOR=$(@:export_%_jdk=%) ALT_EXPORT_PATH=$(JDK_IMAGE_DIR)/$(@:export_%_jdk=%) generic_export
export_debug_jdk::
- $(MAKE) BUILD_FLAVOR=$(@:export_%_jdk=%) VM_SUBDIR=$(@:export_%_jdk=%) \
- ALT_EXPORT_PATH=$(JDK_IMAGE_DIR)/$(@:export_%_jdk=%) \
- generic_export
+ $(MAKE) BUILD_FLAVOR=$(@:export_%_jdk=%) ALT_EXPORT_PATH=$(JDK_IMAGE_DIR)/$(@:export_%_jdk=%) generic_export
# Export file copy rules
XUSAGE=$(HS_SRC_DIR)/share/vm/Xusage.txt
-DOCS_DIR =$(OUTPUTDIR)/$(VM_PLATFORM)_docs
-C1_DIR =$(OUTPUTDIR)/$(VM_PLATFORM)_compiler1/$(VM_SUBDIR)
-C2_DIR =$(OUTPUTDIR)/$(VM_PLATFORM)_compiler2/$(VM_SUBDIR)
-MINIMAL1_DIR=$(OUTPUTDIR)/$(VM_PLATFORM)_minimal1/$(VM_SUBDIR)
-ZERO_DIR =$(OUTPUTDIR)/$(VM_PLATFORM)_zero/$(VM_SUBDIR)
-SHARK_DIR =$(OUTPUTDIR)/$(VM_PLATFORM)_shark/$(VM_SUBDIR)
+DOCS_DIR=$(OUTPUTDIR)/$(VM_PLATFORM)_docs
+C1_BUILD_DIR =$(C1_DIR)/$(BUILD_FLAVOR)
+C2_BUILD_DIR =$(C2_DIR)/$(BUILD_FLAVOR)
+MINIMAL1_BUILD_DIR=$(MINIMAL1_DIR)/$(BUILD_FLAVOR)
+ZERO_BUILD_DIR =$(ZERO_DIR)/$(BUILD_FLAVOR)
+SHARK_BUILD_DIR =$(SHARK_DIR)/$(BUILD_FLAVOR)
# Server (C2)
ifeq ($(JVM_VARIANT_SERVER), true)
# Common
-$(EXPORT_SERVER_DIR)/%.diz: $(C2_DIR)/%.diz
+$(EXPORT_SERVER_DIR)/%.diz: $(C2_BUILD_DIR)/%.diz
$(install-file)
-$(EXPORT_LIB_DIR)/%.jar: $(C2_DIR)/../generated/%.jar
+$(EXPORT_LIB_DIR)/%.jar: $(C2_BUILD_DIR)/../generated/%.jar
$(install-file)
-$(EXPORT_INCLUDE_DIR)/%: $(C2_DIR)/../generated/jvmtifiles/%
+$(EXPORT_INCLUDE_DIR)/%: $(C2_BUILD_DIR)/../generated/jvmtifiles/%
$(install-file)
# Windows
-$(EXPORT_SERVER_DIR)/%.dll: $(C2_DIR)/%.dll
+$(EXPORT_SERVER_DIR)/%.dll: $(C2_BUILD_DIR)/%.dll
$(install-file)
-$(EXPORT_SERVER_DIR)/%.pdb: $(C2_DIR)/%.pdb
+$(EXPORT_SERVER_DIR)/%.pdb: $(C2_BUILD_DIR)/%.pdb
$(install-file)
-$(EXPORT_SERVER_DIR)/%.map: $(C2_DIR)/%.map
+$(EXPORT_SERVER_DIR)/%.map: $(C2_BUILD_DIR)/%.map
$(install-file)
-$(EXPORT_LIB_DIR)/%.lib: $(C2_DIR)/%.lib
+$(EXPORT_LIB_DIR)/%.lib: $(C2_BUILD_DIR)/%.lib
$(install-file)
-$(EXPORT_JRE_BIN_DIR)/%.diz: $(C2_DIR)/%.diz
+$(EXPORT_JRE_BIN_DIR)/%.diz: $(C2_BUILD_DIR)/%.diz
$(install-file)
-$(EXPORT_JRE_BIN_DIR)/%.dll: $(C2_DIR)/%.dll
+$(EXPORT_JRE_BIN_DIR)/%.dll: $(C2_BUILD_DIR)/%.dll
$(install-file)
-$(EXPORT_JRE_BIN_DIR)/%.pdb: $(C2_DIR)/%.pdb
+$(EXPORT_JRE_BIN_DIR)/%.pdb: $(C2_BUILD_DIR)/%.pdb
$(install-file)
-$(EXPORT_JRE_BIN_DIR)/%.map: $(C2_DIR)/%.map
+$(EXPORT_JRE_BIN_DIR)/%.map: $(C2_BUILD_DIR)/%.map
$(install-file)
# Unix
-$(EXPORT_JRE_LIB_ARCH_DIR)/%.$(LIBRARY_SUFFIX): $(C2_DIR)/%.$(LIBRARY_SUFFIX)
+$(EXPORT_JRE_LIB_ARCH_DIR)/%.$(LIBRARY_SUFFIX): $(C2_BUILD_DIR)/%.$(LIBRARY_SUFFIX)
$(install-file)
-$(EXPORT_SERVER_DIR)/%.$(LIBRARY_SUFFIX): $(C2_DIR)/%.$(LIBRARY_SUFFIX)
+$(EXPORT_SERVER_DIR)/%.$(LIBRARY_SUFFIX): $(C2_BUILD_DIR)/%.$(LIBRARY_SUFFIX)
$(install-file)
-$(EXPORT_SERVER_DIR)/64/%.$(LIBRARY_SUFFIX): $(C2_DIR)/%.$(LIBRARY_SUFFIX)
+$(EXPORT_SERVER_DIR)/64/%.$(LIBRARY_SUFFIX): $(C2_BUILD_DIR)/%.$(LIBRARY_SUFFIX)
$(install-file)
-$(EXPORT_JRE_LIB_ARCH_DIR)/%.debuginfo: $(C2_DIR)/%.debuginfo
+$(EXPORT_JRE_LIB_ARCH_DIR)/%.debuginfo: $(C2_BUILD_DIR)/%.debuginfo
$(install-file)
-$(EXPORT_SERVER_DIR)/%.debuginfo: $(C2_DIR)/%.debuginfo
+$(EXPORT_SERVER_DIR)/%.debuginfo: $(C2_BUILD_DIR)/%.debuginfo
$(install-file)
-$(EXPORT_SERVER_DIR)/64/%.debuginfo: $(C2_DIR)/%.debuginfo
+$(EXPORT_SERVER_DIR)/64/%.debuginfo: $(C2_BUILD_DIR)/%.debuginfo
$(install-file)
-$(EXPORT_JRE_LIB_ARCH_DIR)/%.diz: $(C2_DIR)/%.diz
+$(EXPORT_JRE_LIB_ARCH_DIR)/%.diz: $(C2_BUILD_DIR)/%.diz
$(install-file)
-$(EXPORT_SERVER_DIR)/64/%.diz: $(C2_DIR)/%.diz
+$(EXPORT_SERVER_DIR)/64/%.diz: $(C2_BUILD_DIR)/%.diz
$(install-file)
endif
# Client (C1)
ifeq ($(JVM_VARIANT_CLIENT), true)
# Common
-$(EXPORT_CLIENT_DIR)/%.diz: $(C1_DIR)/%.diz
+$(EXPORT_CLIENT_DIR)/%.diz: $(C1_BUILD_DIR)/%.diz
$(install-file)
-$(EXPORT_LIB_DIR)/%.jar: $(C1_DIR)/../generated/%.jar
+$(EXPORT_LIB_DIR)/%.jar: $(C1_BUILD_DIR)/../generated/%.jar
$(install-file)
-$(EXPORT_INCLUDE_DIR)/%: $(C1_DIR)/../generated/jvmtifiles/%
+$(EXPORT_INCLUDE_DIR)/%: $(C1_BUILD_DIR)/../generated/jvmtifiles/%
$(install-file)
# Windows
-$(EXPORT_CLIENT_DIR)/%.dll: $(C1_DIR)/%.dll
+$(EXPORT_CLIENT_DIR)/%.dll: $(C1_BUILD_DIR)/%.dll
$(install-file)
-$(EXPORT_CLIENT_DIR)/%.pdb: $(C1_DIR)/%.pdb
+$(EXPORT_CLIENT_DIR)/%.pdb: $(C1_BUILD_DIR)/%.pdb
$(install-file)
-$(EXPORT_CLIENT_DIR)/%.map: $(C1_DIR)/%.map
+$(EXPORT_CLIENT_DIR)/%.map: $(C1_BUILD_DIR)/%.map
$(install-file)
-$(EXPORT_LIB_DIR)/%.lib: $(C1_DIR)/%.lib
+$(EXPORT_LIB_DIR)/%.lib: $(C1_BUILD_DIR)/%.lib
$(install-file)
-$(EXPORT_JRE_BIN_DIR)/%.diz: $(C1_DIR)/%.diz
+$(EXPORT_JRE_BIN_DIR)/%.diz: $(C1_BUILD_DIR)/%.diz
$(install-file)
-$(EXPORT_JRE_BIN_DIR)/%.dll: $(C1_DIR)/%.dll
+$(EXPORT_JRE_BIN_DIR)/%.dll: $(C1_BUILD_DIR)/%.dll
$(install-file)
-$(EXPORT_JRE_BIN_DIR)/%.pdb: $(C1_DIR)/%.pdb
+$(EXPORT_JRE_BIN_DIR)/%.pdb: $(C1_BUILD_DIR)/%.pdb
$(install-file)
-$(EXPORT_JRE_BIN_DIR)/%.map: $(C1_DIR)/%.map
+$(EXPORT_JRE_BIN_DIR)/%.map: $(C1_BUILD_DIR)/%.map
$(install-file)
# Unix
-$(EXPORT_JRE_LIB_ARCH_DIR)/%.$(LIBRARY_SUFFIX): $(C1_DIR)/%.$(LIBRARY_SUFFIX)
+$(EXPORT_JRE_LIB_ARCH_DIR)/%.$(LIBRARY_SUFFIX): $(C1_BUILD_DIR)/%.$(LIBRARY_SUFFIX)
$(install-file)
-$(EXPORT_CLIENT_DIR)/%.$(LIBRARY_SUFFIX): $(C1_DIR)/%.$(LIBRARY_SUFFIX)
+$(EXPORT_CLIENT_DIR)/%.$(LIBRARY_SUFFIX): $(C1_BUILD_DIR)/%.$(LIBRARY_SUFFIX)
$(install-file)
-$(EXPORT_CLIENT_DIR)/64/%.$(LIBRARY_SUFFIX): $(C1_DIR)/%.$(LIBRARY_SUFFIX)
+$(EXPORT_CLIENT_DIR)/64/%.$(LIBRARY_SUFFIX): $(C1_BUILD_DIR)/%.$(LIBRARY_SUFFIX)
$(install-file)
-$(EXPORT_JRE_LIB_ARCH_DIR)/%.debuginfo: $(C1_DIR)/%.debuginfo
+$(EXPORT_JRE_LIB_ARCH_DIR)/%.debuginfo: $(C1_BUILD_DIR)/%.debuginfo
$(install-file)
-$(EXPORT_CLIENT_DIR)/%.debuginfo: $(C1_DIR)/%.debuginfo
+$(EXPORT_CLIENT_DIR)/%.debuginfo: $(C1_BUILD_DIR)/%.debuginfo
$(install-file)
-$(EXPORT_CLIENT_DIR)/64/%.debuginfo: $(C1_DIR)/%.debuginfo
+$(EXPORT_CLIENT_DIR)/64/%.debuginfo: $(C1_BUILD_DIR)/%.debuginfo
$(install-file)
-$(EXPORT_JRE_LIB_ARCH_DIR)/%.diz: $(C1_DIR)/%.diz
+$(EXPORT_JRE_LIB_ARCH_DIR)/%.diz: $(C1_BUILD_DIR)/%.diz
$(install-file)
-$(EXPORT_CLIENT_DIR)/64/%.diz: $(C1_DIR)/%.diz
+$(EXPORT_CLIENT_DIR)/64/%.diz: $(C1_BUILD_DIR)/%.diz
$(install-file)
endif
# Minimal1
ifeq ($(JVM_VARIANT_MINIMAL1), true)
# Common
-$(EXPORT_MINIMAL_DIR)/%.diz: $(MINIMAL1_DIR)/%.diz
+$(EXPORT_MINIMAL_DIR)/%.diz: $(MINIMAL1_BUILD_DIR)/%.diz
$(install-file)
-$(EXPORT_LIB_DIR)/%.jar: $(MINIMAL1_DIR)/../generated/%.jar
+$(EXPORT_LIB_DIR)/%.jar: $(MINIMAL1_BUILD_DIR)/../generated/%.jar
$(install-file)
-$(EXPORT_INCLUDE_DIR)/%: $(MINIMAL1_DIR)/../generated/jvmtifiles/%
+$(EXPORT_INCLUDE_DIR)/%: $(MINIMAL1_BUILD_DIR)/../generated/jvmtifiles/%
$(install-file)
# Windows
-$(EXPORT_MINIMAL_DIR)/%.dll: $(MINIMAL1_DIR)/%.dll
+$(EXPORT_MINIMAL_DIR)/%.dll: $(MINIMAL1_BUILD_DIR)/%.dll
$(install-file)
-$(EXPORT_MINIMAL_DIR)/%.pdb: $(MINIMAL1_DIR)/%.pdb
+$(EXPORT_MINIMAL_DIR)/%.pdb: $(MINIMAL1_BUILD_DIR)/%.pdb
$(install-file)
-$(EXPORT_MINIMAL_DIR)/%.map: $(MINIMAL1_DIR)/%.map
+$(EXPORT_MINIMAL_DIR)/%.map: $(MINIMAL1_BUILD_DIR)/%.map
$(install-file)
-$(EXPORT_LIB_DIR)/%.lib: $(MINIMAL1_DIR)/%.lib
+$(EXPORT_LIB_DIR)/%.lib: $(MINIMAL1_BUILD_DIR)/%.lib
$(install-file)
-$(EXPORT_JRE_BIN_DIR)/%.diz: $(MINIMAL1_DIR)/%.diz
+$(EXPORT_JRE_BIN_DIR)/%.diz: $(MINIMAL1_BUILD_DIR)/%.diz
$(install-file)
-$(EXPORT_JRE_BIN_DIR)/%.dll: $(MINIMAL1_DIR)/%.dll
+$(EXPORT_JRE_BIN_DIR)/%.dll: $(MINIMAL1_BUILD_DIR)/%.dll
$(install-file)
-$(EXPORT_JRE_BIN_DIR)/%.pdb: $(MINIMAL1_DIR)/%.pdb
+$(EXPORT_JRE_BIN_DIR)/%.pdb: $(MINIMAL1_BUILD_DIR)/%.pdb
$(install-file)
-$(EXPORT_JRE_BIN_DIR)/%.map: $(MINIMAL1_DIR)/%.map
+$(EXPORT_JRE_BIN_DIR)/%.map: $(MINIMAL1_BUILD_DIR)/%.map
$(install-file)
# Unix
-$(EXPORT_JRE_LIB_ARCH_DIR)/%.$(LIBRARY_SUFFIX): $(MINIMAL1_DIR)/%.$(LIBRARY_SUFFIX)
+$(EXPORT_JRE_LIB_ARCH_DIR)/%.$(LIBRARY_SUFFIX): $(MINIMAL1_BUILD_DIR)/%.$(LIBRARY_SUFFIX)
$(install-file)
-$(EXPORT_MINIMAL_DIR)/%.$(LIBRARY_SUFFIX): $(MINIMAL1_DIR)/%.$(LIBRARY_SUFFIX)
+$(EXPORT_MINIMAL_DIR)/%.$(LIBRARY_SUFFIX): $(MINIMAL1_BUILD_DIR)/%.$(LIBRARY_SUFFIX)
$(install-file)
-$(EXPORT_MINIMAL_DIR)/64/%.$(LIBRARY_SUFFIX): $(MINIMAL1_DIR)/%.$(LIBRARY_SUFFIX)
+$(EXPORT_MINIMAL_DIR)/64/%.$(LIBRARY_SUFFIX): $(MINIMAL1_BUILD_DIR)/%.$(LIBRARY_SUFFIX)
$(install-file)
-$(EXPORT_JRE_LIB_ARCH_DIR)/%.debuginfo: $(MINIMAL1_DIR)/%.debuginfo
+$(EXPORT_JRE_LIB_ARCH_DIR)/%.debuginfo: $(MINIMAL1_BUILD_DIR)/%.debuginfo
$(install-file)
-$(EXPORT_MINIMAL_DIR)/%.debuginfo: $(MINIMAL1_DIR)/%.debuginfo
+$(EXPORT_MINIMAL_DIR)/%.debuginfo: $(MINIMAL1_BUILD_DIR)/%.debuginfo
$(install-file)
-$(EXPORT_MINIMAL_DIR)/64/%.debuginfo: $(MINIMAL1_DIR)/%.debuginfo
+$(EXPORT_MINIMAL_DIR)/64/%.debuginfo: $(MINIMAL1_BUILD_DIR)/%.debuginfo
$(install-file)
-$(EXPORT_JRE_LIB_ARCH_DIR)/%.diz: $(MINIMAL1_DIR)/%.diz
+$(EXPORT_JRE_LIB_ARCH_DIR)/%.diz: $(MINIMAL1_BUILD_DIR)/%.diz
$(install-file)
-$(EXPORT_MINIMAL_DIR)/64/%.diz: $(MINIMAL1_DIR)/%.diz
+$(EXPORT_MINIMAL_DIR)/64/%.diz: $(MINIMAL1_BUILD_DIR)/%.diz
$(install-file)
endif
# Zero
ifeq ($(JVM_VARIANT_ZERO), true)
# Common
-$(EXPORT_LIB_DIR)/%.jar: $(ZERO_DIR)/../generated/%.jar
+$(EXPORT_LIB_DIR)/%.jar: $(ZERO_BUILD_DIR)/../generated/%.jar
$(install-file)
-$(EXPORT_INCLUDE_DIR)/%: $(ZERO_DIR)/../generated/jvmtifiles/%
+$(EXPORT_INCLUDE_DIR)/%: $(ZERO_BUILD_DIR)/../generated/jvmtifiles/%
$(install-file)
# Unix
-$(EXPORT_JRE_LIB_ARCH_DIR)/%.$(LIBRARY_SUFFIX): $(ZERO_DIR)/%.$(LIBRARY_SUFFIX)
+$(EXPORT_JRE_LIB_ARCH_DIR)/%.$(LIBRARY_SUFFIX): $(ZERO_BUILD_DIR)/%.$(LIBRARY_SUFFIX)
$(install-file)
-$(EXPORT_JRE_LIB_ARCH_DIR)/%.debuginfo: $(ZERO_DIR)/%.debuginfo
+$(EXPORT_JRE_LIB_ARCH_DIR)/%.debuginfo: $(ZERO_BUILD_DIR)/%.debuginfo
$(install-file)
-$(EXPORT_JRE_LIB_ARCH_DIR)/%.diz: $(ZERO_DIR)/%.diz
+$(EXPORT_JRE_LIB_ARCH_DIR)/%.diz: $(ZERO_BUILD_DIR)/%.diz
$(install-file)
-$(EXPORT_SERVER_DIR)/%.$(LIBRARY_SUFFIX): $(ZERO_DIR)/%.$(LIBRARY_SUFFIX)
+$(EXPORT_SERVER_DIR)/%.$(LIBRARY_SUFFIX): $(ZERO_BUILD_DIR)/%.$(LIBRARY_SUFFIX)
$(install-file)
-$(EXPORT_SERVER_DIR)/%.debuginfo: $(ZERO_DIR)/%.debuginfo
+$(EXPORT_SERVER_DIR)/%.debuginfo: $(ZERO_BUILD_DIR)/%.debuginfo
$(install-file)
-$(EXPORT_SERVER_DIR)/%.diz: $(ZERO_DIR)/%.diz
+$(EXPORT_SERVER_DIR)/%.diz: $(ZERO_BUILD_DIR)/%.diz
$(install-file)
endif
# Shark
ifeq ($(JVM_VARIANT_ZEROSHARK), true)
# Common
-$(EXPORT_LIB_DIR)/%.jar: $(SHARK_DIR)/../generated/%.jar
+$(EXPORT_LIB_DIR)/%.jar: $(SHARK_BUILD_DIR)/../generated/%.jar
$(install-file)
-$(EXPORT_INCLUDE_DIR)/%: $(SHARK_DIR)/../generated/jvmtifiles/%
+$(EXPORT_INCLUDE_DIR)/%: $(SHARK_BUILD_DIR)/../generated/jvmtifiles/%
$(install-file)
# Unix
-$(EXPORT_JRE_LIB_ARCH_DIR)/%.$(LIBRARY_SUFFIX): $(SHARK_DIR)/%.$(LIBRARY_SUFFIX)
+$(EXPORT_JRE_LIB_ARCH_DIR)/%.$(LIBRARY_SUFFIX): $(SHARK_BUILD_DIR)/%.$(LIBRARY_SUFFIX)
$(install-file)
-$(EXPORT_JRE_LIB_ARCH_DIR)/%.debuginfo): $(SHARK_DIR)/%.debuginfo
+$(EXPORT_JRE_LIB_ARCH_DIR)/%.debuginfo): $(SHARK_BUILD_DIR)/%.debuginfo
$(install-file)
-$(EXPORT_JRE_LIB_ARCH_DIR)/%.diz: $(SHARK_DIR)/%.diz
+$(EXPORT_JRE_LIB_ARCH_DIR)/%.diz: $(SHARK_BUILD_DIR)/%.diz
$(install-file)
-$(EXPORT_SERVER_DIR)/%.$(LIBRARY_SUFFIX): $(SHARK_DIR)/%.$(LIBRARY_SUFFIX)
+$(EXPORT_SERVER_DIR)/%.$(LIBRARY_SUFFIX): $(SHARK_BUILD_DIR)/%.$(LIBRARY_SUFFIX)
$(install-file)
-$(EXPORT_SERVER_DIR)/%.debuginfo: $(SHARK_DIR)/%.debuginfo
+$(EXPORT_SERVER_DIR)/%.debuginfo: $(SHARK_BUILD_DIR)/%.debuginfo
$(install-file)
-$(EXPORT_SERVER_DIR)/%.diz: $(SHARK_DIR)/%.diz
+$(EXPORT_SERVER_DIR)/%.diz: $(SHARK_BUILD_DIR)/%.diz
$(install-file)
endif
--- a/hotspot/make/bsd/makefiles/buildtree.make Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/make/bsd/makefiles/buildtree.make Thu May 16 13:47:55 2013 -0700
@@ -49,7 +49,6 @@
# adlc.make -
# jvmti.make - generate JVMTI bindings from the spec (JSR-163)
# sa.make - generate SA jar file and natives
-# env.[ck]sh - environment settings
#
# The makefiles are split this way so that "make foo" will run faster by not
# having to read the dependency files for the vm.
@@ -129,9 +128,7 @@
BUILDTREE_MAKE = $(GAMMADIR)/make/$(OS_FAMILY)/makefiles/buildtree.make
# dtrace.make is used on BSD versions that implement Dtrace (like MacOS X)
-BUILDTREE_TARGETS = Makefile flags.make flags_vm.make vm.make adlc.make \
- jvmti.make sa.make dtrace.make \
- env.sh env.csh jdkpath.sh
+BUILDTREE_TARGETS = Makefile flags.make flags_vm.make vm.make adlc.make jvmti.make sa.make dtrace.make
BUILDTREE_VARS = GAMMADIR=$(GAMMADIR) OS_FAMILY=$(OS_FAMILY) \
SRCARCH=$(SRCARCH) BUILDARCH=$(BUILDARCH) LIBARCH=$(LIBARCH) VARIANT=$(VARIANT)
@@ -354,33 +351,6 @@
echo "include \$$(GAMMADIR)/make/$(OS_FAMILY)/makefiles/$(@F)"; \
) > $@
-env.sh: $(BUILDTREE_MAKE)
- @echo Creating $@ ...
- $(QUIETLY) ( \
- $(BUILDTREE_COMMENT); \
- { echo "JAVA_HOME=$(JDK_IMPORT_PATH)"; }; \
- { \
- echo "CLASSPATH=$${CLASSPATH:+$$CLASSPATH:}.:\$${JAVA_HOME}/jre/lib/rt.jar:\$${JAVA_HOME}/jre/lib/i18n.jar"; \
- } | sed s:$${JAVA_HOME:--------}:\$${JAVA_HOME}:g; \
- echo "HOTSPOT_BUILD_USER=\"$${LOGNAME:-$$USER} in `basename $(GAMMADIR)`\""; \
- echo "export JAVA_HOME CLASSPATH HOTSPOT_BUILD_USER"; \
- ) > $@
-
-env.csh: env.sh
- @echo Creating $@ ...
- $(QUIETLY) ( \
- $(BUILDTREE_COMMENT); \
- { echo "setenv JAVA_HOME \"$(JDK_IMPORT_PATH)\""; }; \
- sed -n 's/^\([A-Za-z_][A-Za-z0-9_]*\)=/setenv \1 /p' $?; \
- ) > $@
-
-jdkpath.sh: $(BUILDTREE_MAKE)
- @echo Creating $@ ...
- $(QUIETLY) ( \
- $(BUILDTREE_COMMENT); \
- echo "JDK=${JAVA_HOME}"; \
- ) > $@
-
FORCE:
.PHONY: all FORCE
--- a/hotspot/make/bsd/makefiles/launcher.make Tue May 14 17:33:07 2013 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,115 +0,0 @@
-#
-# 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
-# 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 gamma launcher, used by vm.make
-
-
-LAUNCHER_SCRIPT = hotspot
-LAUNCHER = gamma
-
-LAUNCHERDIR := $(GAMMADIR)/src/os/posix/launcher
-LAUNCHERDIR_SHARE := $(GAMMADIR)/src/share/tools/launcher
-LAUNCHERFLAGS := $(ARCHFLAG) \
- -I$(LAUNCHERDIR) -I$(GAMMADIR)/src/share/vm/prims \
- -I$(LAUNCHERDIR_SHARE) \
- -DFULL_VERSION=\"$(HOTSPOT_RELEASE_VERSION)\" \
- -DJDK_MAJOR_VERSION=\"$(JDK_MAJOR_VERSION)\" \
- -DJDK_MINOR_VERSION=\"$(JDK_MINOR_VERSION)\" \
- -DARCH=\"$(LIBARCH)\" \
- -DGAMMA \
- -DLAUNCHER_TYPE=\"gamma\" \
- -DLINK_INTO_$(LINK_INTO) \
- $(TARGET_DEFINES)
-# Give the launcher task_for_pid() privileges so that it can be used to run JStack, JInfo, et al.
-LFLAGS_LAUNCHER += -sectcreate __TEXT __info_plist $(GAMMADIR)/src/os/bsd/launcher/Info-privileged.plist
-
-ifeq ($(LINK_INTO),AOUT)
- LAUNCHER.o = launcher.o $(JVM_OBJ_FILES)
- LAUNCHER_MAPFILE = mapfile_reorder
- LFLAGS_LAUNCHER$(LDNOMAP) += $(MAPFLAG:FILENAME=$(LAUNCHER_MAPFILE))
- LFLAGS_LAUNCHER += $(SONAMEFLAG:SONAME=$(LIBJVM)) $(STATIC_LIBGCC)
- LIBS_LAUNCHER += $(STATIC_STDCXX) $(LIBS)
-else
- LAUNCHER.o = launcher.o
- LFLAGS_LAUNCHER += -L`pwd`
-
- # The gamma launcher runs the JDK from $JAVA_HOME, overriding the JVM with a
- # freshly built JVM at ./libjvm.{so|dylib}. This is accomplished by setting
- # the library searchpath using ({DY}LD_LIBRARY_PATH) to find the local JVM
- # first. Gamma dlopen()s libjava from $JAVA_HOME/jre/lib{/$arch}, which is
- # statically linked with CoreFoundation framework libs. Unfortunately, gamma's
- # unique searchpath results in some unresolved symbols in the framework
- # libraries, because JDK libraries are inadvertently discovered first on the
- # searchpath, e.g. libjpeg. On Mac OS X, filenames are case *insensitive*.
- # So, the actual filename collision is libjpeg.dylib and libJPEG.dylib.
- # To resolve this, gamma needs to also statically link with the CoreFoundation
- # framework libraries.
-
- ifeq ($(OS_VENDOR),Darwin)
- LFLAGS_LAUNCHER += -framework CoreFoundation
- endif
-
- LIBS_LAUNCHER += -l$(JVM) $(LIBS)
-endif
-
-LINK_LAUNCHER = $(LINK.CC)
-
-LINK_LAUNCHER/PRE_HOOK = $(LINK_LIB.CXX/PRE_HOOK)
-LINK_LAUNCHER/POST_HOOK = $(LINK_LIB.CXX/POST_HOOK)
-
-LAUNCHER_OUT = launcher
-
-SUFFIXES += .d
-
-SOURCES := $(shell find $(LAUNCHERDIR) -name "*.c")
-SOURCES_SHARE := $(shell find $(LAUNCHERDIR_SHARE) -name "*.c")
-
-OBJS := $(patsubst $(LAUNCHERDIR)/%.c,$(LAUNCHER_OUT)/%.o,$(SOURCES)) $(patsubst $(LAUNCHERDIR_SHARE)/%.c,$(LAUNCHER_OUT)/%.o,$(SOURCES_SHARE))
-
-DEPFILES := $(patsubst %.o,%.d,$(OBJS))
--include $(DEPFILES)
-
-$(LAUNCHER_OUT)/%.o: $(LAUNCHERDIR_SHARE)/%.c
- $(QUIETLY) [ -d $(LAUNCHER_OUT) ] || { mkdir -p $(LAUNCHER_OUT); }
- $(QUIETLY) $(CC) -g -o $@ -c $< -MMD $(LAUNCHERFLAGS) $(CXXFLAGS)
-
-$(LAUNCHER_OUT)/%.o: $(LAUNCHERDIR)/%.c
- $(QUIETLY) [ -d $(LAUNCHER_OUT) ] || { mkdir -p $(LAUNCHER_OUT); }
- $(QUIETLY) $(CC) -g -o $@ -c $< -MMD $(LAUNCHERFLAGS) $(CXXFLAGS)
-
-$(LAUNCHER): $(OBJS) $(LIBJVM) $(LAUNCHER_MAPFILE)
- $(QUIETLY) echo Linking launcher...
- $(QUIETLY) $(LINK_LAUNCHER/PRE_HOOK)
- $(QUIETLY) $(LINK_LAUNCHER) $(LFLAGS_LAUNCHER) -o $@ $(sort $(OBJS)) $(LIBS_LAUNCHER)
- $(QUIETLY) $(LINK_LAUNCHER/POST_HOOK)
- # Sign the launcher with the development certificate (if present) so that it can be used
- # to run JStack, JInfo, et al.
- $(QUIETLY) -codesign -s openjdk_codesign $@
-
-$(LAUNCHER): $(LAUNCHER_SCRIPT)
-
-$(LAUNCHER_SCRIPT): $(LAUNCHERDIR)/launcher.script
- $(QUIETLY) sed -e 's/@@LIBARCH@@/$(LIBARCH)/g' $< > $@
- $(QUIETLY) chmod +x $@
-
--- a/hotspot/make/bsd/makefiles/vm.make Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/make/bsd/makefiles/vm.make Thu May 16 13:47:55 2013 -0700
@@ -331,9 +331,6 @@
#----------------------------------------------------------------------
# Other files
-# Gamma launcher
-include $(MAKEFILES_DIR)/launcher.make
-
# Signal interposition library
include $(MAKEFILES_DIR)/jsig.make
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/make/hotspot.script Thu May 16 13:47:55 2013 -0700
@@ -0,0 +1,218 @@
+#!/bin/sh
+
+# Copyright (c) 2010, 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 script launches HotSpot.
+#
+# If the first parameter is either "-gdb" or "-gud", HotSpot will be
+# launched inside gdb. "-gud" means "open an Emacs window and run gdb
+# inside Emacs".
+#
+# If the first parameter is "-dbx", HotSpot will be launched inside dbx.
+#
+# If the first parameter is "-valgrind", HotSpot will be launched
+# inside Valgrind (http://valgrind.kde.org) using the Memcheck skin,
+# and with memory leak detection enabled. This currently (2005jan19)
+# requires at least Valgrind 2.3.0. -Xmx16m will also be passed as
+# the first parameter to HotSpot, since lowering HotSpot's memory
+# consumption makes execution inside of Valgrind *a lot* faster.
+#
+
+
+#
+# User changeable parameters ------------------------------------------------
+#
+
+# This is the name of the gdb binary to use
+if [ ! "$GDB" ]
+then
+ GDB=gdb
+fi
+
+# This is the name of the gdb binary to use
+if [ ! "$DBX" ]
+then
+ DBX=dbx
+fi
+
+# This is the name of the Valgrind binary to use
+if [ ! "$VALGRIND" ]
+then
+ VALGRIND=valgrind
+fi
+
+# This is the name of Emacs for running GUD
+EMACS=emacs
+
+#
+# End of user changeable parameters -----------------------------------------
+#
+
+# Make sure the paths are fully specified, i.e. they must begin with /.
+REL_MYDIR=`dirname $0`
+MYDIR=`cd $REL_MYDIR && pwd`
+
+#
+# Look whether the user wants to run inside gdb
+case "$1" in
+ -gdb)
+ MODE=gdb
+ shift
+ ;;
+ -gud)
+ MODE=gud
+ shift
+ ;;
+ -dbx)
+ MODE=dbx
+ shift
+ ;;
+ -valgrind)
+ MODE=valgrind
+ shift
+ ;;
+ *)
+ MODE=run
+ ;;
+esac
+
+if [ "${ALT_JAVA_HOME}" != "" ]; then
+ JDK=${ALT_JAVA_HOME%%/jre}
+else
+ JDK=@@JDK_IMPORT_PATH@@
+fi
+
+if [ "${JDK}" = "" ]; then
+ echo "Failed to find JDK. Either ALT_JAVA_HOME is not set or JDK_IMPORT_PATH is empty."
+fi
+
+# We will set the LD_LIBRARY_PATH as follows:
+# o $JVMPATH (directory portion only)
+# o $JRE/lib/$ARCH
+# followed by the user's previous effective LD_LIBRARY_PATH, if
+# any.
+JRE=$JDK/jre
+JAVA_HOME=$JDK
+export JAVA_HOME
+
+ARCH=@@LIBARCH@@
+SBP=${MYDIR}:${JRE}/lib/${ARCH}
+
+
+# Set up a suitable LD_LIBRARY_PATH or DYLD_LIBRARY_PATH
+OS=`uname -s`
+if [ "${OS}" = "Darwin" ]
+then
+ if [ -z "$DYLD_LIBRARY_PATH" ]
+ then
+ DYLD_LIBRARY_PATH="$SBP"
+ else
+ DYLD_LIBRARY_PATH="$SBP:$DYLD_LIBRARY_PATH"
+ fi
+ export DYLD_LIBRARY_PATH
+else
+ # not 'Darwin'
+ if [ -z "$LD_LIBRARY_PATH" ]
+ then
+ LD_LIBRARY_PATH="$SBP"
+ else
+ LD_LIBRARY_PATH="$SBP:$LD_LIBRARY_PATH"
+ fi
+ export LD_LIBRARY_PATH
+fi
+
+JPARMS="-Dsun.java.launcher=gamma -XXaltjvm=$MYDIR $@ $JAVA_ARGS";
+
+# Locate the java launcher
+LAUNCHER=$JDK/bin/java
+if [ ! -x $LAUNCHER ] ; then
+ echo Error: Cannot find the java launcher \"$LAUNCHER\"
+ exit 1
+fi
+
+GDBSRCDIR=$MYDIR
+BASEDIR=`cd $MYDIR/../../.. && pwd`
+
+init_gdb() {
+# Create a gdb script in case we should run inside gdb
+ GDBSCR=/tmp/hsl.$$
+ rm -f $GDBSCR
+ cat >>$GDBSCR <<EOF
+cd `pwd`
+handle SIGUSR1 nostop noprint
+handle SIGUSR2 nostop noprint
+set args $JPARMS
+file $LAUNCHER
+directory $GDBSRCDIR
+# Get us to a point where we can set breakpoints in libjvm.so
+set breakpoint pending on
+break JNI_CreateJavaVM
+run
+# Stop in JNI_CreateJavaVM
+delete 1
+# We can now set breakpoints wherever we like
+EOF
+}
+
+
+case "$MODE" in
+ gdb)
+ init_gdb
+ $GDB -x $GDBSCR
+ rm -f $GDBSCR
+ ;;
+ gud)
+ init_gdb
+# First find out what emacs version we're using, so that we can
+# use the new pretty GDB mode if emacs -version >= 22.1
+ case `$EMACS -version 2> /dev/null` in
+ *GNU\ Emacs\ 2[23]*)
+ emacs_gud_cmd="gdba"
+ emacs_gud_args="--annotate=3"
+ ;;
+ *)
+ emacs_gud_cmd="gdb"
+ emacs_gud_args=
+ ;;
+ esac
+ $EMACS --eval "($emacs_gud_cmd \"$GDB $emacs_gud_args -x $GDBSCR\")";
+ rm -f $GDBSCR
+ ;;
+ dbx)
+ $DBX -s $HOME/.dbxrc -c "loadobject -load libjvm.so; stop in JNI_CreateJavaVM; run $JPARMS; delete all" $LAUNCHER
+ ;;
+ valgrind)
+ echo Warning: Defaulting to 16Mb heap to make Valgrind run faster, use -Xmx for larger heap
+ echo
+ $VALGRIND --tool=memcheck --leak-check=yes --num-callers=50 $LAUNCHER -Xmx16m $JPARMS
+ ;;
+ run)
+ LD_PRELOAD=$PRELOADING exec $LAUNCHER $JPARMS
+ ;;
+ *)
+ echo Error: Internal error, unknown launch mode \"$MODE\"
+ exit 1
+ ;;
+esac
+RETVAL=$?
+exit $RETVAL
--- a/hotspot/make/jprt.properties Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/make/jprt.properties Thu May 16 13:47:55 2013 -0700
@@ -134,14 +134,14 @@
jprt.build.targets.standard= \
${jprt.my.solaris.sparc}-{product|fastdebug}, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}, \
+ ${jprt.my.solaris.sparcv9}-{product|fastdebug|optimized}, \
${jprt.my.solaris.i586}-{product|fastdebug}, \
${jprt.my.solaris.x64}-{product|fastdebug}, \
${jprt.my.linux.i586}-{product|fastdebug}, \
- ${jprt.my.linux.x64}-{product|fastdebug}, \
+ ${jprt.my.linux.x64}-{product|fastdebug|optimized}, \
${jprt.my.macosx.x64}-{product|fastdebug}, \
${jprt.my.windows.i586}-{product|fastdebug}, \
- ${jprt.my.windows.x64}-{product|fastdebug}, \
+ ${jprt.my.windows.x64}-{product|fastdebug|optimized}, \
${jprt.my.linux.armvh}-{product|fastdebug}
jprt.build.targets.open= \
--- a/hotspot/make/linux/makefiles/buildtree.make Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/make/linux/makefiles/buildtree.make Thu May 16 13:47:55 2013 -0700
@@ -49,7 +49,6 @@
# adlc.make -
# jvmti.make - generate JVMTI bindings from the spec (JSR-163)
# sa.make - generate SA jar file and natives
-# env.[ck]sh - environment settings
#
# The makefiles are split this way so that "make foo" will run faster by not
# having to read the dependency files for the vm.
@@ -123,8 +122,7 @@
# For dependencies and recursive makes.
BUILDTREE_MAKE = $(GAMMADIR)/make/$(OS_FAMILY)/makefiles/buildtree.make
-BUILDTREE_TARGETS = Makefile flags.make flags_vm.make vm.make adlc.make jvmti.make sa.make \
- env.sh env.csh jdkpath.sh
+BUILDTREE_TARGETS = Makefile flags.make flags_vm.make vm.make adlc.make jvmti.make sa.make
BUILDTREE_VARS = GAMMADIR=$(GAMMADIR) OS_FAMILY=$(OS_FAMILY) \
SRCARCH=$(SRCARCH) BUILDARCH=$(BUILDARCH) LIBARCH=$(LIBARCH) VARIANT=$(VARIANT)
@@ -349,33 +347,6 @@
echo "include \$$(GAMMADIR)/make/$(OS_FAMILY)/makefiles/$(@F)"; \
) > $@
-env.sh: $(BUILDTREE_MAKE)
- @echo Creating $@ ...
- $(QUIETLY) ( \
- $(BUILDTREE_COMMENT); \
- { echo "JAVA_HOME=$(JDK_IMPORT_PATH)"; }; \
- { \
- echo "CLASSPATH=$${CLASSPATH:+$$CLASSPATH:}.:\$${JAVA_HOME}/jre/lib/rt.jar:\$${JAVA_HOME}/jre/lib/i18n.jar"; \
- } | sed s:$${JAVA_HOME:--------}:\$${JAVA_HOME}:g; \
- echo "HOTSPOT_BUILD_USER=\"$${LOGNAME:-$$USER} in `basename $(GAMMADIR)`\""; \
- echo "export JAVA_HOME CLASSPATH HOTSPOT_BUILD_USER"; \
- ) > $@
-
-env.csh: env.sh
- @echo Creating $@ ...
- $(QUIETLY) ( \
- $(BUILDTREE_COMMENT); \
- { echo "setenv JAVA_HOME \"$(JDK_IMPORT_PATH)\""; }; \
- sed -n 's/^\([A-Za-z_][A-Za-z0-9_]*\)=/setenv \1 /p' $?; \
- ) > $@
-
-jdkpath.sh: $(BUILDTREE_MAKE)
- @echo Creating $@ ...
- $(QUIETLY) ( \
- $(BUILDTREE_COMMENT); \
- echo "JDK=${JAVA_HOME}"; \
- ) > $@
-
FORCE:
.PHONY: all FORCE
--- a/hotspot/make/linux/makefiles/launcher.make Tue May 14 17:33:07 2013 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,93 +0,0 @@
-#
-# 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
-# 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 gamma launcher, used by vm.make
-
-
-LAUNCHER_SCRIPT = hotspot
-LAUNCHER = gamma
-
-LAUNCHERDIR := $(GAMMADIR)/src/os/posix/launcher
-LAUNCHERDIR_SHARE := $(GAMMADIR)/src/share/tools/launcher
-LAUNCHERFLAGS := $(ARCHFLAG) \
- -I$(LAUNCHERDIR) -I$(GAMMADIR)/src/share/vm/prims \
- -I$(LAUNCHERDIR_SHARE) \
- -DFULL_VERSION=\"$(HOTSPOT_RELEASE_VERSION)\" \
- -DJDK_MAJOR_VERSION=\"$(JDK_MAJOR_VERSION)\" \
- -DJDK_MINOR_VERSION=\"$(JDK_MINOR_VERSION)\" \
- -DARCH=\"$(LIBARCH)\" \
- -DGAMMA \
- -DLAUNCHER_TYPE=\"gamma\" \
- -DLINK_INTO_$(LINK_INTO) \
- $(TARGET_DEFINES)
-
-ifeq ($(LINK_INTO),AOUT)
- LAUNCHER.o = launcher.o $(JVM_OBJ_FILES)
- LAUNCHER_MAPFILE = mapfile_reorder
- LFLAGS_LAUNCHER$(LDNOMAP) += $(MAPFLAG:FILENAME=$(LAUNCHER_MAPFILE))
- LFLAGS_LAUNCHER += $(SONAMEFLAG:SONAME=$(LIBJVM)) $(STATIC_LIBGCC)
- LIBS_LAUNCHER += $(STATIC_STDCXX) $(LIBS)
-else
- LAUNCHER.o = launcher.o
- LFLAGS_LAUNCHER += -L `pwd`
- LIBS_LAUNCHER += -l$(JVM) $(LIBS)
-endif
-
-LINK_LAUNCHER = $(LINK.CC)
-
-LINK_LAUNCHER/PRE_HOOK = $(LINK_LIB.CXX/PRE_HOOK)
-LINK_LAUNCHER/POST_HOOK = $(LINK_LIB.CXX/POST_HOOK)
-
-LAUNCHER_OUT = launcher
-
-SUFFIXES += .d
-
-SOURCES := $(shell find $(LAUNCHERDIR) -name "*.c")
-SOURCES_SHARE := $(shell find $(LAUNCHERDIR_SHARE) -name "*.c")
-
-OBJS := $(patsubst $(LAUNCHERDIR)/%.c,$(LAUNCHER_OUT)/%.o,$(SOURCES)) $(patsubst $(LAUNCHERDIR_SHARE)/%.c,$(LAUNCHER_OUT)/%.o,$(SOURCES_SHARE))
-
-DEPFILES := $(patsubst %.o,%.d,$(OBJS))
--include $(DEPFILES)
-
-$(LAUNCHER_OUT)/%.o: $(LAUNCHERDIR_SHARE)/%.c
- $(QUIETLY) [ -d $(LAUNCHER_OUT) ] || { mkdir -p $(LAUNCHER_OUT); }
- $(QUIETLY) $(CC) -g -o $@ -c $< -MMD $(LAUNCHERFLAGS) $(CXXFLAGS)
-
-$(LAUNCHER_OUT)/%.o: $(LAUNCHERDIR)/%.c
- $(QUIETLY) [ -d $(LAUNCHER_OUT) ] || { mkdir -p $(LAUNCHER_OUT); }
- $(QUIETLY) $(CC) -g -o $@ -c $< -MMD $(LAUNCHERFLAGS) $(CXXFLAGS)
-
-$(LAUNCHER): $(OBJS) $(LIBJVM) $(LAUNCHER_MAPFILE)
- $(QUIETLY) echo Linking launcher...
- $(QUIETLY) $(LINK_LAUNCHER/PRE_HOOK)
- $(QUIETLY) $(LINK_LAUNCHER) $(LFLAGS_LAUNCHER) -o $@ $(sort $(OBJS)) $(LIBS_LAUNCHER)
- $(QUIETLY) $(LINK_LAUNCHER/POST_HOOK)
-
-$(LAUNCHER): $(LAUNCHER_SCRIPT)
-
-$(LAUNCHER_SCRIPT): $(LAUNCHERDIR)/launcher.script
- $(QUIETLY) sed -e 's/@@LIBARCH@@/$(LIBARCH)/g' $< > $@
- $(QUIETLY) chmod +x $@
-
--- a/hotspot/make/linux/makefiles/vm.make Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/make/linux/makefiles/vm.make Thu May 16 13:47:55 2013 -0700
@@ -372,9 +372,6 @@
#----------------------------------------------------------------------
# Other files
-# Gamma launcher
-include $(MAKEFILES_DIR)/launcher.make
-
# Signal interposition library
include $(MAKEFILES_DIR)/jsig.make
--- a/hotspot/make/solaris/makefiles/buildtree.make Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/make/solaris/makefiles/buildtree.make Thu May 16 13:47:55 2013 -0700
@@ -49,7 +49,6 @@
# adlc.make -
# jvmti.make - generate JVMTI bindings from the spec (JSR-163)
# sa.make - generate SA jar file and natives
-# env.[ck]sh - environment settings
#
# The makefiles are split this way so that "make foo" will run faster by not
# having to read the dependency files for the vm.
@@ -116,8 +115,7 @@
# For dependencies and recursive makes.
BUILDTREE_MAKE = $(GAMMADIR)/make/$(OS_FAMILY)/makefiles/buildtree.make
-BUILDTREE_TARGETS = Makefile flags.make flags_vm.make vm.make adlc.make jvmti.make sa.make \
- env.sh env.csh jdkpath.sh
+BUILDTREE_TARGETS = Makefile flags.make flags_vm.make vm.make adlc.make jvmti.make sa.make
BUILDTREE_VARS = GAMMADIR=$(GAMMADIR) OS_FAMILY=$(OS_FAMILY) \
ARCH=$(ARCH) BUILDARCH=$(BUILDARCH) LIBARCH=$(LIBARCH) VARIANT=$(VARIANT)
@@ -339,33 +337,6 @@
echo "include \$$(GAMMADIR)/make/$(OS_FAMILY)/makefiles/$(@F)"; \
) > $@
-env.sh: $(BUILDTREE_MAKE)
- @echo Creating $@ ...
- $(QUIETLY) ( \
- $(BUILDTREE_COMMENT); \
- { echo "JAVA_HOME=$(JDK_IMPORT_PATH)"; }; \
- { \
- echo "CLASSPATH=$${CLASSPATH:+$$CLASSPATH:}.:\$${JAVA_HOME}/jre/lib/rt.jar:\$${JAVA_HOME}/jre/lib/i18n.jar"; \
- } | sed s:$${JAVA_HOME:--------}:\$${JAVA_HOME}:g; \
- echo "HOTSPOT_BUILD_USER=\"$${LOGNAME:-$$USER} in `basename $(GAMMADIR)`\""; \
- echo "export JAVA_HOME LD_LIBRARY_PATH CLASSPATH HOTSPOT_BUILD_USER"; \
- ) > $@
-
-env.csh: env.sh
- @echo Creating $@ ...
- $(QUIETLY) ( \
- $(BUILDTREE_COMMENT); \
- { echo "setenv JAVA_HOME \"$(JDK_IMPORT_PATH)\""; }; \
- sed -n 's/^\([A-Za-z_][A-Za-z0-9_]*\)=/setenv \1 /p' $?; \
- ) > $@
-
-jdkpath.sh: $(BUILDTREE_MAKE)
- @echo Creating $@ ...
- $(QUIETLY) ( \
- $(BUILDTREE_COMMENT); \
- echo "JDK=${JAVA_HOME}"; \
- ) > $@
-
FORCE:
.PHONY: all FORCE
--- a/hotspot/make/solaris/makefiles/launcher.make Tue May 14 17:33:07 2013 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,108 +0,0 @@
-#
-# 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
-# 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 gamma launcher, used by vm.make
-
-LAUNCHER_SCRIPT = hotspot
-LAUNCHER = gamma
-
-LAUNCHERDIR = $(GAMMADIR)/src/os/posix/launcher
-LAUNCHERDIR_SHARE := $(GAMMADIR)/src/share/tools/launcher
-LAUNCHERFLAGS = $(ARCHFLAG) \
- -I$(LAUNCHERDIR) -I$(GAMMADIR)/src/share/vm/prims \
- -I$(LAUNCHERDIR_SHARE) \
- -DFULL_VERSION=\"$(HOTSPOT_RELEASE_VERSION)\" \
- -DJDK_MAJOR_VERSION=\"$(JDK_MAJOR_VERSION)\" \
- -DJDK_MINOR_VERSION=\"$(JDK_MINOR_VERSION)\" \
- -DARCH=\"$(LIBARCH)\" \
- -DGAMMA \
- -DLAUNCHER_TYPE=\"gamma\" \
- -DLINK_INTO_$(LINK_INTO) \
- $(TARGET_DEFINES)
-
-ifeq ($(LINK_INTO),AOUT)
- LAUNCHER.o = launcher.o $(JVM_OBJ_FILES)
- LAUNCHER_MAPFILE = mapfile_extended
- LFLAGS_LAUNCHER$(LDNOMAP) += $(MAPFLAG:FILENAME=$(LAUNCHER_MAPFILE))
- LIBS_LAUNCHER += $(LIBS)
-else
- LAUNCHER.o = launcher.o
- LFLAGS_LAUNCHER += -L `pwd`
- LIBS_LAUNCHER += -l$(JVM) $(LIBS)
-endif
-
-LINK_LAUNCHER = $(LINK.CXX)
-
-LINK_LAUNCHER/PRE_HOOK = $(LINK_LIB.CXX/PRE_HOOK)
-LINK_LAUNCHER/POST_HOOK = $(LINK_LIB.CXX/POST_HOOK)
-
-ifeq ("${Platform_compiler}", "sparcWorks")
-# Enable the following LAUNCHERFLAGS addition if you need to compare the
-# built ELF objects.
-#
-# The -g option makes static data global and the "-W0,-noglobal"
-# option tells the compiler to not globalize static data using a unique
-# globalization prefix. Instead force the use of a static globalization
-# prefix based on the source filepath so the objects from two identical
-# compilations are the same.
-#
-# Note: The blog says to use "-W0,-xglobalstatic", but that doesn't
-# seem to work. I got "-W0,-noglobal" from Kelly and that works.
-#LAUNCHERFLAGS += -W0,-noglobal
-endif # Platform_compiler == sparcWorks
-
-LAUNCHER_OUT = launcher
-
-SUFFIXES += .d
-
-SOURCES := $(shell find $(LAUNCHERDIR) -name "*.c")
-SOURCES_SHARE := $(shell find $(LAUNCHERDIR_SHARE) -name "*.c")
-
-OBJS := $(patsubst $(LAUNCHERDIR)/%.c,$(LAUNCHER_OUT)/%.o,$(SOURCES)) $(patsubst $(LAUNCHERDIR_SHARE)/%.c,$(LAUNCHER_OUT)/%.o,$(SOURCES_SHARE))
-
-DEPFILES := $(patsubst %.o,%.d,$(OBJS))
--include $(DEPFILES)
-
-$(LAUNCHER_OUT)/%.o: $(LAUNCHERDIR_SHARE)/%.c
- $(QUIETLY) [ -d $(LAUNCHER_OUT) ] || { mkdir -p $(LAUNCHER_OUT); }
- $(QUIETLY) $(CC) -g -o $@ -c $< -MMD $(LAUNCHERFLAGS) $(CXXFLAGS)
-
-$(LAUNCHER_OUT)/%.o: $(LAUNCHERDIR)/%.c
- $(QUIETLY) [ -d $(LAUNCHER_OUT) ] || { mkdir -p $(LAUNCHER_OUT); }
- $(QUIETLY) $(CC) -g -o $@ -c $< -MMD $(LAUNCHERFLAGS) $(CXXFLAGS)
-
-$(LAUNCHER): $(OBJS) $(LIBJVM) $(LAUNCHER_MAPFILE)
-ifeq ($(filter -sbfast -xsbfast, $(CFLAGS_BROWSE)),)
- $(QUIETLY) echo Linking launcher...
- $(QUIETLY) $(LINK_LAUNCHER/PRE_HOOK)
- $(QUIETLY) $(LINK_LAUNCHER) $(LFLAGS_LAUNCHER) -o $@ $(sort $(OBJS)) $(LIBS_LAUNCHER)
- $(QUIETLY) $(LINK_LAUNCHER/POST_HOOK)
-endif # filter -sbfast -xsbfast
-
-$(LAUNCHER): $(LAUNCHER_SCRIPT)
-
-$(LAUNCHER_SCRIPT): $(LAUNCHERDIR)/launcher.script
- $(QUIETLY) sed -e 's/@@LIBARCH@@/$(LIBARCH)/g' $< > $@
- $(QUIETLY) chmod +x $@
-
--- a/hotspot/make/solaris/makefiles/vm.make Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/make/solaris/makefiles/vm.make Thu May 16 13:47:55 2013 -0700
@@ -338,9 +338,6 @@
#----------------------------------------------------------------------
# Other files
-# Gamma launcher
-include $(MAKEFILES_DIR)/launcher.make
-
# Signal interposition library
include $(MAKEFILES_DIR)/jsig.make
--- a/hotspot/make/windows/makefiles/debug.make Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/make/windows/makefiles/debug.make Thu May 16 13:47:55 2013 -0700
@@ -33,7 +33,7 @@
BUILD_PCH_FILE=_build_pch_file.obj
!endif
-default:: $(BUILD_PCH_FILE) $(AOUT) launcher checkAndBuildSA
+default:: $(BUILD_PCH_FILE) $(AOUT) checkAndBuildSA
!include ../local.make
!include compile.make
@@ -71,4 +71,3 @@
!include $(WorkSpace)/make/windows/makefiles/shared.make
!include $(WorkSpace)/make/windows/makefiles/sa.make
-!include $(WorkSpace)/make/windows/makefiles/launcher.make
--- a/hotspot/make/windows/makefiles/fastdebug.make Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/make/windows/makefiles/fastdebug.make Thu May 16 13:47:55 2013 -0700
@@ -33,7 +33,7 @@
BUILD_PCH_FILE=_build_pch_file.obj
!endif
-default:: $(BUILD_PCH_FILE) $(AOUT) launcher checkAndBuildSA
+default:: $(BUILD_PCH_FILE) $(AOUT) checkAndBuildSA
!include ../local.make
!include compile.make
@@ -70,4 +70,3 @@
!include $(WorkSpace)/make/windows/makefiles/shared.make
!include $(WorkSpace)/make/windows/makefiles/sa.make
-!include $(WorkSpace)/make/windows/makefiles/launcher.make
--- a/hotspot/make/windows/makefiles/launcher.make Tue May 14 17:33:07 2013 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,73 +0,0 @@
-#
-# Copyright (c) 2010, 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.
-#
-#
-
-
-LAUNCHER_FLAGS=$(CXX_FLAGS) $(ARCHFLAG) \
- /D FULL_VERSION=\"$(HOTSPOT_RELEASE_VERSION)\" \
- /D JDK_MAJOR_VERSION=\"$(JDK_MAJOR_VERSION)\" \
- /D JDK_MINOR_VERSION=\"$(JDK_MINOR_VERSION)\" \
- /D GAMMA \
- /D LAUNCHER_TYPE=\"gamma\" \
- /D _CRT_SECURE_NO_WARNINGS \
- /D _CRT_SECURE_NO_DEPRECATE \
- /D LINK_INTO_LIBJVM \
- /I $(WorkSpace)\src\os\windows\launcher \
- /I $(WorkSpace)\src\share\tools\launcher \
- /I $(WorkSpace)\src\share\vm\prims \
- /I $(WorkSpace)\src\share\vm \
- /I $(WorkSpace)\src\cpu\$(Platform_arch)\vm \
- /I $(WorkSpace)\src\os\windows\vm
-
-LD_FLAGS=/manifest $(HS_INTERNAL_NAME).lib kernel32.lib user32.lib /nologo /machine:$(MACHINE) /map /debug /subsystem:console
-
-!if "$(COMPILER_NAME)" == "VS2005"
-# This VS2005 compiler has /GS as a default and requires bufferoverflowU.lib
-# on the link command line, otherwise we get missing __security_check_cookie
-# externals at link time. Even with /GS-, you need bufferoverflowU.lib.
-BUFFEROVERFLOWLIB = bufferoverflowU.lib
-LD_FLAGS = $(LD_FLAGS) $(BUFFEROVERFLOWLIB)
-!endif
-
-!if "$(COMPILER_NAME)" == "VS2010" && "$(BUILDARCH)" == "i486"
-LD_FLAGS = /SAFESEH $(LD_FLAGS)
-!endif
-
-LAUNCHERDIR = $(WorkSpace)/src/os/windows/launcher
-LAUNCHERDIR_SHARE = $(WorkSpace)/src/share/tools/launcher
-
-OUTDIR = launcher
-
-{$(LAUNCHERDIR)}.c{$(OUTDIR)}.obj:
- -mkdir $(OUTDIR) 2>NUL >NUL
- $(CXX) $(LAUNCHER_FLAGS) /c /Fo$@ $<
-
-{$(LAUNCHERDIR_SHARE)}.c{$(OUTDIR)}.obj:
- -mkdir $(OUTDIR) 2>NUL >NUL
- $(CXX) $(LAUNCHER_FLAGS) /c /Fo$@ $<
-
-$(OUTDIR)\*.obj: $(LAUNCHERDIR)\*.c $(LAUNCHERDIR)\*.h $(LAUNCHERDIR_SHARE)\*.c $(LAUNCHERDIR_SHARE)\*.h
-
-launcher: $(OUTDIR)\java.obj $(OUTDIR)\java_md.obj $(OUTDIR)\jli_util.obj
- echo $(JAVA_HOME) > jdkpath.txt
- $(LD) $(LD_FLAGS) /out:hotspot.exe $**
--- a/hotspot/make/windows/makefiles/product.make Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/make/windows/makefiles/product.make Thu May 16 13:47:55 2013 -0700
@@ -32,7 +32,7 @@
BUILD_PCH_FILE=_build_pch_file.obj
!endif
-default:: $(BUILD_PCH_FILE) $(AOUT) launcher checkAndBuildSA
+default:: $(BUILD_PCH_FILE) $(AOUT) checkAndBuildSA
!include ../local.make
!include compile.make
@@ -73,4 +73,3 @@
!include $(WorkSpace)/make/windows/makefiles/shared.make
!include $(WorkSpace)/make/windows/makefiles/sa.make
-!include $(WorkSpace)/make/windows/makefiles/launcher.make
--- a/hotspot/make/windows/makefiles/projectcreator.make Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/make/windows/makefiles/projectcreator.make Thu May 16 13:47:55 2013 -0700
@@ -59,7 +59,6 @@
-relativeSrcInclude src \
-absoluteSrcInclude $(HOTSPOTBUILDSPACE) \
-ignorePath $(HOTSPOTBUILDSPACE) \
- -ignorePath launcher \
-ignorePath share\vm\adlc \
-ignorePath share\vm\shark \
-ignorePath share\tools \
@@ -105,7 +104,6 @@
-define ALIGN_STACK_FRAMES \
-define VM_LITTLE_ENDIAN \
-prelink "" "Generating vm.def..." "cd $(HOTSPOTBUILDSPACE)\%f\%b set HOTSPOTMKSHOME=$(HOTSPOTMKSHOME) set JAVA_HOME=$(HOTSPOTJDKDIST) $(HOTSPOTMKSHOME)\sh $(HOTSPOTWORKSPACE)\make\windows\build_vm_def.sh $(LD_VER)" \
- -postbuild "" "Building hotspot.exe..." "cd $(HOTSPOTBUILDSPACE)\%f\%b set HOTSPOTMKSHOME=$(HOTSPOTMKSHOME) nmake -f $(HOTSPOTWORKSPACE)\make\windows\projectfiles\common\Makefile LOCAL_MAKE=$(HOTSPOTBUILDSPACE)\%f\local.make JAVA_HOME=$(HOTSPOTJDKDIST) launcher" \
-ignoreFile jsig.c \
-ignoreFile jvmtiEnvRecommended.cpp \
-ignoreFile jvmtiEnvStub.cpp \
--- a/hotspot/make/windows/projectfiles/common/Makefile Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/make/windows/projectfiles/common/Makefile Thu May 16 13:47:55 2013 -0700
@@ -65,7 +65,6 @@
!endif
HS_INTERNAL_NAME=jvm
-!include $(HOTSPOTWORKSPACE)/make/windows/makefiles/launcher.make
default:: $(AdditionalTargets) $(JvmtiGeneratedFiles)
--- a/hotspot/src/os/posix/launcher/java_md.c Tue May 14 17:33:07 2013 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1936 +0,0 @@
-/*
- * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * 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 "java.h"
-#include <dirent.h>
-#include <dlfcn.h>
-#include <fcntl.h>
-#include <inttypes.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <limits.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <sys/types.h>
-
-#ifndef GAMMA
-#include "manifest_info.h"
-#include "version_comp.h"
-#endif
-
-#if defined(__linux__) || defined(_ALLBSD_SOURCE)
-#include <pthread.h>
-#else
-#include <thread.h>
-#endif
-
-#ifdef __APPLE__
-#define JVM_DLL "libjvm.dylib"
-#define JAVA_DLL "libjava.dylib"
-#define LD_LIBRARY_PATH "DYLD_LIBRARY_PATH"
-#else
-#define JVM_DLL "libjvm.so"
-#define JAVA_DLL "libjava.so"
-#define LD_LIBRARY_PATH "LD_LIBRARY_PATH"
-#endif
-
-#ifndef GAMMA /* launcher.make defines ARCH */
-/*
- * If a processor / os combination has the ability to run binaries of
- * two data models and cohabitation of jre/jdk bits with both data
- * models is supported, then DUAL_MODE is defined. When DUAL_MODE is
- * defined, the architecture names for the narrow and wide version of
- * the architecture are defined in LIBARCH64NAME and LIBARCH32NAME. Currently
- * only Solaris on sparc/sparcv9 and i586/amd64 is DUAL_MODE; linux
- * i586/amd64 could be defined as DUAL_MODE but that is not the
- * current policy.
- */
-
-#ifndef LIBARCHNAME
-# error "The macro LIBARCHNAME was not defined on the compile line"
-#endif
-
-#ifdef __sun
-# define DUAL_MODE
-# ifndef LIBARCH32NAME
-# error "The macro LIBARCH32NAME was not defined on the compile line"
-# endif
-# ifndef LIBARCH64NAME
-# error "The macro LIBARCH64NAME was not defined on the compile line"
-# endif
-# include <sys/systeminfo.h>
-# include <sys/elf.h>
-# include <stdio.h>
-#endif
-
-#endif /* ifndef GAMMA */
-
-/* pointer to environment */
-extern char **environ;
-
-#ifndef GAMMA
-/*
- * A collection of useful strings. One should think of these as #define
- * entries, but actual strings can be more efficient (with many compilers).
- */
-#ifdef __linux__
-static const char *system_dir = "/usr/java";
-static const char *user_dir = "/java";
-#else /* Solaris */
-static const char *system_dir = "/usr/jdk";
-static const char *user_dir = "/jdk";
-#endif
-
-#endif /* ifndef GAMMA */
-
-/*
- * Flowchart of launcher execs and options processing on unix
- *
- * The selection of the proper vm shared library to open depends on
- * several classes of command line options, including vm "flavor"
- * options (-client, -server) and the data model options, -d32 and
- * -d64, as well as a version specification which may have come from
- * the command line or from the manifest of an executable jar file.
- * The vm selection options are not passed to the running
- * virtual machine; they must be screened out by the launcher.
- *
- * The version specification (if any) is processed first by the
- * platform independent routine SelectVersion. This may result in
- * the exec of the specified launcher version.
- *
- * Typically, the launcher execs at least once to ensure a suitable
- * LD_LIBRARY_PATH is in effect for the process. The first exec
- * screens out all the data model options; leaving the choice of data
- * model implicit in the binary selected to run. However, in case no
- * exec is done, the data model options are screened out before the vm
- * is invoked.
- *
- * incoming argv ------------------------------
- * | |
- * \|/ |
- * CheckJVMType |
- * (removes -client, -server, etc.) |
- * \|/
- * CreateExecutionEnvironment
- * (removes -d32 and -d64,
- * determines desired data model,
- * sets up LD_LIBRARY_PATH,
- * and exec's)
- * |
- * --------------------------------------------
- * |
- * \|/
- * exec child 1 incoming argv -----------------
- * | |
- * \|/ |
- * CheckJVMType |
- * (removes -client, -server, etc.) |
- * | \|/
- * | CreateExecutionEnvironment
- * | (verifies desired data model
- * | is running and acceptable
- * | LD_LIBRARY_PATH;
- * | no-op in child)
- * |
- * \|/
- * TranslateDashJArgs...
- * (Prepare to pass args to vm)
- * |
- * |
- * |
- * \|/
- * ParseArguments
- * (ignores -d32 and -d64,
- * processes version options,
- * creates argument list for vm,
- * etc.)
- *
- */
-
-static char *SetExecname(char **argv);
-static char * GetExecname();
-static jboolean GetJVMPath(const char *jrepath, const char *jvmtype,
- char *jvmpath, jint jvmpathsize, char * arch);
-static jboolean GetJREPath(char *path, jint pathsize, char * arch, jboolean speculative);
-
-#ifndef GAMMA
-const char *
-GetArch()
-{
- return LIBARCHNAME;
-}
-#endif /* ifndef GAMMA */
-
-void
-CreateExecutionEnvironment(int *_argcp,
- char ***_argvp,
- char jrepath[],
- jint so_jrepath,
- char jvmpath[],
- jint so_jvmpath,
- char **original_argv) {
- /*
- * First, determine if we are running the desired data model. If we
- * are running the desired data model, all the error messages
- * associated with calling GetJREPath, ReadKnownVMs, etc. should be
- * output. However, if we are not running the desired data model,
- * some of the errors should be suppressed since it is more
- * informative to issue an error message based on whether or not the
- * os/processor combination has dual mode capabilities.
- */
-
- char *execname = NULL;
- int original_argc = *_argcp;
- jboolean jvmpathExists;
-
- /* Compute the name of the executable */
- execname = SetExecname(*_argvp);
-
-#ifndef GAMMA
- /* Set the LD_LIBRARY_PATH environment variable, check data model
- flags, and exec process, if needed */
- {
- char *arch = (char *)GetArch(); /* like sparc or sparcv9 */
- char * jvmtype = NULL;
- int argc = *_argcp;
- char **argv = original_argv;
-
- char *runpath = NULL; /* existing effective LD_LIBRARY_PATH
- setting */
-
- int running = /* What data model is being ILP32 =>
- 32 bit vm; LP64 => 64 bit vm */
-#ifdef _LP64
- 64;
-#else
- 32;
-#endif
-
- int wanted = running; /* What data mode is being
- asked for? Current model is
- fine unless another model
- is asked for */
-
- char* new_runpath = NULL; /* desired new LD_LIBRARY_PATH string */
- char* newpath = NULL; /* path on new LD_LIBRARY_PATH */
- char* lastslash = NULL;
-
- char** newenvp = NULL; /* current environment */
-
- char** newargv = NULL;
- int newargc = 0;
-#ifdef __sun
- char* dmpath = NULL; /* data model specific LD_LIBRARY_PATH,
- Solaris only */
-#endif
-
- /*
- * Starting in 1.5, all unix platforms accept the -d32 and -d64
- * options. On platforms where only one data-model is supported
- * (e.g. ia-64 Linux), using the flag for the other data model is
- * an error and will terminate the program.
- */
-
- { /* open new scope to declare local variables */
- int i;
-
- newargv = (char **)JLI_MemAlloc((argc+1) * sizeof(*newargv));
- newargv[newargc++] = argv[0];
-
- /* scan for data model arguments and remove from argument list;
- last occurrence determines desired data model */
- for (i=1; i < argc; i++) {
-
- if (strcmp(argv[i], "-J-d64") == 0 || strcmp(argv[i], "-d64") == 0) {
- wanted = 64;
- continue;
- }
- if (strcmp(argv[i], "-J-d32") == 0 || strcmp(argv[i], "-d32") == 0) {
- wanted = 32;
- continue;
- }
- newargv[newargc++] = argv[i];
-
-#ifdef JAVA_ARGS
- if (argv[i][0] != '-')
- continue;
-#else
- if (strcmp(argv[i], "-classpath") == 0 || strcmp(argv[i], "-cp") == 0) {
- i++;
- if (i >= argc) break;
- newargv[newargc++] = argv[i];
- continue;
- }
- if (argv[i][0] != '-') { i++; break; }
-#endif
- }
-
- /* copy rest of args [i .. argc) */
- while (i < argc) {
- newargv[newargc++] = argv[i++];
- }
- newargv[newargc] = NULL;
-
- /*
- * newargv has all proper arguments here
- */
-
- argc = newargc;
- argv = newargv;
- }
-
- /* If the data model is not changing, it is an error if the
- jvmpath does not exist */
- if (wanted == running) {
- /* Find out where the JRE is that we will be using. */
- if (!GetJREPath(jrepath, so_jrepath, arch, JNI_FALSE) ) {
- fprintf(stderr, "Error: could not find Java 2 Runtime Environment.\n");
- exit(2);
- }
-
- /* Find the specified JVM type */
- if (ReadKnownVMs(jrepath, arch, JNI_FALSE) < 1) {
- fprintf(stderr, "Error: no known VMs. (check for corrupt jvm.cfg file)\n");
- exit(1);
- }
-
- jvmpath[0] = '\0';
- jvmtype = CheckJvmType(_argcp, _argvp, JNI_FALSE);
-
- if (!GetJVMPath(jrepath, jvmtype, jvmpath, so_jvmpath, arch )) {
- fprintf(stderr, "Error: no `%s' JVM at `%s'.\n", jvmtype, jvmpath);
- exit(4);
- }
- } else { /* do the same speculatively or exit */
-#ifdef DUAL_MODE
- if (running != wanted) {
- /* Find out where the JRE is that we will be using. */
- if (!GetJREPath(jrepath, so_jrepath, ((wanted==64)?LIBARCH64NAME:LIBARCH32NAME), JNI_TRUE)) {
- goto EndDataModelSpeculate;
- }
-
- /*
- * Read in jvm.cfg for target data model and process vm
- * selection options.
- */
- if (ReadKnownVMs(jrepath, ((wanted==64)?LIBARCH64NAME:LIBARCH32NAME), JNI_TRUE) < 1) {
- goto EndDataModelSpeculate;
- }
- jvmpath[0] = '\0';
- jvmtype = CheckJvmType(_argcp, _argvp, JNI_TRUE);
- /* exec child can do error checking on the existence of the path */
- jvmpathExists = GetJVMPath(jrepath, jvmtype, jvmpath, so_jvmpath,
- ((wanted==64)?LIBARCH64NAME:LIBARCH32NAME));
-
- }
- EndDataModelSpeculate: /* give up and let other code report error message */
- ;
-#else
- fprintf(stderr, "Running a %d-bit JVM is not supported on this platform.\n", wanted);
- exit(1);
-#endif
- }
-
- /*
- * We will set the LD_LIBRARY_PATH as follows:
- *
- * o $JVMPATH (directory portion only)
- * o $JRE/lib/$LIBARCHNAME
- * o $JRE/../lib/$LIBARCHNAME
- *
- * followed by the user's previous effective LD_LIBRARY_PATH, if
- * any.
- */
-
-#ifdef __sun
- /*
- * Starting in Solaris 7, ld.so.1 supports three LD_LIBRARY_PATH
- * variables:
- *
- * 1. LD_LIBRARY_PATH -- used for 32 and 64 bit searches if
- * data-model specific variables are not set.
- *
- * 2. LD_LIBRARY_PATH_64 -- overrides and replaces LD_LIBRARY_PATH
- * for 64-bit binaries.
- *
- * 3. LD_LIBRARY_PATH_32 -- overrides and replaces LD_LIBRARY_PATH
- * for 32-bit binaries.
- *
- * The vm uses LD_LIBRARY_PATH to set the java.library.path system
- * property. To shield the vm from the complication of multiple
- * LD_LIBRARY_PATH variables, if the appropriate data model
- * specific variable is set, we will act as if LD_LIBRARY_PATH had
- * the value of the data model specific variant and the data model
- * specific variant will be unset. Note that the variable for the
- * *wanted* data model must be used (if it is set), not simply the
- * current running data model.
- */
-
- switch(wanted) {
- case 0:
- if(running == 32) {
- dmpath = getenv("LD_LIBRARY_PATH_32");
- wanted = 32;
- }
- else {
- dmpath = getenv("LD_LIBRARY_PATH_64");
- wanted = 64;
- }
- break;
-
- case 32:
- dmpath = getenv("LD_LIBRARY_PATH_32");
- break;
-
- case 64:
- dmpath = getenv("LD_LIBRARY_PATH_64");
- break;
-
- default:
- fprintf(stderr, "Improper value at line %d.", __LINE__);
- exit(1); /* unknown value in wanted */
- break;
- }
-
- /*
- * If dmpath is NULL, the relevant data model specific variable is
- * not set and normal LD_LIBRARY_PATH should be used.
- */
- if( dmpath == NULL) {
- runpath = getenv("LD_LIBRARY_PATH");
- }
- else {
- runpath = dmpath;
- }
-#else
- /*
- * If not on Solaris, assume only a single LD_LIBRARY_PATH
- * variable.
- */
- runpath = getenv(LD_LIBRARY_PATH);
-#endif /* __sun */
-
-#if defined(__linux__)
- /*
- * On linux, if a binary is running as sgid or suid, glibc sets
- * LD_LIBRARY_PATH to the empty string for security purposes. (In
- * contrast, on Solaris the LD_LIBRARY_PATH variable for a
- * privileged binary does not lose its settings; but the dynamic
- * linker does apply more scrutiny to the path.) The launcher uses
- * the value of LD_LIBRARY_PATH to prevent an exec loop.
- * Therefore, if we are running sgid or suid, this function's
- * setting of LD_LIBRARY_PATH will be ineffective and we should
- * return from the function now. Getting the right libraries to
- * be found must be handled through other mechanisms.
- */
- if((getgid() != getegid()) || (getuid() != geteuid()) ) {
- return;
- }
-#elif defined(_ALLBSD_SOURCE)
- /*
- * On BSD, if a binary is running as sgid or suid, libc sets
- * LD_LIBRARY_PATH to the empty string for security purposes. (In
- * contrast, on Solaris the LD_LIBRARY_PATH variable for a
- * privileged binary does not lose its settings; but the dynamic
- * linker does apply more scrutiny to the path.) The launcher uses
- * the value of LD_LIBRARY_PATH to prevent an exec loop.
- * Therefore, if we are running sgid or suid, this function's
- * setting of LD_LIBRARY_PATH will be ineffective and we should
- * return from the function now. Getting the right libraries to
- * be found must be handled through other mechanisms.
- */
- if(issetugid()) {
- return;
- }
-#endif
-
- /* runpath contains current effective LD_LIBRARY_PATH setting */
-
- jvmpath = JLI_StringDup(jvmpath);
- new_runpath = JLI_MemAlloc( ((runpath!=NULL)?strlen(runpath):0) +
- 2*strlen(jrepath) + 2*strlen(arch) +
- strlen(jvmpath) + 52);
- newpath = new_runpath + strlen(LD_LIBRARY_PATH "=");
-
-
- /*
- * Create desired LD_LIBRARY_PATH value for target data model.
- */
- {
- /* remove the name of the .so from the JVM path */
- lastslash = strrchr(jvmpath, '/');
- if (lastslash)
- *lastslash = '\0';
-
-
- /* jvmpath, ((running != wanted)?((wanted==64)?"/"LIBARCH64NAME:"/.."):""), */
-
- sprintf(new_runpath, LD_LIBRARY_PATH "="
- "%s:"
- "%s/lib/%s:"
- "%s/../lib/%s",
- jvmpath,
-#ifdef DUAL_MODE
- jrepath, ((wanted==64)?LIBARCH64NAME:LIBARCH32NAME),
- jrepath, ((wanted==64)?LIBARCH64NAME:LIBARCH32NAME)
-#else
- jrepath, arch,
- jrepath, arch
-#endif
- );
-
-
- /*
- * Check to make sure that the prefix of the current path is the
- * desired environment variable setting.
- */
- if (runpath != NULL &&
- strncmp(newpath, runpath, strlen(newpath))==0 &&
- (runpath[strlen(newpath)] == 0 || runpath[strlen(newpath)] == ':') &&
- (running == wanted) /* data model does not have to be changed */
-#ifdef __sun
- && (dmpath == NULL) /* data model specific variables not set */
-#endif
- ) {
-
- return;
-
- }
- }
-
- /*
- * Place the desired environment setting onto the prefix of
- * LD_LIBRARY_PATH. Note that this prevents any possible infinite
- * loop of execv() because we test for the prefix, above.
- */
- if (runpath != 0) {
- strcat(new_runpath, ":");
- strcat(new_runpath, runpath);
- }
-
- if( putenv(new_runpath) != 0) {
- exit(1); /* problem allocating memory; LD_LIBRARY_PATH not set
- properly */
- }
-
- /*
- * Unix systems document that they look at LD_LIBRARY_PATH only
- * once at startup, so we have to re-exec the current executable
- * to get the changed environment variable to have an effect.
- */
-
-#ifdef __sun
- /*
- * If dmpath is not NULL, remove the data model specific string
- * in the environment for the exec'ed child.
- */
-
- if( dmpath != NULL)
- (void)UnsetEnv((wanted==32)?"LD_LIBRARY_PATH_32":"LD_LIBRARY_PATH_64");
-#endif
-
- newenvp = environ;
-
- {
- char *newexec = execname;
-#ifdef DUAL_MODE
- /*
- * If the data model is being changed, the path to the
- * executable must be updated accordingly; the executable name
- * and directory the executable resides in are separate. In the
- * case of 32 => 64, the new bits are assumed to reside in, e.g.
- * "olddir/LIBARCH64NAME/execname"; in the case of 64 => 32,
- * the bits are assumed to be in "olddir/../execname". For example,
- *
- * olddir/sparcv9/execname
- * olddir/amd64/execname
- *
- * for Solaris SPARC and Linux amd64, respectively.
- */
-
- if (running != wanted) {
- char *oldexec = strcpy(JLI_MemAlloc(strlen(execname) + 1), execname);
- char *olddir = oldexec;
- char *oldbase = strrchr(oldexec, '/');
-
-
- newexec = JLI_MemAlloc(strlen(execname) + 20);
- *oldbase++ = 0;
- sprintf(newexec, "%s/%s/%s", olddir,
- ((wanted==64) ? LIBARCH64NAME : ".."), oldbase);
- argv[0] = newexec;
- }
-#endif
-
- (void)fflush(stdout);
- (void)fflush(stderr);
- execve(newexec, argv, newenvp);
- perror("execve()");
-
- fprintf(stderr, "Error trying to exec %s.\n", newexec);
- fprintf(stderr, "Check if file exists and permissions are set correctly.\n");
-
-#ifdef DUAL_MODE
- if (running != wanted) {
- fprintf(stderr, "Failed to start a %d-bit JVM process from a %d-bit JVM.\n",
- wanted, running);
-# ifdef __sun
-
-# ifdef __sparc
- fprintf(stderr, "Verify all necessary J2SE components have been installed.\n" );
- fprintf(stderr,
- "(Solaris SPARC 64-bit components must be installed after 32-bit components.)\n" );
-# else
- fprintf(stderr, "Either 64-bit processes are not supported by this platform\n");
- fprintf(stderr, "or the 64-bit components have not been installed.\n");
-# endif
- }
-# endif
-#endif
-
- }
-
- exit(1);
- }
-
-#else /* ifndef GAMMA */
-
- /*
- * gamma launcher is simpler in that it doesn't handle VM flavors, data
- * model, LD_LIBRARY_PATH, etc. Assuming everything is set-up correctly
- * all we need to do here is to return correct path names. See also
- * GetJVMPath() and GetApplicationHome().
- */
-
- { char *arch = (char *) ARCH; /* like sparc or sparcv9 */
- char *p;
-
- if (!GetJREPath(jrepath, so_jrepath, arch, JNI_FALSE) ) {
- fprintf(stderr, "Error: could not find Java 2 Runtime Environment.\n");
- exit(2);
- }
-
- if (!GetJVMPath(jrepath, NULL, jvmpath, so_jvmpath, arch )) {
- fprintf(stderr, "Error: no JVM at `%s'.\n", jvmpath);
- exit(4);
- }
- }
-
-#endif /* ifndef GAMMA */
-}
-
-
-/*
- * On Solaris VM choosing is done by the launcher (java.c).
- */
-static jboolean
-GetJVMPath(const char *jrepath, const char *jvmtype,
- char *jvmpath, jint jvmpathsize, char * arch)
-{
- struct stat s;
-
-#ifndef GAMMA
- if (strchr(jvmtype, '/')) {
- sprintf(jvmpath, "%s/" JVM_DLL, jvmtype);
- } else {
- sprintf(jvmpath, "%s/lib/%s/%s/" JVM_DLL, jrepath, arch, jvmtype);
- }
-#else
- /*
- * For gamma launcher, JVM is either built-in or in the same directory.
- * Either way we return "<exe_path>/libjvm.so" where <exe_path> is the
- * directory where gamma launcher is located.
- */
-
- char *p;
-
- snprintf(jvmpath, jvmpathsize, "%s", GetExecname());
- p = strrchr(jvmpath, '/');
- if (p) {
- /* replace executable name with libjvm.so */
- snprintf(p + 1, jvmpathsize - (p + 1 - jvmpath), "%s", JVM_DLL);
- } else {
- /* this case shouldn't happen */
- snprintf(jvmpath, jvmpathsize, "%s", JVM_DLL);
- }
-#endif /* ifndef GAMMA */
-
- if (_launcher_debug)
- printf("Does `%s' exist ... ", jvmpath);
-
- if (stat(jvmpath, &s) == 0) {
- if (_launcher_debug)
- printf("yes.\n");
- return JNI_TRUE;
- } else {
- if (_launcher_debug)
- printf("no.\n");
- return JNI_FALSE;
- }
-}
-
-/*
- * Find path to JRE based on .exe's location or registry settings.
- */
-static jboolean
-GetJREPath(char *path, jint pathsize, char * arch, jboolean speculative)
-{
- char libjava[MAXPATHLEN];
-
- if (GetApplicationHome(path, pathsize)) {
-
- /* Is the JRE universal, i.e. no arch dir? */
- sprintf(libjava, "%s/jre/lib/" JAVA_DLL, path);
- if (access(libjava, F_OK) == 0) {
- strcat(path, "/jre");
- goto found;
- }
-
- /* Is JRE co-located with the application? */
- sprintf(libjava, "%s/lib/%s/" JAVA_DLL, path, arch);
- if (access(libjava, F_OK) == 0) {
- goto found;
- }
-
- /* Does the app ship a private JRE in <apphome>/jre directory? */
- sprintf(libjava, "%s/jre/lib/%s/" JAVA_DLL, path, arch);
- if (access(libjava, F_OK) == 0) {
- strcat(path, "/jre");
- goto found;
- }
- }
-
- if (!speculative)
- fprintf(stderr, "Error: could not find " JAVA_DLL "\n");
- return JNI_FALSE;
-
- found:
- if (_launcher_debug)
- printf("JRE path is %s\n", path);
- return JNI_TRUE;
-}
-
-jboolean
-LoadJavaVM(const char *jvmpath, InvocationFunctions *ifn)
-{
-#ifdef GAMMA
- /* JVM is directly linked with gamma launcher; no dlopen() */
- ifn->CreateJavaVM = JNI_CreateJavaVM;
- ifn->GetDefaultJavaVMInitArgs = JNI_GetDefaultJavaVMInitArgs;
- return JNI_TRUE;
-#else
- Dl_info dlinfo;
- void *libjvm;
-
- if (_launcher_debug) {
- printf("JVM path is %s\n", jvmpath);
- }
-
- libjvm = dlopen(jvmpath, RTLD_NOW + RTLD_GLOBAL);
- if (libjvm == NULL) {
-#if defined(__sparc) && !defined(_LP64) /* i.e. 32-bit sparc */
- FILE * fp;
- Elf32_Ehdr elf_head;
- int count;
- int location;
-
- fp = fopen(jvmpath, "r");
- if(fp == NULL)
- goto error;
-
- /* read in elf header */
- count = fread((void*)(&elf_head), sizeof(Elf32_Ehdr), 1, fp);
- fclose(fp);
- if(count < 1)
- goto error;
-
- /*
- * Check for running a server vm (compiled with -xarch=v8plus)
- * on a stock v8 processor. In this case, the machine type in
- * the elf header would not be included the architecture list
- * provided by the isalist command, which is turn is gotten from
- * sysinfo. This case cannot occur on 64-bit hardware and thus
- * does not have to be checked for in binaries with an LP64 data
- * model.
- */
- if(elf_head.e_machine == EM_SPARC32PLUS) {
- char buf[257]; /* recommended buffer size from sysinfo man
- page */
- long length;
- char* location;
-
- length = sysinfo(SI_ISALIST, buf, 257);
- if(length > 0) {
- location = strstr(buf, "sparcv8plus ");
- if(location == NULL) {
- fprintf(stderr, "SPARC V8 processor detected; Server compiler requires V9 or better.\n");
- fprintf(stderr, "Use Client compiler on V8 processors.\n");
- fprintf(stderr, "Could not create the Java virtual machine.\n");
- return JNI_FALSE;
- }
- }
- }
-#endif
- fprintf(stderr, "dl failure on line %d", __LINE__);
- goto error;
- }
-
- ifn->CreateJavaVM = (CreateJavaVM_t)
- dlsym(libjvm, "JNI_CreateJavaVM");
- if (ifn->CreateJavaVM == NULL)
- goto error;
-
- ifn->GetDefaultJavaVMInitArgs = (GetDefaultJavaVMInitArgs_t)
- dlsym(libjvm, "JNI_GetDefaultJavaVMInitArgs");
- if (ifn->GetDefaultJavaVMInitArgs == NULL)
- goto error;
-
- return JNI_TRUE;
-
-error:
- fprintf(stderr, "Error: failed %s, because %s\n", jvmpath, dlerror());
- return JNI_FALSE;
-#endif /* ifndef GAMMA */
-}
-
-/*
- * If app is "/foo/bin/javac", or "/foo/bin/sparcv9/javac" then put
- * "/foo" into buf.
- */
-jboolean
-GetApplicationHome(char *buf, jint bufsize)
-{
-#if defined(__linux__) || defined(_ALLBSD_SOURCE)
- char *execname = GetExecname();
- if (execname) {
- strncpy(buf, execname, bufsize-1);
- buf[bufsize-1] = '\0';
- } else {
- return JNI_FALSE;
- }
-#else
- Dl_info dlinfo;
-
- dladdr((void *)GetApplicationHome, &dlinfo);
- if (realpath(dlinfo.dli_fname, buf) == NULL) {
- fprintf(stderr, "Error: realpath(`%s') failed.\n", dlinfo.dli_fname);
- return JNI_FALSE;
- }
-#endif
-
-#ifdef GAMMA
- {
- /* gamma launcher uses JAVA_HOME environment variable to find JDK/JRE */
- char* java_home_var = getenv("JAVA_HOME");
- if (java_home_var == NULL) {
- printf("JAVA_HOME must point to a valid JDK/JRE to run gamma\n");
- return JNI_FALSE;
- }
- snprintf(buf, bufsize, "%s", java_home_var);
- }
-#else
- if (strrchr(buf, '/') == 0) {
- buf[0] = '\0';
- return JNI_FALSE;
- }
- *(strrchr(buf, '/')) = '\0'; /* executable file */
- if (strlen(buf) < 4 || strrchr(buf, '/') == 0) {
- buf[0] = '\0';
- return JNI_FALSE;
- }
- if (strcmp("/bin", buf + strlen(buf) - 4) != 0)
- *(strrchr(buf, '/')) = '\0'; /* sparcv9 or amd64 */
- if (strlen(buf) < 4 || strcmp("/bin", buf + strlen(buf) - 4) != 0) {
- buf[0] = '\0';
- return JNI_FALSE;
- }
- *(strrchr(buf, '/')) = '\0'; /* bin */
-#endif /* ifndef GAMMA */
-
- return JNI_TRUE;
-}
-
-
-/*
- * Return true if the named program exists
- */
-static int
-ProgramExists(char *name)
-{
- struct stat sb;
- if (stat(name, &sb) != 0) return 0;
- if (S_ISDIR(sb.st_mode)) return 0;
- return (sb.st_mode & S_IEXEC) != 0;
-}
-
-
-/*
- * Find a command in a directory, returning the path.
- */
-static char *
-Resolve(char *indir, char *cmd)
-{
- char name[PATH_MAX + 2], *real;
-
- if ((strlen(indir) + strlen(cmd) + 1) > PATH_MAX) return 0;
- sprintf(name, "%s%c%s", indir, FILE_SEPARATOR, cmd);
- if (!ProgramExists(name)) return 0;
- real = JLI_MemAlloc(PATH_MAX + 2);
- if (!realpath(name, real))
- strcpy(real, name);
- return real;
-}
-
-
-/*
- * Find a path for the executable
- */
-static char *
-FindExecName(char *program)
-{
- char cwdbuf[PATH_MAX+2];
- char *path;
- char *tmp_path;
- char *f;
- char *result = NULL;
-
- /* absolute path? */
- if (*program == FILE_SEPARATOR ||
- (FILE_SEPARATOR=='\\' && strrchr(program, ':')))
- return Resolve("", program+1);
-
- /* relative path? */
- if (strrchr(program, FILE_SEPARATOR) != 0) {
- char buf[PATH_MAX+2];
- return Resolve(getcwd(cwdbuf, sizeof(cwdbuf)), program);
- }
-
- /* from search path? */
- path = getenv("PATH");
- if (!path || !*path) path = ".";
- tmp_path = JLI_MemAlloc(strlen(path) + 2);
- strcpy(tmp_path, path);
-
- for (f=tmp_path; *f && result==0; ) {
- char *s = f;
- while (*f && (*f != PATH_SEPARATOR)) ++f;
- if (*f) *f++ = 0;
- if (*s == FILE_SEPARATOR)
- result = Resolve(s, program);
- else {
- /* relative path element */
- char dir[2*PATH_MAX];
- sprintf(dir, "%s%c%s", getcwd(cwdbuf, sizeof(cwdbuf)),
- FILE_SEPARATOR, s);
- result = Resolve(dir, program);
- }
- if (result != 0) break;
- }
-
- JLI_MemFree(tmp_path);
- return result;
-}
-
-
-/* Store the name of the executable once computed */
-static char *execname = NULL;
-
-/*
- * Compute the name of the executable
- *
- * In order to re-exec securely we need the absolute path of the
- * executable. On Solaris getexecname(3c) may not return an absolute
- * path so we use dladdr to get the filename of the executable and
- * then use realpath to derive an absolute path. From Solaris 9
- * onwards the filename returned in DL_info structure from dladdr is
- * an absolute pathname so technically realpath isn't required.
- * On Linux we read the executable name from /proc/self/exe.
- * As a fallback, and for platforms other than Solaris and Linux,
- * we use FindExecName to compute the executable name.
- */
-static char *
-SetExecname(char **argv)
-{
- char* exec_path = NULL;
-
- if (execname != NULL) /* Already determined */
- return (execname);
-
-#if defined(__sun)
- {
- Dl_info dlinfo;
- if (dladdr((void*)&SetExecname, &dlinfo)) {
- char *resolved = (char*)JLI_MemAlloc(PATH_MAX+1);
- if (resolved != NULL) {
- exec_path = realpath(dlinfo.dli_fname, resolved);
- if (exec_path == NULL) {
- JLI_MemFree(resolved);
- }
- }
- }
- }
-#elif defined(__linux__)
- {
- const char* self = "/proc/self/exe";
- char buf[PATH_MAX+1];
- int len = readlink(self, buf, PATH_MAX);
- if (len >= 0) {
- buf[len] = '\0'; /* readlink doesn't nul terminate */
- exec_path = JLI_StringDup(buf);
- }
- }
-#else /* !__sun && !__linux */
- {
- /* Not implemented */
- }
-#endif
-
- if (exec_path == NULL) {
- exec_path = FindExecName(argv[0]);
- }
- execname = exec_path;
- return exec_path;
-}
-
-/*
- * Return the name of the executable. Used in java_md.c to find the JRE area.
- */
-static char *
-GetExecname() {
- return execname;
-}
-
-void ReportErrorMessage(char * message, jboolean always) {
- if (always) {
- fprintf(stderr, "%s\n", message);
- }
-}
-
-void ReportErrorMessage2(char * format, char * string, jboolean always) {
- if (always) {
- fprintf(stderr, format, string);
- fprintf(stderr, "\n");
- }
-}
-
-void ReportExceptionDescription(JNIEnv * env) {
- (*env)->ExceptionDescribe(env);
-}
-
-/*
- * Return JNI_TRUE for an option string that has no effect but should
- * _not_ be passed on to the vm; return JNI_FALSE otherwise. On
- * Solaris SPARC, this screening needs to be done if:
- * 1) LD_LIBRARY_PATH does _not_ need to be reset and
- * 2) -d32 or -d64 is passed to a binary with a matching data model
- * (the exec in SetLibraryPath removes -d<n> options and points the
- * exec to the proper binary). When this exec is not done, these options
- * would end up getting passed onto the vm.
- */
-jboolean RemovableMachineDependentOption(char * option) {
- /*
- * Unconditionally remove both -d32 and -d64 options since only
- * the last such options has an effect; e.g.
- * java -d32 -d64 -d32 -version
- * is equivalent to
- * java -d32 -version
- */
-
- if( (strcmp(option, "-d32") == 0 ) ||
- (strcmp(option, "-d64") == 0 ))
- return JNI_TRUE;
- else
- return JNI_FALSE;
-}
-
-void PrintMachineDependentOptions() {
- fprintf(stdout,
- " -d32 use a 32-bit data model if available\n"
- "\n"
- " -d64 use a 64-bit data model if available\n");
- return;
-}
-
-#ifndef GAMMA
-/*
- * The following methods (down to ServerClassMachine()) answer
- * the question about whether a machine is a "server-class"
- * machine. A server-class machine is loosely defined as one
- * with 2 or more processors and 2 gigabytes or more physical
- * memory. The definition of a processor is a physical package,
- * not a hyperthreaded chip masquerading as a multi-processor.
- * The definition of memory is also somewhat fuzzy, since x86
- * machines seem not to report all the memory in their DIMMs, we
- * think because of memory mapping of graphics cards, etc.
- *
- * This code is somewhat more confused with #ifdef's than we'd
- * like because this file is used by both Solaris and Linux
- * platforms, and so needs to be parameterized for SPARC and
- * i586 hardware. The other Linux platforms (amd64 and ia64)
- * don't even ask this question, because they only come with
- * server JVMs. */
-
-# define KB (1024UL)
-# define MB (1024UL * KB)
-# define GB (1024UL * MB)
-
-/* Compute physical memory by asking the OS */
-uint64_t
-physical_memory(void) {
- const uint64_t pages = (uint64_t) sysconf(_SC_PHYS_PAGES);
- const uint64_t page_size = (uint64_t) sysconf(_SC_PAGESIZE);
- const uint64_t result = pages * page_size;
-# define UINT64_FORMAT "%" PRIu64
-
- if (_launcher_debug) {
- printf("pages: " UINT64_FORMAT
- " page_size: " UINT64_FORMAT
- " physical memory: " UINT64_FORMAT " (%.3fGB)\n",
- pages, page_size, result, result / (double) GB);
- }
- return result;
-}
-
-#if defined(__sun) && defined(__sparc)
-
-/* Methods for solaris-sparc: these are easy. */
-
-/* Ask the OS how many processors there are. */
-unsigned long
-physical_processors(void) {
- const unsigned long sys_processors = sysconf(_SC_NPROCESSORS_CONF);
-
- if (_launcher_debug) {
- printf("sysconf(_SC_NPROCESSORS_CONF): %lu\n", sys_processors);
- }
- return sys_processors;
-}
-
-/* The solaris-sparc version of the "server-class" predicate. */
-jboolean
-solaris_sparc_ServerClassMachine(void) {
- jboolean result = JNI_FALSE;
- /* How big is a server class machine? */
- const unsigned long server_processors = 2UL;
- const uint64_t server_memory = 2UL * GB;
- const uint64_t actual_memory = physical_memory();
-
- /* Is this a server class machine? */
- if (actual_memory >= server_memory) {
- const unsigned long actual_processors = physical_processors();
- if (actual_processors >= server_processors) {
- result = JNI_TRUE;
- }
- }
- if (_launcher_debug) {
- printf("solaris_" LIBARCHNAME "_ServerClassMachine: %s\n",
- (result == JNI_TRUE ? "JNI_TRUE" : "JNI_FALSE"));
- }
- return result;
-}
-
-#endif /* __sun && __sparc */
-
-#if defined(__sun) && defined(i586)
-
-/*
- * A utility method for asking the CPU about itself.
- * There's a corresponding version of linux-i586
- * because the compilers are different.
- */
-void
-get_cpuid(uint32_t arg,
- uint32_t* eaxp,
- uint32_t* ebxp,
- uint32_t* ecxp,
- uint32_t* edxp) {
-#ifdef _LP64
- asm(
- /* rbx is a callee-saved register */
- " movq %rbx, %r11 \n"
- /* rdx and rcx are 3rd and 4th argument registers */
- " movq %rdx, %r10 \n"
- " movq %rcx, %r9 \n"
- " movl %edi, %eax \n"
- " cpuid \n"
- " movl %eax, (%rsi)\n"
- " movl %ebx, (%r10)\n"
- " movl %ecx, (%r9) \n"
- " movl %edx, (%r8) \n"
- /* Restore rbx */
- " movq %r11, %rbx");
-#else
- /* EBX is a callee-saved register */
- asm(" pushl %ebx");
- /* Need ESI for storing through arguments */
- asm(" pushl %esi");
- asm(" movl 8(%ebp), %eax \n"
- " cpuid \n"
- " movl 12(%ebp), %esi \n"
- " movl %eax, (%esi) \n"
- " movl 16(%ebp), %esi \n"
- " movl %ebx, (%esi) \n"
- " movl 20(%ebp), %esi \n"
- " movl %ecx, (%esi) \n"
- " movl 24(%ebp), %esi \n"
- " movl %edx, (%esi) ");
- /* Restore ESI and EBX */
- asm(" popl %esi");
- /* Restore EBX */
- asm(" popl %ebx");
-#endif
-}
-
-#endif /* __sun && i586 */
-
-#if (defined(__linux__) || defined(_ALLBSD_SOURCE)) && defined(i586)
-
-/*
- * A utility method for asking the CPU about itself.
- * There's a corresponding version of solaris-i586
- * because the compilers are different.
- */
-void
-get_cpuid(uint32_t arg,
- uint32_t* eaxp,
- uint32_t* ebxp,
- uint32_t* ecxp,
- uint32_t* edxp) {
-#ifdef _LP64
- __asm__ volatile (/* Instructions */
- " movl %4, %%eax \n"
- " cpuid \n"
- " movl %%eax, (%0)\n"
- " movl %%ebx, (%1)\n"
- " movl %%ecx, (%2)\n"
- " movl %%edx, (%3)\n"
- : /* Outputs */
- : /* Inputs */
- "r" (eaxp),
- "r" (ebxp),
- "r" (ecxp),
- "r" (edxp),
- "r" (arg)
- : /* Clobbers */
- "%rax", "%rbx", "%rcx", "%rdx", "memory"
- );
-#else
- uint32_t value_of_eax = 0;
- uint32_t value_of_ebx = 0;
- uint32_t value_of_ecx = 0;
- uint32_t value_of_edx = 0;
- __asm__ volatile (/* Instructions */
- /* ebx is callee-save, so push it */
- " pushl %%ebx \n"
- " movl %4, %%eax \n"
- " cpuid \n"
- " movl %%eax, %0 \n"
- " movl %%ebx, %1 \n"
- " movl %%ecx, %2 \n"
- " movl %%edx, %3 \n"
- /* restore ebx */
- " popl %%ebx \n"
-
- : /* Outputs */
- "=m" (value_of_eax),
- "=m" (value_of_ebx),
- "=m" (value_of_ecx),
- "=m" (value_of_edx)
- : /* Inputs */
- "m" (arg)
- : /* Clobbers */
- "%eax", "%ecx", "%edx"
- );
- *eaxp = value_of_eax;
- *ebxp = value_of_ebx;
- *ecxp = value_of_ecx;
- *edxp = value_of_edx;
-#endif
-}
-
-#endif /* __linux__ && i586 */
-
-#ifdef i586
-/*
- * Routines shared by solaris-i586 and linux-i586.
- */
-
-enum HyperThreadingSupport_enum {
- hts_supported = 1,
- hts_too_soon_to_tell = 0,
- hts_not_supported = -1,
- hts_not_pentium4 = -2,
- hts_not_intel = -3
-};
-typedef enum HyperThreadingSupport_enum HyperThreadingSupport;
-
-/* Determine if hyperthreading is supported */
-HyperThreadingSupport
-hyperthreading_support(void) {
- HyperThreadingSupport result = hts_too_soon_to_tell;
- /* Bits 11 through 8 is family processor id */
-# define FAMILY_ID_SHIFT 8
-# define FAMILY_ID_MASK 0xf
- /* Bits 23 through 20 is extended family processor id */
-# define EXT_FAMILY_ID_SHIFT 20
-# define EXT_FAMILY_ID_MASK 0xf
- /* Pentium 4 family processor id */
-# define PENTIUM4_FAMILY_ID 0xf
- /* Bit 28 indicates Hyper-Threading Technology support */
-# define HT_BIT_SHIFT 28
-# define HT_BIT_MASK 1
- uint32_t vendor_id[3] = { 0U, 0U, 0U };
- uint32_t value_of_eax = 0U;
- uint32_t value_of_edx = 0U;
- uint32_t dummy = 0U;
-
- /* Yes, this is supposed to be [0], [2], [1] */
- get_cpuid(0, &dummy, &vendor_id[0], &vendor_id[2], &vendor_id[1]);
- if (_launcher_debug) {
- printf("vendor: %c %c %c %c %c %c %c %c %c %c %c %c \n",
- ((vendor_id[0] >> 0) & 0xff),
- ((vendor_id[0] >> 8) & 0xff),
- ((vendor_id[0] >> 16) & 0xff),
- ((vendor_id[0] >> 24) & 0xff),
- ((vendor_id[1] >> 0) & 0xff),
- ((vendor_id[1] >> 8) & 0xff),
- ((vendor_id[1] >> 16) & 0xff),
- ((vendor_id[1] >> 24) & 0xff),
- ((vendor_id[2] >> 0) & 0xff),
- ((vendor_id[2] >> 8) & 0xff),
- ((vendor_id[2] >> 16) & 0xff),
- ((vendor_id[2] >> 24) & 0xff));
- }
- get_cpuid(1, &value_of_eax, &dummy, &dummy, &value_of_edx);
- if (_launcher_debug) {
- printf("value_of_eax: 0x%x value_of_edx: 0x%x\n",
- value_of_eax, value_of_edx);
- }
- if ((((value_of_eax >> FAMILY_ID_SHIFT) & FAMILY_ID_MASK) == PENTIUM4_FAMILY_ID) ||
- (((value_of_eax >> EXT_FAMILY_ID_SHIFT) & EXT_FAMILY_ID_MASK) != 0)) {
- if ((((vendor_id[0] >> 0) & 0xff) == 'G') &&
- (((vendor_id[0] >> 8) & 0xff) == 'e') &&
- (((vendor_id[0] >> 16) & 0xff) == 'n') &&
- (((vendor_id[0] >> 24) & 0xff) == 'u') &&
- (((vendor_id[1] >> 0) & 0xff) == 'i') &&
- (((vendor_id[1] >> 8) & 0xff) == 'n') &&
- (((vendor_id[1] >> 16) & 0xff) == 'e') &&
- (((vendor_id[1] >> 24) & 0xff) == 'I') &&
- (((vendor_id[2] >> 0) & 0xff) == 'n') &&
- (((vendor_id[2] >> 8) & 0xff) == 't') &&
- (((vendor_id[2] >> 16) & 0xff) == 'e') &&
- (((vendor_id[2] >> 24) & 0xff) == 'l')) {
- if (((value_of_edx >> HT_BIT_SHIFT) & HT_BIT_MASK) == HT_BIT_MASK) {
- if (_launcher_debug) {
- printf("Hyperthreading supported\n");
- }
- result = hts_supported;
- } else {
- if (_launcher_debug) {
- printf("Hyperthreading not supported\n");
- }
- result = hts_not_supported;
- }
- } else {
- if (_launcher_debug) {
- printf("Not GenuineIntel\n");
- }
- result = hts_not_intel;
- }
- } else {
- if (_launcher_debug) {
- printf("not Pentium 4 or extended\n");
- }
- result = hts_not_pentium4;
- }
- return result;
-}
-
-/* Determine how many logical processors there are per CPU */
-unsigned int
-logical_processors_per_package(void) {
- /*
- * After CPUID with EAX==1, register EBX bits 23 through 16
- * indicate the number of logical processors per package
- */
-# define NUM_LOGICAL_SHIFT 16
-# define NUM_LOGICAL_MASK 0xff
- unsigned int result = 1U;
- const HyperThreadingSupport hyperthreading = hyperthreading_support();
-
- if (hyperthreading == hts_supported) {
- uint32_t value_of_ebx = 0U;
- uint32_t dummy = 0U;
-
- get_cpuid(1, &dummy, &value_of_ebx, &dummy, &dummy);
- result = (value_of_ebx >> NUM_LOGICAL_SHIFT) & NUM_LOGICAL_MASK;
- if (_launcher_debug) {
- printf("logical processors per package: %u\n", result);
- }
- }
- return result;
-}
-
-/* Compute the number of physical processors, not logical processors */
-unsigned long
-physical_processors(void) {
- const long sys_processors = sysconf(_SC_NPROCESSORS_CONF);
- unsigned long result = sys_processors;
-
- if (_launcher_debug) {
- printf("sysconf(_SC_NPROCESSORS_CONF): %lu\n", sys_processors);
- }
- if (sys_processors > 1) {
- unsigned int logical_processors = logical_processors_per_package();
- if (logical_processors > 1) {
- result = (unsigned long) sys_processors / logical_processors;
- }
- }
- if (_launcher_debug) {
- printf("physical processors: %lu\n", result);
- }
- return result;
-}
-
-#endif /* i586 */
-
-#if defined(__sun) && defined(i586)
-
-/* The definition of a server-class machine for solaris-i586/amd64 */
-jboolean
-solaris_i586_ServerClassMachine(void) {
- jboolean result = JNI_FALSE;
- /* How big is a server class machine? */
- const unsigned long server_processors = 2UL;
- const uint64_t server_memory = 2UL * GB;
- /*
- * We seem not to get our full complement of memory.
- * We allow some part (1/8?) of the memory to be "missing",
- * based on the sizes of DIMMs, and maybe graphics cards.
- */
- const uint64_t missing_memory = 256UL * MB;
- const uint64_t actual_memory = physical_memory();
-
- /* Is this a server class machine? */
- if (actual_memory >= (server_memory - missing_memory)) {
- const unsigned long actual_processors = physical_processors();
- if (actual_processors >= server_processors) {
- result = JNI_TRUE;
- }
- }
- if (_launcher_debug) {
- printf("solaris_" LIBARCHNAME "_ServerClassMachine: %s\n",
- (result == JNI_TRUE ? "true" : "false"));
- }
- return result;
-}
-
-#endif /* __sun && i586 */
-
-#if defined(__linux__) && defined(i586)
-
-/* The definition of a server-class machine for linux-i586 */
-jboolean
-linux_i586_ServerClassMachine(void) {
- jboolean result = JNI_FALSE;
- /* How big is a server class machine? */
- const unsigned long server_processors = 2UL;
- const uint64_t server_memory = 2UL * GB;
- /*
- * We seem not to get our full complement of memory.
- * We allow some part (1/8?) of the memory to be "missing",
- * based on the sizes of DIMMs, and maybe graphics cards.
- */
- const uint64_t missing_memory = 256UL * MB;
- const uint64_t actual_memory = physical_memory();
-
- /* Is this a server class machine? */
- if (actual_memory >= (server_memory - missing_memory)) {
- const unsigned long actual_processors = physical_processors();
- if (actual_processors >= server_processors) {
- result = JNI_TRUE;
- }
- }
- if (_launcher_debug) {
- printf("linux_" LIBARCHNAME "_ServerClassMachine: %s\n",
- (result == JNI_TRUE ? "true" : "false"));
- }
- return result;
-}
-
-#endif /* __linux__ && i586 */
-
-#if defined(_ALLBSD_SOURCE) && defined(i586)
-
-/* The definition of a server-class machine for bsd-i586 */
-jboolean
-bsd_i586_ServerClassMachine(void) {
- jboolean result = JNI_FALSE;
- /* How big is a server class machine? */
- const unsigned long server_processors = 2UL;
- const uint64_t server_memory = 2UL * GB;
- /*
- * We seem not to get our full complement of memory.
- * We allow some part (1/8?) of the memory to be "missing",
- * based on the sizes of DIMMs, and maybe graphics cards.
- */
- const uint64_t missing_memory = 256UL * MB;
- const uint64_t actual_memory = physical_memory();
-
- /* Is this a server class machine? */
- if (actual_memory >= (server_memory - missing_memory)) {
- const unsigned long actual_processors = physical_processors();
- if (actual_processors >= server_processors) {
- result = JNI_TRUE;
- }
- }
- if (_launcher_debug) {
- printf("linux_" LIBARCHNAME "_ServerClassMachine: %s\n",
- (result == JNI_TRUE ? "true" : "false"));
- }
- return result;
-}
-
-#endif /* _ALLBSD_SOURCE && i586 */
-
-/* Dispatch to the platform-specific definition of "server-class" */
-jboolean
-ServerClassMachine(void) {
- jboolean result = JNI_FALSE;
-#if defined(NEVER_ACT_AS_SERVER_CLASS_MACHINE)
- result = JNI_FALSE;
-#elif defined(ALWAYS_ACT_AS_SERVER_CLASS_MACHINE)
- result = JNI_TRUE;
-#elif defined(__sun) && defined(__sparc)
- result = solaris_sparc_ServerClassMachine();
-#elif defined(__sun) && defined(i586)
- result = solaris_i586_ServerClassMachine();
-#elif defined(__linux__) && defined(i586)
- result = linux_i586_ServerClassMachine();
-#elif defined(_ALLBSD_SOURCE) && defined(i586)
- result = bsd_i586_ServerClassMachine();
-#else
- if (_launcher_debug) {
- printf("ServerClassMachine: returns default value of %s\n",
- (result == JNI_TRUE ? "true" : "false"));
- }
-#endif
- return result;
-}
-
-/*
- * Since using the file system as a registry is a bit risky, perform
- * additional sanity checks on the identified directory to validate
- * it as a valid jre/sdk.
- *
- * Return 0 if the tests fail; otherwise return non-zero (true).
- *
- * Note that checking for anything more than the existence of an
- * executable object at bin/java relative to the path being checked
- * will break the regression tests.
- */
-static int
-CheckSanity(char *path, char *dir)
-{
- char buffer[PATH_MAX];
-
- if (strlen(path) + strlen(dir) + 11 > PATH_MAX)
- return (0); /* Silently reject "impossibly" long paths */
-
- (void)strcat(strcat(strcat(strcpy(buffer, path), "/"), dir), "/bin/java");
- return ((access(buffer, X_OK) == 0) ? 1 : 0);
-}
-
-/*
- * Determine if there is an acceptable JRE in the directory dirname.
- * Upon locating the "best" one, return a fully qualified path to
- * it. "Best" is defined as the most advanced JRE meeting the
- * constraints contained in the manifest_info. If no JRE in this
- * directory meets the constraints, return NULL.
- *
- * Note that we don't check for errors in reading the directory
- * (which would be done by checking errno). This is because it
- * doesn't matter if we get an error reading the directory, or
- * we just don't find anything interesting in the directory. We
- * just return NULL in either case.
- *
- * The historical names of j2sdk and j2re were changed to jdk and
- * jre respecively as part of the 1.5 rebranding effort. Since the
- * former names are legacy on Linux, they must be recognized for
- * all time. Fortunately, this is a minor cost.
- */
-static char
-*ProcessDir(manifest_info *info, char *dirname)
-{
- DIR *dirp;
- struct dirent *dp;
- char *best = NULL;
- int offset;
- int best_offset = 0;
- char *ret_str = NULL;
- char buffer[PATH_MAX];
-
- if ((dirp = opendir(dirname)) == NULL)
- return (NULL);
-
- do {
- if ((dp = readdir(dirp)) != NULL) {
- offset = 0;
- if ((strncmp(dp->d_name, "jre", 3) == 0) ||
- (strncmp(dp->d_name, "jdk", 3) == 0))
- offset = 3;
- else if (strncmp(dp->d_name, "j2re", 4) == 0)
- offset = 4;
- else if (strncmp(dp->d_name, "j2sdk", 5) == 0)
- offset = 5;
- if (offset > 0) {
- if ((JLI_AcceptableRelease(dp->d_name + offset,
- info->jre_version)) && CheckSanity(dirname, dp->d_name))
- if ((best == NULL) || (JLI_ExactVersionId(
- dp->d_name + offset, best + best_offset) > 0)) {
- if (best != NULL)
- JLI_MemFree(best);
- best = JLI_StringDup(dp->d_name);
- best_offset = offset;
- }
- }
- }
- } while (dp != NULL);
- (void) closedir(dirp);
- if (best == NULL)
- return (NULL);
- else {
- ret_str = JLI_MemAlloc(strlen(dirname) + strlen(best) + 2);
- ret_str = strcat(strcat(strcpy(ret_str, dirname), "/"), best);
- JLI_MemFree(best);
- return (ret_str);
- }
-}
-
-/*
- * This is the global entry point. It examines the host for the optimal
- * JRE to be used by scanning a set of directories. The set of directories
- * is platform dependent and can be overridden by the environment
- * variable JAVA_VERSION_PATH.
- *
- * This routine itself simply determines the set of appropriate
- * directories before passing control onto ProcessDir().
- */
-char*
-LocateJRE(manifest_info* info)
-{
- char *path;
- char *home;
- char *target = NULL;
- char *dp;
- char *cp;
-
- /*
- * Start by getting JAVA_VERSION_PATH
- */
- if (info->jre_restrict_search)
- path = JLI_StringDup(system_dir);
- else if ((path = getenv("JAVA_VERSION_PATH")) != NULL)
- path = JLI_StringDup(path);
- else
- if ((home = getenv("HOME")) != NULL) {
- path = (char *)JLI_MemAlloc(strlen(home) + strlen(system_dir) +
- strlen(user_dir) + 2);
- path = strcat(strcat(strcat(strcpy(path, home),
- user_dir), ":"), system_dir);
- } else
- path = JLI_StringDup(system_dir);
-
- /*
- * Step through each directory on the path. Terminate the scan with
- * the first directory with an acceptable JRE.
- */
- cp = dp = path;
- while (dp != NULL) {
- cp = strchr(dp, (int)':');
- if (cp != NULL)
- *cp = (char)NULL;
- if ((target = ProcessDir(info, dp)) != NULL)
- break;
- dp = cp;
- if (dp != NULL)
- dp++;
- }
- JLI_MemFree(path);
- return (target);
-}
-
-/*
- * Given a path to a jre to execute, this routine checks if this process
- * is indeed that jre. If not, it exec's that jre.
- *
- * We want to actually check the paths rather than just the version string
- * built into the executable, so that given version specification (and
- * JAVA_VERSION_PATH) will yield the exact same Java environment, regardless
- * of the version of the arbitrary launcher we start with.
- */
-void
-ExecJRE(char *jre, char **argv)
-{
- char wanted[PATH_MAX];
- char *execname;
- char *progname;
-
- /*
- * Resolve the real path to the directory containing the selected JRE.
- */
- if (realpath(jre, wanted) == NULL) {
- fprintf(stderr, "Unable to resolve %s\n", jre);
- exit(1);
- }
-
- /*
- * Resolve the real path to the currently running launcher.
- */
- execname = SetExecname(argv);
- if (execname == NULL) {
- fprintf(stderr, "Unable to resolve current executable\n");
- exit(1);
- }
-
- /*
- * If the path to the selected JRE directory is a match to the initial
- * portion of the path to the currently executing JRE, we have a winner!
- * If so, just return.
- */
- if (strncmp(wanted, execname, strlen(wanted)) == 0)
- return; /* I am the droid you were looking for */
-
- /*
- * If this isn't the selected version, exec the selected version.
- */
-#ifdef JAVA_ARGS /* javac, jar and friends. */
- progname = "java";
-#else /* java, oldjava, javaw and friends */
-#ifdef PROGNAME
- progname = PROGNAME;
-#else
- progname = *argv;
- if ((s = strrchr(progname, FILE_SEPARATOR)) != 0) {
- progname = s + 1;
- }
-#endif /* PROGNAME */
-#endif /* JAVA_ARGS */
-
- /*
- * This should never happen (because of the selection code in SelectJRE),
- * but check for "impossibly" long path names just because buffer overruns
- * can be so deadly.
- */
- if (strlen(wanted) + strlen(progname) + 6 > PATH_MAX) {
- fprintf(stderr, "Path length exceeds maximum length (PATH_MAX)\n");
- exit(1);
- }
-
- /*
- * Construct the path and exec it.
- */
- (void)strcat(strcat(wanted, "/bin/"), progname);
- argv[0] = progname;
- if (_launcher_debug) {
- int i;
- printf("ReExec Command: %s (%s)\n", wanted, argv[0]);
- printf("ReExec Args:");
- for (i = 1; argv[i] != NULL; i++)
- printf(" %s", argv[i]);
- printf("\n");
- }
- (void)fflush(stdout);
- (void)fflush(stderr);
- execv(wanted, argv);
- perror("execv()");
- fprintf(stderr, "Exec of %s failed\n", wanted);
- exit(1);
-}
-#endif /* ifndef GAMMA */
-
-/*
- * "Borrowed" from Solaris 10 where the unsetenv() function is being added
- * to libc thanks to SUSv3 (Standard Unix Specification, version 3). As
- * such, in the fullness of time this will appear in libc on all relevant
- * Solaris/Linux platforms and maybe even the Windows platform. At that
- * time, this stub can be removed.
- *
- * This implementation removes the environment locking for multithreaded
- * applications. (We don't have access to these mutexes within libc and
- * the launcher isn't multithreaded.) Note that what remains is platform
- * independent, because it only relies on attributes that a POSIX environment
- * defines.
- *
- * Returns 0 on success, -1 on failure.
- *
- * Also removed was the setting of errno. The only value of errno set
- * was EINVAL ("Invalid Argument").
- */
-
-/*
- * s1(environ) is name=value
- * s2(name) is name(not the form of name=value).
- * if names match, return value of 1, else return 0
- */
-static int
-match_noeq(const char *s1, const char *s2)
-{
- while (*s1 == *s2++) {
- if (*s1++ == '=')
- return (1);
- }
- if (*s1 == '=' && s2[-1] == '\0')
- return (1);
- return (0);
-}
-
-/*
- * added for SUSv3 standard
- *
- * Delete entry from environ.
- * Do not free() memory! Other threads may be using it.
- * Keep it around forever.
- */
-static int
-borrowed_unsetenv(const char *name)
-{
- long idx; /* index into environ */
-
- if (name == NULL || *name == '\0' ||
- strchr(name, '=') != NULL) {
- return (-1);
- }
-
- for (idx = 0; environ[idx] != NULL; idx++) {
- if (match_noeq(environ[idx], name))
- break;
- }
- if (environ[idx] == NULL) {
- /* name not found but still a success */
- return (0);
- }
- /* squeeze up one entry */
- do {
- environ[idx] = environ[idx+1];
- } while (environ[++idx] != NULL);
-
- return (0);
-}
-/* --- End of "borrowed" code --- */
-
-/*
- * Wrapper for unsetenv() function.
- */
-int
-UnsetEnv(char *name)
-{
- return(borrowed_unsetenv(name));
-}
-
-/* --- Splash Screen shared library support --- */
-
-static const char* SPLASHSCREEN_SO = "libsplashscreen.so";
-
-static void* hSplashLib = NULL;
-
-void* SplashProcAddress(const char* name) {
- if (!hSplashLib) {
- hSplashLib = dlopen(SPLASHSCREEN_SO, RTLD_LAZY | RTLD_GLOBAL);
- }
- if (hSplashLib) {
- void* sym = dlsym(hSplashLib, name);
- return sym;
- } else {
- return NULL;
- }
-}
-
-void SplashFreeLibrary() {
- if (hSplashLib) {
- dlclose(hSplashLib);
- hSplashLib = NULL;
- }
-}
-
-/*
- * Block current thread and continue execution in a new thread
- */
-int
-ContinueInNewThread(int (JNICALL *continuation)(void *), jlong stack_size, void * args) {
- int rslt;
-#if defined(__linux__) || defined(_ALLBSD_SOURCE)
- pthread_t tid;
- pthread_attr_t attr;
- pthread_attr_init(&attr);
- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
-
- if (stack_size > 0) {
- pthread_attr_setstacksize(&attr, stack_size);
- }
-
- if (pthread_create(&tid, &attr, (void *(*)(void*))continuation, (void*)args) == 0) {
- void * tmp;
- pthread_join(tid, &tmp);
- rslt = (int)(intptr_t)tmp;
- } else {
- /*
- * Continue execution in current thread if for some reason (e.g. out of
- * memory/LWP) a new thread can't be created. This will likely fail
- * later in continuation as JNI_CreateJavaVM needs to create quite a
- * few new threads, anyway, just give it a try..
- */
- rslt = continuation(args);
- }
-
- pthread_attr_destroy(&attr);
-#else
- thread_t tid;
- long flags = 0;
- if (thr_create(NULL, stack_size, (void *(*)(void *))continuation, args, flags, &tid) == 0) {
- void * tmp;
- thr_join(tid, NULL, &tmp);
- rslt = (int)(intptr_t)tmp;
- } else {
- /* See above. Continue in current thread if thr_create() failed */
- rslt = continuation(args);
- }
-#endif
- return rslt;
-}
-
-/* Coarse estimation of number of digits assuming the worst case is a 64-bit pid. */
-#define MAX_PID_STR_SZ 20
-
-void SetJavaLauncherPlatformProps() {
- /* Linux only */
-#ifdef __linux__
- const char *substr = "-Dsun.java.launcher.pid=";
- char *pid_prop_str = (char *)JLI_MemAlloc(strlen(substr) + MAX_PID_STR_SZ + 1);
- sprintf(pid_prop_str, "%s%d", substr, getpid());
- AddOption(pid_prop_str, NULL);
-#endif
-}
--- a/hotspot/src/os/posix/launcher/java_md.h Tue May 14 17:33:07 2013 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,82 +0,0 @@
-/*
- * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * 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 JAVA_MD_H
-#define JAVA_MD_H
-
-#include <limits.h>
-#include <unistd.h>
-#include <sys/param.h>
-#ifndef GAMMA
-#include "manifest_info.h"
-#endif
-#include "jli_util.h"
-
-#define PATH_SEPARATOR ':'
-#define FILESEP "/"
-#define FILE_SEPARATOR '/'
-#define IS_FILE_SEPARATOR(c) ((c) == '/')
-#ifndef MAXNAMELEN
-#define MAXNAMELEN PATH_MAX
-#endif
-
-#ifdef JAVA_ARGS
-/*
- * ApplicationHome is prepended to each of these entries; the resulting
- * strings are concatenated (separated by PATH_SEPARATOR) and used as the
- * value of -cp option to the launcher.
- */
-#ifndef APP_CLASSPATH
-#define APP_CLASSPATH { "/lib/tools.jar", "/classes" }
-#endif
-#endif
-
-#ifdef HAVE_GETHRTIME
-/*
- * Support for doing cheap, accurate interval timing.
- */
-#include <sys/time.h>
-#define CounterGet() (gethrtime()/1000)
-#define Counter2Micros(counts) (counts)
-#else
-#define CounterGet() (0)
-#define Counter2Micros(counts) (1)
-#endif /* HAVE_GETHRTIME */
-
-#ifdef _LP64
-#define JLONG_FORMAT "%ld"
-#else
-#define JLONG_FORMAT "%lld"
-#endif
-
-/*
- * Function prototypes.
- */
-#ifndef GAMMA
-char *LocateJRE(manifest_info *info);
-void ExecJRE(char *jre, char **argv);
-#endif
-int UnsetEnv(char *name);
-
-#endif
--- a/hotspot/src/os/posix/launcher/launcher.script Tue May 14 17:33:07 2013 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,218 +0,0 @@
-#!/bin/sh
-
-# Copyright (c) 2010, 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 script launches HotSpot.
-#
-# If the first parameter is either "-gdb" or "-gud", HotSpot will be
-# launched inside gdb. "-gud" means "open an Emacs window and run gdb
-# inside Emacs".
-#
-# If the first parameter is "-dbx", HotSpot will be launched inside dbx.
-#
-# If the first parameter is "-valgrind", HotSpot will be launched
-# inside Valgrind (http://valgrind.kde.org) using the Memcheck skin,
-# and with memory leak detection enabled. This currently (2005jan19)
-# requires at least Valgrind 2.3.0. -Xmx16m will also be passed as
-# the first parameter to HotSpot, since lowering HotSpot's memory
-# consumption makes execution inside of Valgrind *a lot* faster.
-#
-
-
-#
-# User changeable parameters ------------------------------------------------
-#
-
-# This is the name of the gdb binary to use
-if [ ! "$GDB" ]
-then
- GDB=gdb
-fi
-
-# This is the name of the gdb binary to use
-if [ ! "$DBX" ]
-then
- DBX=dbx
-fi
-
-# This is the name of the Valgrind binary to use
-if [ ! "$VALGRIND" ]
-then
- VALGRIND=valgrind
-fi
-
-# This is the name of Emacs for running GUD
-EMACS=emacs
-
-#
-# End of user changeable parameters -----------------------------------------
-#
-
-# Make sure the paths are fully specified, i.e. they must begin with /.
-REL_MYDIR=`dirname $0`
-MYDIR=`cd $REL_MYDIR && pwd`
-
-# Look whether the user wants to run inside gdb
-case "$1" in
- -gdb)
- MODE=gdb
- shift
- ;;
- -gud)
- MODE=gud
- shift
- ;;
- -dbx)
- MODE=dbx
- shift
- ;;
- -valgrind)
- MODE=valgrind
- shift
- ;;
- *)
- MODE=run
- ;;
-esac
-
-JDK=
-if [ "${ALT_JAVA_HOME}" = "" ]; then
- . ${MYDIR}/jdkpath.sh
-else
- JDK=${ALT_JAVA_HOME%%/jre};
-fi
-
-if [ "${JDK}" = "" ]; then
- echo Failed to find JDK. ALT_JAVA_HOME is not set or ./jdkpath.sh is empty or not found.
- exit 1
-fi
-
-# We will set the LD_LIBRARY_PATH as follows:
-# o $JVMPATH (directory portion only)
-# o $JRE/lib/$ARCH
-# followed by the user's previous effective LD_LIBRARY_PATH, if
-# any.
-JRE=$JDK/jre
-JAVA_HOME=$JDK
-export JAVA_HOME
-
-ARCH=@@LIBARCH@@
-SBP=${MYDIR}:${JRE}/lib/${ARCH}
-
-
-# Set up a suitable LD_LIBRARY_PATH or DYLD_LIBRARY_PATH
-OS=`uname -s`
-if [ "${OS}" = "Darwin" ]
-then
- if [ -z "$DYLD_LIBRARY_PATH" ]
- then
- DYLD_LIBRARY_PATH="$SBP"
- else
- DYLD_LIBRARY_PATH="$SBP:$DYLD_LIBRARY_PATH"
- fi
- export DYLD_LIBRARY_PATH
-else
- # not 'Darwin'
- if [ -z "$LD_LIBRARY_PATH" ]
- then
- LD_LIBRARY_PATH="$SBP"
- else
- LD_LIBRARY_PATH="$SBP:$LD_LIBRARY_PATH"
- fi
- export LD_LIBRARY_PATH
-fi
-
-JPARMS="$@ $JAVA_ARGS";
-
-# Locate the gamma development launcher
-LAUNCHER=${MYDIR}/gamma
-if [ ! -x $LAUNCHER ] ; then
- echo Error: Cannot find the gamma development launcher \"$LAUNCHER\"
- exit 1
-fi
-
-GDBSRCDIR=$MYDIR
-BASEDIR=`cd $MYDIR/../../.. && pwd`
-
-init_gdb() {
-# Create a gdb script in case we should run inside gdb
- GDBSCR=/tmp/hsl.$$
- rm -f $GDBSCR
- cat >>$GDBSCR <<EOF
-cd `pwd`
-handle SIGUSR1 nostop noprint
-handle SIGUSR2 nostop noprint
-set args $JPARMS
-file $LAUNCHER
-directory $GDBSRCDIR
-# Get us to a point where we can set breakpoints in libjvm.so
-break InitializeJVM
-run
-# Stop in InitializeJVM
-delete 1
-# We can now set breakpoints wherever we like
-EOF
-}
-
-
-case "$MODE" in
- gdb)
- init_gdb
- $GDB -x $GDBSCR
- rm -f $GDBSCR
- ;;
- gud)
- init_gdb
-# First find out what emacs version we're using, so that we can
-# use the new pretty GDB mode if emacs -version >= 22.1
- case `$EMACS -version 2> /dev/null` in
- *GNU\ Emacs\ 2[23]*)
- emacs_gud_cmd="gdba"
- emacs_gud_args="--annotate=3"
- ;;
- *)
- emacs_gud_cmd="gdb"
- emacs_gud_args=
- ;;
- esac
- $EMACS --eval "($emacs_gud_cmd \"$GDB $emacs_gud_args -x $GDBSCR\")";
- rm -f $GDBSCR
- ;;
- dbx)
- $DBX -s $HOME/.dbxrc $LAUNCHER $JPARMS
- ;;
- valgrind)
- echo Warning: Defaulting to 16Mb heap to make Valgrind run faster, use -Xmx for larger heap
- echo
- $VALGRIND --tool=memcheck --leak-check=yes --num-callers=50 $LAUNCHER -Xmx16m $JPARMS
- ;;
- run)
- LD_PRELOAD=$PRELOADING exec $LAUNCHER $JPARMS
- ;;
- *)
- echo Error: Internal error, unknown launch mode \"$MODE\"
- exit 1
- ;;
-esac
-RETVAL=$?
-exit $RETVAL
--- a/hotspot/src/os/windows/launcher/java_md.c Tue May 14 17:33:07 2013 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1507 +0,0 @@
-/*
- * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * 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 <ctype.h>
-#include <windows.h>
-#include <io.h>
-#include <process.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#include <jni.h>
-#include "java.h"
-#ifndef GAMMA
-#include "version_comp.h"
-#endif
-
-#define JVM_DLL "jvm.dll"
-#define JAVA_DLL "java.dll"
-#define CRT_DLL "msvcr71.dll"
-
-/*
- * Prototypes.
- */
-static jboolean GetPublicJREHome(char *path, jint pathsize);
-static jboolean GetJVMPath(const char *jrepath, const char *jvmtype,
- char *jvmpath, jint jvmpathsize);
-static jboolean GetJREPath(char *path, jint pathsize);
-static void EnsureJreInstallation(const char *jrepath);
-
-/* We supports warmup for UI stack that is performed in parallel
- * to VM initialization.
- * This helps to improve startup of UI application as warmup phase
- * might be long due to initialization of OS or hardware resources.
- * It is not CPU bound and therefore it does not interfere with VM init.
- * Obviously such warmup only has sense for UI apps and therefore it needs
- * to be explicitly requested by passing -Dsun.awt.warmup=true property
- * (this is always the case for plugin/javaws).
- *
- * Implementation launches new thread after VM starts and use it to perform
- * warmup code (platform dependent).
- * This thread is later reused as AWT toolkit thread as graphics toolkit
- * often assume that they are used from the same thread they were launched on.
- *
- * At the moment we only support warmup for D3D. It only possible on windows
- * and only if other flags do not prohibit this (e.g. OpenGL support requested).
- */
-#undef ENABLE_AWT_PRELOAD
-#ifndef JAVA_ARGS /* turn off AWT preloading for javac, jar, etc */
- #ifdef _X86_ /* for now disable AWT preloading for 64bit */
- #define ENABLE_AWT_PRELOAD
- #endif
-#endif
-
-#ifdef ENABLE_AWT_PRELOAD
-/* "AWT was preloaded" flag;
- * Turned on by AWTPreload().
- */
-int awtPreloaded = 0;
-
-/* Calls a function with the name specified.
- * The function must be int(*fn)(void).
- */
-int AWTPreload(const char *funcName);
-/* Stops AWT preloading. */
-void AWTPreloadStop();
-
-/* D3D preloading */
-/* -1: not initialized; 0: OFF, 1: ON */
-int awtPreloadD3D = -1;
-/* Command line parameter to swith D3D preloading on. */
-#define PARAM_PRELOAD_D3D "-Dsun.awt.warmup"
-/* D3D/OpenGL management parameters (may disable D3D preloading) */
-#define PARAM_NODDRAW "-Dsun.java2d.noddraw"
-#define PARAM_D3D "-Dsun.java2d.d3d"
-#define PARAM_OPENGL "-Dsun.java2d.opengl"
-/* funtion in awt.dll (src/windows/native/sun/java2d/d3d/D3DPipelineManager.cpp) */
-#define D3D_PRELOAD_FUNC "preloadD3D"
-
-
-/* Extracts value of a parameter with the specified name
- * from command line argument (returns pointer in the argument).
- * Returns NULL if the argument does not contains the parameter.
- * e.g.:
- * GetParamValue("theParam", "theParam=value") returns pointer to "value".
- */
-const char * GetParamValue(const char *paramName, const char *arg) {
- int nameLen = strlen(paramName);
- if (strncmp(paramName, arg, nameLen) == 0) {
- // arg[nameLen] is valid (may contain final NULL)
- if (arg[nameLen] == '=') {
- return arg + nameLen + 1;
- }
- }
- return NULL;
-}
-
-/* Checks if commandline argument contains property specified
- * and analyze it as boolean property (true/false).
- * Returns -1 if the argument does not contain the parameter;
- * Returns 1 if the argument contains the parameter and its value is "true";
- * Returns 0 if the argument contains the parameter and its value is "false".
- */
-int GetBoolParamValue(const char *paramName, const char *arg) {
- const char * paramValue = GetParamValue(paramName, arg);
- if (paramValue != NULL) {
- if (stricmp(paramValue, "true") == 0) {
- return 1;
- }
- if (stricmp(paramValue, "false") == 0) {
- return 0;
- }
- }
- return -1;
-}
-#endif /* ENABLE_AWT_PRELOAD */
-
-
-const char *
-GetArch()
-{
-
-#ifdef _M_AMD64
- return "amd64";
-#elif defined(_M_IA64)
- return "ia64";
-#else
- return "i386";
-#endif
-}
-
-/*
- *
- */
-void
-CreateExecutionEnvironment(int *_argc,
- char ***_argv,
- char jrepath[],
- jint so_jrepath,
- char jvmpath[],
- jint so_jvmpath,
- char **original_argv) {
-#ifndef GAMMA
- char * jvmtype;
-
- /* Find out where the JRE is that we will be using. */
- if (!GetJREPath(jrepath, so_jrepath)) {
- ReportErrorMessage("Error: could not find Java SE Runtime Environment.",
- JNI_TRUE);
- exit(2);
- }
-
- /* Do this before we read jvm.cfg */
- EnsureJreInstallation(jrepath);
-
- /* Find the specified JVM type */
- if (ReadKnownVMs(jrepath, (char*)GetArch(), JNI_FALSE) < 1) {
- ReportErrorMessage("Error: no known VMs. (check for corrupt jvm.cfg file)",
- JNI_TRUE);
- exit(1);
- }
- jvmtype = CheckJvmType(_argc, _argv, JNI_FALSE);
-
- jvmpath[0] = '\0';
- if (!GetJVMPath(jrepath, jvmtype, jvmpath, so_jvmpath)) {
- char * message=NULL;
- const char * format = "Error: no `%s' JVM at `%s'.";
- message = (char *)JLI_MemAlloc((strlen(format)+strlen(jvmtype)+
- strlen(jvmpath)) * sizeof(char));
- sprintf(message,format, jvmtype, jvmpath);
- ReportErrorMessage(message, JNI_TRUE);
- exit(4);
- }
- /* If we got here, jvmpath has been correctly initialized. */
-
-#else /* ifndef GAMMA */
-
- /*
- * gamma launcher is simpler in that it doesn't handle VM flavors, data
- * model, etc. Assuming everything is set-up correctly
- * all we need to do here is to return correct path names. See also
- * GetJVMPath() and GetApplicationHome().
- */
-
- {
- if (!GetJREPath(jrepath, so_jrepath) ) {
- ReportErrorMessage("Error: could not find Java SE Runtime Environment.",
- JNI_TRUE);
- exit(2);
- }
-
- if (!GetJVMPath(jrepath, NULL, jvmpath, so_jvmpath)) {
- char * message=NULL;
- const char * format = "Error: no JVM at `%s'.";
- message = (char *)JLI_MemAlloc((strlen(format)+
- strlen(jvmpath)) * sizeof(char));
- sprintf(message, format, jvmpath);
- ReportErrorMessage(message, JNI_TRUE);
- exit(4);
- }
- }
-
-#endif /* ifndef GAMMA */
-
-}
-
-
-static jboolean
-LoadMSVCRT()
-{
- // Only do this once
- static int loaded = 0;
- char crtpath[MAXPATHLEN];
-
- if (!loaded) {
- /*
- * The Microsoft C Runtime Library needs to be loaded first. A copy is
- * assumed to be present in the "JRE path" directory. If it is not found
- * there (or "JRE path" fails to resolve), skip the explicit load and let
- * nature take its course, which is likely to be a failure to execute.
- */
- if (GetJREPath(crtpath, MAXPATHLEN)) {
- (void)strcat(crtpath, "\\bin\\" CRT_DLL); /* Add crt dll */
- if (_launcher_debug) {
- printf("CRT path is %s\n", crtpath);
- }
- if (_access(crtpath, 0) == 0) {
- if (LoadLibrary(crtpath) == 0) {
- ReportErrorMessage2("Error loading: %s", crtpath, JNI_TRUE);
- return JNI_FALSE;
- }
- }
- }
- loaded = 1;
- }
- return JNI_TRUE;
-}
-
-/*
- * The preJVMStart is a function in the jkernel.dll, which
- * performs the final step of synthesizing back the decomposed
- * modules (partial install) to the full JRE. Any tool which
- * uses the JRE must peform this step to ensure the complete synthesis.
- * The EnsureJreInstallation function calls preJVMStart based on
- * the conditions outlined below, noting that the operation
- * will fail silently if any of conditions are not met.
- * NOTE: this call must be made before jvm.dll is loaded, or jvm.cfg
- * is read, since jvm.cfg will be modified by the preJVMStart.
- * 1. Are we on a supported platform.
- * 2. Find the location of the JRE or the Kernel JRE.
- * 3. check existence of JREHOME/lib/bundles
- * 4. check jkernel.dll and invoke the entry-point
- */
-typedef VOID (WINAPI *PREJVMSTART)();
-
-static void
-EnsureJreInstallation(const char* jrepath)
-{
- HINSTANCE handle;
- char tmpbuf[MAXPATHLEN];
- PREJVMSTART PreJVMStart;
- struct stat s;
-
- /* 32 bit windows only please */
- if (strcmp(GetArch(), "i386") != 0 ) {
- if (_launcher_debug) {
- printf("EnsureJreInstallation:unsupported platform\n");
- }
- return;
- }
- /* Does our bundle directory exist ? */
- strcpy(tmpbuf, jrepath);
- strcat(tmpbuf, "\\lib\\bundles");
- if (stat(tmpbuf, &s) != 0) {
- if (_launcher_debug) {
- printf("EnsureJreInstallation:<%s>:not found\n", tmpbuf);
- }
- return;
- }
- /* Does our jkernel dll exist ? */
- strcpy(tmpbuf, jrepath);
- strcat(tmpbuf, "\\bin\\jkernel.dll");
- if (stat(tmpbuf, &s) != 0) {
- if (_launcher_debug) {
- printf("EnsureJreInstallation:<%s>:not found\n", tmpbuf);
- }
- return;
- }
- /* The Microsoft C Runtime Library needs to be loaded first. */
- if (!LoadMSVCRT()) {
- if (_launcher_debug) {
- printf("EnsureJreInstallation:could not load C runtime DLL\n");
- }
- return;
- }
- /* Load the jkernel.dll */
- if ((handle = LoadLibrary(tmpbuf)) == 0) {
- if (_launcher_debug) {
- printf("EnsureJreInstallation:%s:load failed\n", tmpbuf);
- }
- return;
- }
- /* Get the function address */
- PreJVMStart = (PREJVMSTART)GetProcAddress(handle, "preJVMStart");
- if (PreJVMStart == NULL) {
- if (_launcher_debug) {
- printf("EnsureJreInstallation:preJVMStart:function lookup failed\n");
- }
- FreeLibrary(handle);
- return;
- }
- PreJVMStart();
- if (_launcher_debug) {
- printf("EnsureJreInstallation:preJVMStart:called\n");
- }
- FreeLibrary(handle);
- return;
-}
-
-/*
- * Find path to JRE based on .exe's location or registry settings.
- */
-jboolean
-GetJREPath(char *path, jint pathsize)
-{
- char javadll[MAXPATHLEN];
- struct stat s;
-
- if (GetApplicationHome(path, pathsize)) {
- /* Is JRE co-located with the application? */
- sprintf(javadll, "%s\\bin\\" JAVA_DLL, path);
- if (stat(javadll, &s) == 0) {
- goto found;
- }
-
- /* Does this app ship a private JRE in <apphome>\jre directory? */
- sprintf(javadll, "%s\\jre\\bin\\" JAVA_DLL, path);
- if (stat(javadll, &s) == 0) {
- strcat(path, "\\jre");
- goto found;
- }
- }
-
-#ifndef GAMMA
- /* Look for a public JRE on this machine. */
- if (GetPublicJREHome(path, pathsize)) {
- goto found;
- }
-#endif
-
- fprintf(stderr, "Error: could not find " JAVA_DLL "\n");
- return JNI_FALSE;
-
- found:
- if (_launcher_debug)
- printf("JRE path is %s\n", path);
- return JNI_TRUE;
-}
-
-/*
- * Given a JRE location and a JVM type, construct what the name the
- * JVM shared library will be. Return true, if such a library
- * exists, false otherwise.
- */
-static jboolean
-GetJVMPath(const char *jrepath, const char *jvmtype,
- char *jvmpath, jint jvmpathsize)
-{
- struct stat s;
-
-#ifndef GAMMA
- if (strchr(jvmtype, '/') || strchr(jvmtype, '\\')) {
- sprintf(jvmpath, "%s\\" JVM_DLL, jvmtype);
- } else {
- sprintf(jvmpath, "%s\\bin\\%s\\" JVM_DLL, jrepath, jvmtype);
- }
-#else
- /*
- * For gamma launcher, JVM is either built-in or in the same directory.
- * Either way we return "<exe_path>/jvm.dll" where <exe_path> is the
- * directory where gamma launcher is located.
- */
-
- char *p;
- GetModuleFileName(0, jvmpath, jvmpathsize);
-
- p = strrchr(jvmpath, '\\');
- if (p) {
- /* replace executable name with libjvm.so */
- snprintf(p + 1, jvmpathsize - (p + 1 - jvmpath), "%s", JVM_DLL);
- } else {
- /* this case shouldn't happen */
- snprintf(jvmpath, jvmpathsize, "%s", JVM_DLL);
- }
-#endif /* ifndef GAMMA */
-
- if (stat(jvmpath, &s) == 0) {
- return JNI_TRUE;
- } else {
- return JNI_FALSE;
- }
-}
-
-/*
- * Load a jvm from "jvmpath" and initialize the invocation functions.
- */
-jboolean
-LoadJavaVM(const char *jvmpath, InvocationFunctions *ifn)
-{
-#ifdef GAMMA
- /* JVM is directly linked with gamma launcher; no Loadlibrary() */
- ifn->CreateJavaVM = JNI_CreateJavaVM;
- ifn->GetDefaultJavaVMInitArgs = JNI_GetDefaultJavaVMInitArgs;
- return JNI_TRUE;
-#else
- HINSTANCE handle;
-
- if (_launcher_debug) {
- printf("JVM path is %s\n", jvmpath);
- }
-
- /* The Microsoft C Runtime Library needs to be loaded first. */
- LoadMSVCRT();
-
- /* Load the Java VM DLL */
- if ((handle = LoadLibrary(jvmpath)) == 0) {
- ReportErrorMessage2("Error loading: %s", (char *)jvmpath, JNI_TRUE);
- return JNI_FALSE;
- }
-
- /* Now get the function addresses */
- ifn->CreateJavaVM =
- (void *)GetProcAddress(handle, "JNI_CreateJavaVM");
- ifn->GetDefaultJavaVMInitArgs =
- (void *)GetProcAddress(handle, "JNI_GetDefaultJavaVMInitArgs");
- if (ifn->CreateJavaVM == 0 || ifn->GetDefaultJavaVMInitArgs == 0) {
- ReportErrorMessage2("Error: can't find JNI interfaces in: %s",
- (char *)jvmpath, JNI_TRUE);
- return JNI_FALSE;
- }
-
- return JNI_TRUE;
-#endif /* ifndef GAMMA */
-}
-
-/*
- * If app is "c:\foo\bin\javac", then put "c:\foo" into buf.
- */
-jboolean
-GetApplicationHome(char *buf, jint bufsize)
-{
-#ifndef GAMMA
- char *cp;
- GetModuleFileName(0, buf, bufsize);
- *strrchr(buf, '\\') = '\0'; /* remove .exe file name */
- if ((cp = strrchr(buf, '\\')) == 0) {
- /* This happens if the application is in a drive root, and
- * there is no bin directory. */
- buf[0] = '\0';
- return JNI_FALSE;
- }
- *cp = '\0'; /* remove the bin\ part */
- return JNI_TRUE;
-
-#else /* ifndef GAMMA */
-
- char env[MAXPATHLEN + 1];
-
- /* gamma launcher uses ALT_JAVA_HOME environment variable or jdkpath.txt file to find JDK/JRE */
-
- if (getenv("ALT_JAVA_HOME") != NULL) {
- snprintf(buf, bufsize, "%s", getenv("ALT_JAVA_HOME"));
- }
- else {
- char path[MAXPATHLEN + 1];
- char* p;
- int len;
- FILE* fp;
-
- // find the path to the currect executable
- len = GetModuleFileName(NULL, path, MAXPATHLEN + 1);
- if (len == 0 || len > MAXPATHLEN) {
- printf("Could not get directory of current executable.");
- return JNI_FALSE;
- }
- // remove last path component ("hotspot.exe")
- p = strrchr(path, '\\');
- if (p == NULL) {
- printf("Could not parse directory of current executable.\n");
- return JNI_FALSE;
- }
- *p = '\0';
-
- // open jdkpath.txt and read JAVA_HOME from it
- if (strlen(path) + strlen("\\jdkpath.txt") + 1 >= MAXPATHLEN) {
- printf("Path too long: %s\n", path);
- return JNI_FALSE;
- }
- strcat(path, "\\jdkpath.txt");
- fp = fopen(path, "r");
- if (fp == NULL) {
- printf("Could not open file %s to get path to JDK.\n", path);
- return JNI_FALSE;
- }
-
- if (fgets(buf, bufsize, fp) == NULL) {
- printf("Could not read from file %s to get path to JDK.\n", path);
- fclose(fp);
- return JNI_FALSE;
- }
- // trim the buffer
- p = buf + strlen(buf) - 1;
- while(isspace(*p)) {
- *p = '\0';
- p--;
- }
- fclose(fp);
- }
-
- _snprintf(env, MAXPATHLEN, "JAVA_HOME=%s", buf);
- _putenv(env);
-
- return JNI_TRUE;
-#endif /* ifndef GAMMA */
-}
-
-#ifdef JAVAW
-__declspec(dllimport) char **__initenv;
-
-int WINAPI
-WinMain(HINSTANCE inst, HINSTANCE previnst, LPSTR cmdline, int cmdshow)
-{
- int ret;
-
- __initenv = _environ;
- ret = main(__argc, __argv);
-
- return ret;
-}
-#endif
-
-#ifndef GAMMA
-
-/*
- * Helpers to look in the registry for a public JRE.
- */
- /* Same for 1.5.0, 1.5.1, 1.5.2 etc. */
-#define DOTRELEASE JDK_MAJOR_VERSION "." JDK_MINOR_VERSION
-#define JRE_KEY "Software\\JavaSoft\\Java Runtime Environment"
-
-static jboolean
-GetStringFromRegistry(HKEY key, const char *name, char *buf, jint bufsize)
-{
- DWORD type, size;
-
- if (RegQueryValueEx(key, name, 0, &type, 0, &size) == 0
- && type == REG_SZ
- && (size < (unsigned int)bufsize)) {
- if (RegQueryValueEx(key, name, 0, 0, buf, &size) == 0) {
- return JNI_TRUE;
- }
- }
- return JNI_FALSE;
-}
-
-static jboolean
-GetPublicJREHome(char *buf, jint bufsize)
-{
- HKEY key, subkey;
- char version[MAXPATHLEN];
-
- /*
- * Note: There is a very similar implementation of the following
- * registry reading code in the Windows java control panel (javacp.cpl).
- * If there are bugs here, a similar bug probably exists there. Hence,
- * changes here require inspection there.
- */
-
- /* Find the current version of the JRE */
- if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, JRE_KEY, 0, KEY_READ, &key) != 0) {
- fprintf(stderr, "Error opening registry key '" JRE_KEY "'\n");
- return JNI_FALSE;
- }
-
- if (!GetStringFromRegistry(key, "CurrentVersion",
- version, sizeof(version))) {
- fprintf(stderr, "Failed reading value of registry key:\n\t"
- JRE_KEY "\\CurrentVersion\n");
- RegCloseKey(key);
- return JNI_FALSE;
- }
-
- if (strcmp(version, DOTRELEASE) != 0) {
- fprintf(stderr, "Registry key '" JRE_KEY "\\CurrentVersion'\nhas "
- "value '%s', but '" DOTRELEASE "' is required.\n", version);
- RegCloseKey(key);
- return JNI_FALSE;
- }
-
- /* Find directory where the current version is installed. */
- if (RegOpenKeyEx(key, version, 0, KEY_READ, &subkey) != 0) {
- fprintf(stderr, "Error opening registry key '"
- JRE_KEY "\\%s'\n", version);
- RegCloseKey(key);
- return JNI_FALSE;
- }
-
- if (!GetStringFromRegistry(subkey, "JavaHome", buf, bufsize)) {
- fprintf(stderr, "Failed reading value of registry key:\n\t"
- JRE_KEY "\\%s\\JavaHome\n", version);
- RegCloseKey(key);
- RegCloseKey(subkey);
- return JNI_FALSE;
- }
-
- if (_launcher_debug) {
- char micro[MAXPATHLEN];
- if (!GetStringFromRegistry(subkey, "MicroVersion", micro,
- sizeof(micro))) {
- printf("Warning: Can't read MicroVersion\n");
- micro[0] = '\0';
- }
- printf("Version major.minor.micro = %s.%s\n", version, micro);
- }
-
- RegCloseKey(key);
- RegCloseKey(subkey);
- return JNI_TRUE;
-}
-
-#endif /* ifndef GAMMA */
-
-/*
- * Support for doing cheap, accurate interval timing.
- */
-static jboolean counterAvailable = JNI_FALSE;
-static jboolean counterInitialized = JNI_FALSE;
-static LARGE_INTEGER counterFrequency;
-
-jlong CounterGet()
-{
- LARGE_INTEGER count;
-
- if (!counterInitialized) {
- counterAvailable = QueryPerformanceFrequency(&counterFrequency);
- counterInitialized = JNI_TRUE;
- }
- if (!counterAvailable) {
- return 0;
- }
- QueryPerformanceCounter(&count);
- return (jlong)(count.QuadPart);
-}
-
-jlong Counter2Micros(jlong counts)
-{
- if (!counterAvailable || !counterInitialized) {
- return 0;
- }
- return (counts * 1000 * 1000)/counterFrequency.QuadPart;
-}
-
-void ReportErrorMessage(char * message, jboolean always) {
-#ifdef JAVAW
- if (message != NULL) {
- MessageBox(NULL, message, "Java Virtual Machine Launcher",
- (MB_OK|MB_ICONSTOP|MB_APPLMODAL));
- }
-#else
- if (always) {
- fprintf(stderr, "%s\n", message);
- }
-#endif
-}
-
-void ReportErrorMessage2(char * format, char * string, jboolean always) {
- /*
- * The format argument must be a printf format string with one %s
- * argument, which is passed the string argument.
- */
-#ifdef JAVAW
- size_t size;
- char * message;
- size = strlen(format) + strlen(string);
- message = (char*)JLI_MemAlloc(size*sizeof(char));
- sprintf(message, (const char *)format, string);
-
- if (message != NULL) {
- MessageBox(NULL, message, "Java Virtual Machine Launcher",
- (MB_OK|MB_ICONSTOP|MB_APPLMODAL));
- JLI_MemFree(message);
- }
-#else
- if (always) {
- fprintf(stderr, (const char *)format, string);
- fprintf(stderr, "\n");
- }
-#endif
-}
-
-/*
- * As ReportErrorMessage2 (above) except the system message (if any)
- * associated with this error is written to a second %s format specifier
- * in the format argument.
- */
-void ReportSysErrorMessage2(char * format, char * string, jboolean always) {
- int save_errno = errno;
- DWORD errval;
- int freeit = 0;
- char *errtext = NULL;
-
- if ((errval = GetLastError()) != 0) { /* Platform SDK / DOS Error */
- int n = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|
- FORMAT_MESSAGE_IGNORE_INSERTS|FORMAT_MESSAGE_ALLOCATE_BUFFER,
- NULL, errval, 0, (LPTSTR)&errtext, 0, NULL);
- if (errtext == NULL || n == 0) { /* Paranoia check */
- errtext = "";
- n = 0;
- } else {
- freeit = 1;
- if (n > 2) { /* Drop final CR, LF */
- if (errtext[n - 1] == '\n') n--;
- if (errtext[n - 1] == '\r') n--;
- errtext[n] = '\0';
- }
- }
- } else /* C runtime error that has no corresponding DOS error code */
- errtext = strerror(save_errno);
-
-#ifdef JAVAW
- {
- size_t size;
- char * message;
- size = strlen(format) + strlen(string) + strlen(errtext);
- message = (char*)JLI_MemAlloc(size*sizeof(char));
- sprintf(message, (const char *)format, string, errtext);
-
- if (message != NULL) {
- MessageBox(NULL, message, "Java Virtual Machine Launcher",
- (MB_OK|MB_ICONSTOP|MB_APPLMODAL));
- JLI_MemFree(message);
- }
- }
-#else
- if (always) {
- fprintf(stderr, (const char *)format, string, errtext);
- fprintf(stderr, "\n");
- }
-#endif
- if (freeit)
- (void)LocalFree((HLOCAL)errtext);
-}
-
-void ReportExceptionDescription(JNIEnv * env) {
-#ifdef JAVAW
- /*
- * This code should be replaced by code which opens a window with
- * the exception detail message.
- */
- (*env)->ExceptionDescribe(env);
-#else
- (*env)->ExceptionDescribe(env);
-#endif
-}
-
-
-/*
- * Return JNI_TRUE for an option string that has no effect but should
- * _not_ be passed on to the vm; return JNI_FALSE otherwise. On
- * windows, there are no options that should be screened in this
- * manner.
- */
-jboolean RemovableMachineDependentOption(char * option) {
-#ifdef ENABLE_AWT_PRELOAD
- if (awtPreloadD3D < 0) {
- /* Tests the command line parameter only if not set yet. */
- if (GetBoolParamValue(PARAM_PRELOAD_D3D, option) == 1) {
- awtPreloadD3D = 1;
- }
- }
- if (awtPreloadD3D != 0) {
- /* Don't test the command line parameters if already disabled. */
- if (GetBoolParamValue(PARAM_NODDRAW, option) == 1
- || GetBoolParamValue(PARAM_D3D, option) == 0
- || GetBoolParamValue(PARAM_OPENGL, option) == 1)
- {
- awtPreloadD3D = 0;
- }
- }
-#endif /* ENABLE_AWT_PRELOAD */
-
- return JNI_FALSE;
-}
-
-void PrintMachineDependentOptions() {
- return;
-}
-
-#ifndef GAMMA
-
-jboolean
-ServerClassMachine() {
- jboolean result = JNI_FALSE;
-#if defined(NEVER_ACT_AS_SERVER_CLASS_MACHINE)
- result = JNI_FALSE;
-#elif defined(ALWAYS_ACT_AS_SERVER_CLASS_MACHINE)
- result = JNI_TRUE;
-#endif
- return result;
-}
-
-/*
- * Determine if there is an acceptable JRE in the registry directory top_key.
- * Upon locating the "best" one, return a fully qualified path to it.
- * "Best" is defined as the most advanced JRE meeting the constraints
- * contained in the manifest_info. If no JRE in this directory meets the
- * constraints, return NULL.
- *
- * It doesn't matter if we get an error reading the registry, or we just
- * don't find anything interesting in the directory. We just return NULL
- * in either case.
- */
-static char *
-ProcessDir(manifest_info* info, HKEY top_key) {
- DWORD index = 0;
- HKEY ver_key;
- char name[MAXNAMELEN];
- int len;
- char *best = NULL;
-
- /*
- * Enumerate "<top_key>/SOFTWARE/JavaSoft/Java Runtime Environment"
- * searching for the best available version.
- */
- while (RegEnumKey(top_key, index, name, MAXNAMELEN) == ERROR_SUCCESS) {
- index++;
- if (JLI_AcceptableRelease(name, info->jre_version))
- if ((best == NULL) || (JLI_ExactVersionId(name, best) > 0)) {
- if (best != NULL)
- JLI_MemFree(best);
- best = JLI_StringDup(name);
- }
- }
-
- /*
- * Extract "JavaHome" from the "best" registry directory and return
- * that path. If no appropriate version was located, or there is an
- * error in extracting the "JavaHome" string, return null.
- */
- if (best == NULL)
- return (NULL);
- else {
- if (RegOpenKeyEx(top_key, best, 0, KEY_READ, &ver_key)
- != ERROR_SUCCESS) {
- JLI_MemFree(best);
- if (ver_key != NULL)
- RegCloseKey(ver_key);
- return (NULL);
- }
- JLI_MemFree(best);
- len = MAXNAMELEN;
- if (RegQueryValueEx(ver_key, "JavaHome", NULL, NULL, (LPBYTE)name, &len)
- != ERROR_SUCCESS) {
- if (ver_key != NULL)
- RegCloseKey(ver_key);
- return (NULL);
- }
- if (ver_key != NULL)
- RegCloseKey(ver_key);
- return (JLI_StringDup(name));
- }
-}
-
-/*
- * This is the global entry point. It examines the host for the optimal
- * JRE to be used by scanning a set of registry entries. This set of entries
- * is hardwired on Windows as "Software\JavaSoft\Java Runtime Environment"
- * under the set of roots "{ HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE }".
- *
- * This routine simply opens each of these registry directories before passing
- * control onto ProcessDir().
- */
-char *
-LocateJRE(manifest_info* info) {
- HKEY key = NULL;
- char *path;
- int key_index;
- HKEY root_keys[2] = { HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE };
-
- for (key_index = 0; key_index <= 1; key_index++) {
- if (RegOpenKeyEx(root_keys[key_index], JRE_KEY, 0, KEY_READ, &key)
- == ERROR_SUCCESS)
- if ((path = ProcessDir(info, key)) != NULL) {
- if (key != NULL)
- RegCloseKey(key);
- return (path);
- }
- if (key != NULL)
- RegCloseKey(key);
- }
- return NULL;
-}
-
-
-/*
- * Local helper routine to isolate a single token (option or argument)
- * from the command line.
- *
- * This routine accepts a pointer to a character pointer. The first
- * token (as defined by MSDN command-line argument syntax) is isolated
- * from that string.
- *
- * Upon return, the input character pointer pointed to by the parameter s
- * is updated to point to the remainding, unscanned, portion of the string,
- * or to a null character if the entire string has been consummed.
- *
- * This function returns a pointer to a null-terminated string which
- * contains the isolated first token, or to the null character if no
- * token could be isolated.
- *
- * Note the side effect of modifying the input string s by the insertion
- * of a null character, making it two strings.
- *
- * See "Parsing C Command-Line Arguments" in the MSDN Library for the
- * parsing rule details. The rule summary from that specification is:
- *
- * * Arguments are delimited by white space, which is either a space or a tab.
- *
- * * A string surrounded by double quotation marks is interpreted as a single
- * argument, regardless of white space contained within. A quoted string can
- * be embedded in an argument. Note that the caret (^) is not recognized as
- * an escape character or delimiter.
- *
- * * A double quotation mark preceded by a backslash, \", is interpreted as a
- * literal double quotation mark (").
- *
- * * Backslashes are interpreted literally, unless they immediately precede a
- * double quotation mark.
- *
- * * If an even number of backslashes is followed by a double quotation mark,
- * then one backslash (\) is placed in the argv array for every pair of
- * backslashes (\\), and the double quotation mark (") is interpreted as a
- * string delimiter.
- *
- * * If an odd number of backslashes is followed by a double quotation mark,
- * then one backslash (\) is placed in the argv array for every pair of
- * backslashes (\\) and the double quotation mark is interpreted as an
- * escape sequence by the remaining backslash, causing a literal double
- * quotation mark (") to be placed in argv.
- */
-static char*
-nextarg(char** s) {
- char *p = *s;
- char *head;
- int slashes = 0;
- int inquote = 0;
-
- /*
- * Strip leading whitespace, which MSDN defines as only space or tab.
- * (Hence, no locale specific "isspace" here.)
- */
- while (*p != (char)0 && (*p == ' ' || *p == '\t'))
- p++;
- head = p; /* Save the start of the token to return */
-
- /*
- * Isolate a token from the command line.
- */
- while (*p != (char)0 && (inquote || !(*p == ' ' || *p == '\t'))) {
- if (*p == '\\' && *(p+1) == '"' && slashes % 2 == 0)
- p++;
- else if (*p == '"')
- inquote = !inquote;
- slashes = (*p++ == '\\') ? slashes + 1 : 0;
- }
-
- /*
- * If the token isolated isn't already terminated in a "char zero",
- * then replace the whitespace character with one and move to the
- * next character.
- */
- if (*p != (char)0)
- *p++ = (char)0;
-
- /*
- * Update the parameter to point to the head of the remaining string
- * reflecting the command line and return a pointer to the leading
- * token which was isolated from the command line.
- */
- *s = p;
- return (head);
-}
-
-/*
- * Local helper routine to return a string equivalent to the input string
- * s, but with quotes removed so the result is a string as would be found
- * in argv[]. The returned string should be freed by a call to JLI_MemFree().
- *
- * The rules for quoting (and escaped quotes) are:
- *
- * 1 A double quotation mark preceded by a backslash, \", is interpreted as a
- * literal double quotation mark (").
- *
- * 2 Backslashes are interpreted literally, unless they immediately precede a
- * double quotation mark.
- *
- * 3 If an even number of backslashes is followed by a double quotation mark,
- * then one backslash (\) is placed in the argv array for every pair of
- * backslashes (\\), and the double quotation mark (") is interpreted as a
- * string delimiter.
- *
- * 4 If an odd number of backslashes is followed by a double quotation mark,
- * then one backslash (\) is placed in the argv array for every pair of
- * backslashes (\\) and the double quotation mark is interpreted as an
- * escape sequence by the remaining backslash, causing a literal double
- * quotation mark (") to be placed in argv.
- */
-static char*
-unquote(const char *s) {
- const char *p = s; /* Pointer to the tail of the original string */
- char *un = (char*)JLI_MemAlloc(strlen(s) + 1); /* Ptr to unquoted string */
- char *pun = un; /* Pointer to the tail of the unquoted string */
-
- while (*p != '\0') {
- if (*p == '"') {
- p++;
- } else if (*p == '\\') {
- const char *q = p + strspn(p,"\\");
- if (*q == '"')
- do {
- *pun++ = '\\';
- p += 2;
- } while (*p == '\\' && p < q);
- else
- while (p < q)
- *pun++ = *p++;
- } else {
- *pun++ = *p++;
- }
- }
- *pun = '\0';
- return un;
-}
-
-/*
- * Given a path to a jre to execute, this routine checks if this process
- * is indeed that jre. If not, it exec's that jre.
- *
- * We want to actually check the paths rather than just the version string
- * built into the executable, so that given version specification will yield
- * the exact same Java environment, regardless of the version of the arbitrary
- * launcher we start with.
- */
-void
-ExecJRE(char *jre, char **argv) {
- int len;
- char *progname;
- char path[MAXPATHLEN + 1];
-
- /*
- * Determine the executable we are building (or in the rare case, running).
- */
-#ifdef JAVA_ARGS /* javac, jar and friends. */
- progname = "java";
-#else /* java, oldjava, javaw and friends */
-#ifdef PROGNAME
- progname = PROGNAME;
-#else
- {
- char *s;
- progname = *argv;
- if ((s = strrchr(progname, FILE_SEPARATOR)) != 0) {
- progname = s + 1;
- }
- }
-#endif /* PROGNAME */
-#endif /* JAVA_ARGS */
-
- /*
- * Resolve the real path to the currently running launcher.
- */
- len = GetModuleFileName(NULL, path, MAXPATHLEN + 1);
- if (len == 0 || len > MAXPATHLEN) {
- ReportSysErrorMessage2(
- "Unable to resolve path to current %s executable: %s",
- progname, JNI_TRUE);
- exit(1);
- }
-
- if (_launcher_debug) {
- printf("ExecJRE: old: %s\n", path);
- printf("ExecJRE: new: %s\n", jre);
- }
-
- /*
- * If the path to the selected JRE directory is a match to the initial
- * portion of the path to the currently executing JRE, we have a winner!
- * If so, just return. (strnicmp() is the Windows equiv. of strncasecmp().)
- */
- if (strnicmp(jre, path, strlen(jre)) == 0)
- return; /* I am the droid you were looking for */
-
- /*
- * If this isn't the selected version, exec the selected version.
- */
- (void)strcat(strcat(strcpy(path, jre), "\\bin\\"), progname);
- (void)strcat(path, ".exe");
-
- /*
- * Although Windows has an execv() entrypoint, it doesn't actually
- * overlay a process: it can only create a new process and terminate
- * the old process. Therefore, any processes waiting on the initial
- * process wake up and they shouldn't. Hence, a chain of pseudo-zombie
- * processes must be retained to maintain the proper wait semantics.
- * Fortunately the image size of the launcher isn't too large at this
- * time.
- *
- * If it weren't for this semantic flaw, the code below would be ...
- *
- * execv(path, argv);
- * ReportErrorMessage2("Exec of %s failed\n", path, JNI_TRUE);
- * exit(1);
- *
- * The incorrect exec semantics could be addressed by:
- *
- * exit((int)spawnv(_P_WAIT, path, argv));
- *
- * Unfortunately, a bug in Windows spawn/exec impementation prevents
- * this from completely working. All the Windows POSIX process creation
- * interfaces are implemented as wrappers around the native Windows
- * function CreateProcess(). CreateProcess() takes a single string
- * to specify command line options and arguments, so the POSIX routine
- * wrappers build a single string from the argv[] array and in the
- * process, any quoting information is lost.
- *
- * The solution to this to get the original command line, to process it
- * to remove the new multiple JRE options (if any) as was done for argv
- * in the common SelectVersion() routine and finally to pass it directly
- * to the native CreateProcess() Windows process control interface.
- */
- {
- char *cmdline;
- char *p;
- char *np;
- char *ocl;
- char *ccl;
- char *unquoted;
- DWORD exitCode;
- STARTUPINFO si;
- PROCESS_INFORMATION pi;
-
- /*
- * The following code block gets and processes the original command
- * line, replacing the argv[0] equivalent in the command line with
- * the path to the new executable and removing the appropriate
- * Multiple JRE support options. Note that similar logic exists
- * in the platform independent SelectVersion routine, but is
- * replicated here due to the syntax of CreateProcess().
- *
- * The magic "+ 4" characters added to the command line length are
- * 2 possible quotes around the path (argv[0]), a space after the
- * path and a terminating null character.
- */
- ocl = GetCommandLine();
- np = ccl = JLI_StringDup(ocl);
- p = nextarg(&np); /* Discard argv[0] */
- cmdline = (char *)JLI_MemAlloc(strlen(path) + strlen(np) + 4);
- if (strchr(path, (int)' ') == NULL && strchr(path, (int)'\t') == NULL)
- cmdline = strcpy(cmdline, path);
- else
- cmdline = strcat(strcat(strcpy(cmdline, "\""), path), "\"");
-
- while (*np != (char)0) { /* While more command-line */
- p = nextarg(&np);
- if (*p != (char)0) { /* If a token was isolated */
- unquoted = unquote(p);
- if (*unquoted == '-') { /* Looks like an option */
- if (strcmp(unquoted, "-classpath") == 0 ||
- strcmp(unquoted, "-cp") == 0) { /* Unique cp syntax */
- cmdline = strcat(strcat(cmdline, " "), p);
- p = nextarg(&np);
- if (*p != (char)0) /* If a token was isolated */
- cmdline = strcat(strcat(cmdline, " "), p);
- } else if (strncmp(unquoted, "-version:", 9) != 0 &&
- strcmp(unquoted, "-jre-restrict-search") != 0 &&
- strcmp(unquoted, "-no-jre-restrict-search") != 0) {
- cmdline = strcat(strcat(cmdline, " "), p);
- }
- } else { /* End of options */
- cmdline = strcat(strcat(cmdline, " "), p);
- cmdline = strcat(strcat(cmdline, " "), np);
- JLI_MemFree((void *)unquoted);
- break;
- }
- JLI_MemFree((void *)unquoted);
- }
- }
- JLI_MemFree((void *)ccl);
-
- if (_launcher_debug) {
- np = ccl = JLI_StringDup(cmdline);
- p = nextarg(&np);
- printf("ReExec Command: %s (%s)\n", path, p);
- printf("ReExec Args: %s\n", np);
- JLI_MemFree((void *)ccl);
- }
- (void)fflush(stdout);
- (void)fflush(stderr);
-
- /*
- * The following code is modeled after a model presented in the
- * Microsoft Technical Article "Moving Unix Applications to
- * Windows NT" (March 6, 1994) and "Creating Processes" on MSDN
- * (Februrary 2005). It approximates UNIX spawn semantics with
- * the parent waiting for termination of the child.
- */
- memset(&si, 0, sizeof(si));
- si.cb =sizeof(STARTUPINFO);
- memset(&pi, 0, sizeof(pi));
-
- if (!CreateProcess((LPCTSTR)path, /* executable name */
- (LPTSTR)cmdline, /* command line */
- (LPSECURITY_ATTRIBUTES)NULL, /* process security attr. */
- (LPSECURITY_ATTRIBUTES)NULL, /* thread security attr. */
- (BOOL)TRUE, /* inherits system handles */
- (DWORD)0, /* creation flags */
- (LPVOID)NULL, /* environment block */
- (LPCTSTR)NULL, /* current directory */
- (LPSTARTUPINFO)&si, /* (in) startup information */
- (LPPROCESS_INFORMATION)&pi)) { /* (out) process information */
- ReportSysErrorMessage2("CreateProcess(%s, ...) failed: %s",
- path, JNI_TRUE);
- exit(1);
- }
-
- if (WaitForSingleObject(pi.hProcess, INFINITE) != WAIT_FAILED) {
- if (GetExitCodeProcess(pi.hProcess, &exitCode) == FALSE)
- exitCode = 1;
- } else {
- ReportErrorMessage("WaitForSingleObject() failed.", JNI_TRUE);
- exitCode = 1;
- }
-
- CloseHandle(pi.hThread);
- CloseHandle(pi.hProcess);
-
- exit(exitCode);
- }
-
-}
-
-#endif /* ifndef GAMMA */
-
-
-/*
- * Wrapper for platform dependent unsetenv function.
- */
-int
-UnsetEnv(char *name)
-{
- int ret;
- char *buf = JLI_MemAlloc(strlen(name) + 2);
- buf = strcat(strcpy(buf, name), "=");
- ret = _putenv(buf);
- JLI_MemFree(buf);
- return (ret);
-}
-
-/* --- Splash Screen shared library support --- */
-
-static const char* SPLASHSCREEN_SO = "\\bin\\splashscreen.dll";
-
-static HMODULE hSplashLib = NULL;
-
-void* SplashProcAddress(const char* name) {
- char libraryPath[MAXPATHLEN]; /* some extra space for strcat'ing SPLASHSCREEN_SO */
-
- if (!GetJREPath(libraryPath, MAXPATHLEN)) {
- return NULL;
- }
- if (strlen(libraryPath)+strlen(SPLASHSCREEN_SO) >= MAXPATHLEN) {
- return NULL;
- }
- strcat(libraryPath, SPLASHSCREEN_SO);
-
- if (!hSplashLib) {
- hSplashLib = LoadLibrary(libraryPath);
- }
- if (hSplashLib) {
- return GetProcAddress(hSplashLib, name);
- } else {
- return NULL;
- }
-}
-
-void SplashFreeLibrary() {
- if (hSplashLib) {
- FreeLibrary(hSplashLib);
- hSplashLib = NULL;
- }
-}
-
-/*
- * Block current thread and continue execution in a new thread
- */
-int
-ContinueInNewThread(int (JNICALL *continuation)(void *), jlong stack_size, void * args) {
- int rslt = 0;
- unsigned thread_id;
-
-#ifndef STACK_SIZE_PARAM_IS_A_RESERVATION
-#define STACK_SIZE_PARAM_IS_A_RESERVATION (0x10000)
-#endif
-
- /*
- * STACK_SIZE_PARAM_IS_A_RESERVATION is what we want, but it's not
- * supported on older version of Windows. Try first with the flag; and
- * if that fails try again without the flag. See MSDN document or HotSpot
- * source (os_win32.cpp) for details.
- */
- HANDLE thread_handle =
- (HANDLE)_beginthreadex(NULL,
- (unsigned)stack_size,
- continuation,
- args,
- STACK_SIZE_PARAM_IS_A_RESERVATION,
- &thread_id);
- if (thread_handle == NULL) {
- thread_handle =
- (HANDLE)_beginthreadex(NULL,
- (unsigned)stack_size,
- continuation,
- args,
- 0,
- &thread_id);
- }
-
- /* AWT preloading (AFTER main thread start) */
-#ifdef ENABLE_AWT_PRELOAD
- /* D3D preloading */
- if (awtPreloadD3D != 0) {
- char *envValue;
- /* D3D routines checks env.var J2D_D3D if no appropriate
- * command line params was specified
- */
- envValue = getenv("J2D_D3D");
- if (envValue != NULL && stricmp(envValue, "false") == 0) {
- awtPreloadD3D = 0;
- }
- /* Test that AWT preloading isn't disabled by J2D_D3D_PRELOAD env.var */
- envValue = getenv("J2D_D3D_PRELOAD");
- if (envValue != NULL && stricmp(envValue, "false") == 0) {
- awtPreloadD3D = 0;
- }
- if (awtPreloadD3D < 0) {
- /* If awtPreloadD3D is still undefined (-1), test
- * if it is turned on by J2D_D3D_PRELOAD env.var.
- * By default it's turned OFF.
- */
- awtPreloadD3D = 0;
- if (envValue != NULL && stricmp(envValue, "true") == 0) {
- awtPreloadD3D = 1;
- }
- }
- }
- if (awtPreloadD3D) {
- AWTPreload(D3D_PRELOAD_FUNC);
- }
-#endif /* ENABLE_AWT_PRELOAD */
-
- if (thread_handle) {
- WaitForSingleObject(thread_handle, INFINITE);
- GetExitCodeThread(thread_handle, &rslt);
- CloseHandle(thread_handle);
- } else {
- rslt = continuation(args);
- }
-
-#ifdef ENABLE_AWT_PRELOAD
- if (awtPreloaded) {
- AWTPreloadStop();
- }
-#endif /* ENABLE_AWT_PRELOAD */
-
- return rslt;
-}
-
-/* Linux only, empty on windows. */
-void SetJavaLauncherPlatformProps() {}
-
-
-//==============================
-// AWT preloading
-#ifdef ENABLE_AWT_PRELOAD
-
-typedef int FnPreloadStart(void);
-typedef void FnPreloadStop(void);
-static FnPreloadStop *fnPreloadStop = NULL;
-static HMODULE hPreloadAwt = NULL;
-
-/*
- * Starts AWT preloading
- */
-int AWTPreload(const char *funcName)
-{
- int result = -1;
-
- // load AWT library once (if several preload function should be called)
- if (hPreloadAwt == NULL) {
- // awt.dll is not loaded yet
- char libraryPath[MAXPATHLEN];
- int jrePathLen = 0;
- HMODULE hJava = NULL;
- HMODULE hVerify = NULL;
-
- while (1) {
- // awt.dll depends on jvm.dll & java.dll;
- // jvm.dll is already loaded, so we need only java.dll;
- // java.dll depends on MSVCRT lib & verify.dll.
- if (!GetJREPath(libraryPath, MAXPATHLEN)) {
- break;
- }
-
- // save path length
- jrePathLen = strlen(libraryPath);
-
- // load msvcrt 1st
- LoadMSVCRT();
-
- // load verify.dll
- strcat(libraryPath, "\\bin\\verify.dll");
- hVerify = LoadLibrary(libraryPath);
- if (hVerify == NULL) {
- break;
- }
-
- // restore jrePath
- libraryPath[jrePathLen] = 0;
- // load java.dll
- strcat(libraryPath, "\\bin\\" JAVA_DLL);
- hJava = LoadLibrary(libraryPath);
- if (hJava == NULL) {
- break;
- }
-
- // restore jrePath
- libraryPath[jrePathLen] = 0;
- // load awt.dll
- strcat(libraryPath, "\\bin\\awt.dll");
- hPreloadAwt = LoadLibrary(libraryPath);
- if (hPreloadAwt == NULL) {
- break;
- }
-
- // get "preloadStop" func ptr
- fnPreloadStop = (FnPreloadStop *)GetProcAddress(hPreloadAwt, "preloadStop");
-
- break;
- }
- }
-
- if (hPreloadAwt != NULL) {
- FnPreloadStart *fnInit = (FnPreloadStart *)GetProcAddress(hPreloadAwt, funcName);
- if (fnInit != NULL) {
- // don't forget to stop preloading
- awtPreloaded = 1;
-
- result = fnInit();
- }
- }
-
- return result;
-}
-
-/*
- * Terminates AWT preloading
- */
-void AWTPreloadStop() {
- if (fnPreloadStop != NULL) {
- fnPreloadStop();
- }
-}
-
-#endif /* ENABLE_AWT_PRELOAD */
--- a/hotspot/src/os/windows/launcher/java_md.h Tue May 14 17:33:07 2013 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,83 +0,0 @@
-/*
- * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * 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 JAVA_MD_H
-#define JAVA_MD_H
-
-#include <jni.h>
-#include <windows.h>
-#include <io.h>
-#ifndef GAMMA
-#include "manifest_info.h"
-#endif
-#include "jli_util.h"
-
-#ifdef GAMMA
-#define stricmp _stricmp
-#define strnicmp _strnicmp
-#define snprintf _snprintf
-#define strdup _strdup
-#endif
-
-#define PATH_SEPARATOR ';'
-#define FILESEP "\\"
-#define FILE_SEPARATOR '\\'
-#define IS_FILE_SEPARATOR(c) ((c) == '\\' || (c) == '/')
-#define MAXPATHLEN MAX_PATH
-#define MAXNAMELEN MAX_PATH
-
-#ifdef JAVA_ARGS
-/*
- * ApplicationHome is prepended to each of these entries; the resulting
- * strings are concatenated (separated by PATH_SEPARATOR) and used as the
- * value of -cp option to the launcher.
- */
-#ifndef APP_CLASSPATH
-#define APP_CLASSPATH { "\\lib\\tools.jar", "\\classes" }
-#endif
-#endif
-
-/*
- * Support for doing cheap, accurate interval timing.
- */
-extern jlong CounterGet(void);
-extern jlong Counter2Micros(jlong counts);
-
-#ifdef JAVAW
-#define main _main
-extern int _main(int argc, char **argv);
-#endif
-
-#define JLONG_FORMAT "%I64d"
-
-/*
- * Function prototypes.
- */
-#ifndef GAMMA
-char *LocateJRE(manifest_info *info);
-void ExecJRE(char *jre, char **argv);
-#endif
-int UnsetEnv(char *name);
-
-#endif
--- a/hotspot/src/share/tools/ProjectCreator/BuildConfig.java Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/tools/ProjectCreator/BuildConfig.java Thu May 16 13:47:55 2013 -0700
@@ -65,6 +65,7 @@
String sourceBase = getFieldString(null, "SourceBase");
String buildSpace = getFieldString(null, "BuildSpace");
String outDir = buildBase;
+ String jdkTargetRoot = getFieldString(null, "JdkTargetRoot");
put("Id", flavourBuild);
put("OutputDir", outDir);
@@ -72,6 +73,7 @@
put("BuildBase", buildBase);
put("BuildSpace", buildSpace);
put("OutputDll", outDir + Util.sep + outDll);
+ put("JdkTargetRoot", jdkTargetRoot);
context = new String [] {flavourBuild, flavour, build, null};
}
--- a/hotspot/src/share/tools/ProjectCreator/WinGammaPlatformVC10.java Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/tools/ProjectCreator/WinGammaPlatformVC10.java Thu May 16 13:47:55 2013 -0700
@@ -98,11 +98,6 @@
tagV(cfg.getV("LinkerFlags"));
endTag();
- startTag("PostBuildEvent");
- tagData("Message", BuildConfig.getFieldString(null, "PostbuildDescription"));
- tagData("Command", cfg.expandFormat(BuildConfig.getFieldString(null, "PostbuildCommand").replace("\t", "\r\n")));
- endTag();
-
startTag("PreLinkEvent");
tagData("Message", BuildConfig.getFieldString(null, "PrelinkDescription"));
tagData("Command", cfg.expandFormat(BuildConfig.getFieldString(null, "PrelinkCommand").replace("\t", "\r\n")));
@@ -141,7 +136,9 @@
for (BuildConfig cfg : allConfigs) {
startTag(cfg, "PropertyGroup");
- tagData("LocalDebuggerCommand", "$(TargetDir)/hotspot.exe");
+ tagData("LocalDebuggerCommand", cfg.get("JdkTargetRoot") + "\\bin\\java.exe");
+ tagData("LocalDebuggerCommandArguments", "-XXaltjvm=$(TargetDir) -Dsun.java.launcher=gamma");
+ tagData("LocalDebuggerEnvironment", "JAVA_HOME=" + cfg.get("JdkTargetRoot"));
endTag();
}
--- a/hotspot/src/share/tools/launcher/java.c Tue May 14 17:33:07 2013 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,2080 +0,0 @@
-/*
- * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * 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.
- *
- */
-
-/*
- * Gamma (Hotspot internal engineering test) launcher based on 6.0u22 JDK,
- * search "GAMMA" for gamma specific changes.
- *
- * GAMMA: gamma launcher is much simpler than regular java launcher in that
- * JVM is either statically linked in or it is installed in the
- * same directory where the launcher exists, so we don't have to
- * worry about choosing the right JVM based on command line flag, jar
- * file and/or ergonomics. Intead of removing unused logic from source
- * they are commented out with #ifndef GAMMA, hopefully it'll be easier
- * to maintain this file in sync with regular JDK launcher.
- */
-
-/*
- * Shared source for 'java' command line tool.
- *
- * If JAVA_ARGS is defined, then acts as a launcher for applications. For
- * instance, the JDK command line tools such as javac and javadoc (see
- * makefiles for more details) are built with this program. Any arguments
- * prefixed with '-J' will be passed directly to the 'java' command.
- */
-
-#ifdef GAMMA
-# ifdef JAVA_ARGS
-# error Do NOT define JAVA_ARGS when building gamma launcher
-# endif
-# if !defined(LINK_INTO_AOUT) && !defined(LINK_INTO_LIBJVM)
-# error Either LINK_INTO_AOUT or LINK_INTO_LIBJVM must be defined
-# endif
-#endif
-
-/*
- * One job of the launcher is to remove command line options which the
- * vm does not understand and will not process. These options include
- * options which select which style of vm is run (e.g. -client and
- * -server) as well as options which select the data model to use.
- * Additionally, for tools which invoke an underlying vm "-J-foo"
- * options are turned into "-foo" options to the vm. This option
- * filtering is handled in a number of places in the launcher, some of
- * it in machine-dependent code. In this file, the function
- * CheckJVMType removes vm style options and TranslateApplicationArgs
- * removes "-J" prefixes. On unix platforms, the
- * CreateExecutionEnvironment function from the unix java_md.c file
- * processes and removes -d<n> options. However, in case
- * CreateExecutionEnvironment does not need to exec because
- * LD_LIBRARY_PATH is set acceptably and the data model does not need
- * to be changed, ParseArguments will screen out the redundant -d<n>
- * options and prevent them from being passed to the vm; this is done
- * by using the machine-dependent call
- * RemovableMachineDependentOption.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <jni.h>
-#include <jvm.h>
-#include "java.h"
-#ifndef GAMMA
-#include "manifest_info.h"
-#include "version_comp.h"
-#include "splashscreen.h"
-#endif
-#include "wildcard.h"
-
-#ifndef FULL_VERSION
-#define FULL_VERSION JDK_MAJOR_VERSION "." JDK_MINOR_VERSION
-#endif
-
-/*
- * The following environment variable is used to influence the behavior
- * of the jre exec'd through the SelectVersion routine. The command line
- * options which specify the version are not passed to the exec'd version,
- * because that jre may be an older version which wouldn't recognize them.
- * This environment variable is known to this (and later) version and serves
- * to suppress the version selection code. This is not only for efficiency,
- * but also for correctness, since any command line options have been
- * removed which would cause any value found in the manifest to be used.
- * This would be incorrect because the command line options are defined
- * to take precedence.
- *
- * The value associated with this environment variable is the MainClass
- * name from within the executable jar file (if any). This is strictly a
- * performance enhancement to avoid re-reading the jar file manifest.
- *
- * A NOTE TO DEVELOPERS: For performance reasons it is important that
- * the program image remain relatively small until after SelectVersion
- * CreateExecutionEnvironment have finished their possibly recursive
- * processing. Watch everything, but resist all temptations to use Java
- * interfaces.
- */
-#define ENV_ENTRY "_JAVA_VERSION_SET"
-
-#ifndef GAMMA
-#define SPLASH_FILE_ENV_ENTRY "_JAVA_SPLASH_FILE"
-#define SPLASH_JAR_ENV_ENTRY "_JAVA_SPLASH_JAR"
-#endif
-
-static jboolean printVersion = JNI_FALSE; /* print and exit */
-static jboolean showVersion = JNI_FALSE; /* print but continue */
-static char *progname;
-jboolean _launcher_debug = JNI_FALSE;
-
-#ifndef GAMMA
-/*
- * Entries for splash screen environment variables.
- * putenv is performed in SelectVersion. We need
- * them in memory until UnsetEnv, so they are made static
- * global instead of auto local.
- */
-static char* splash_file_entry = NULL;
-static char* splash_jar_entry = NULL;
-#endif
-
-/*
- * List of VM options to be specified when the VM is created.
- */
-static JavaVMOption *options;
-static int numOptions, maxOptions;
-
-/*
- * Prototypes for functions internal to launcher.
- */
-static void SetClassPath(const char *s);
-static void SelectVersion(int argc, char **argv, char **main_class);
-static jboolean ParseArguments(int *pargc, char ***pargv, char **pjarfile,
- char **pclassname, int *pret, const char *jvmpath);
-static jboolean InitializeJVM(JavaVM **pvm, JNIEnv **penv,
- InvocationFunctions *ifn);
-static jstring NewPlatformString(JNIEnv *env, char *s);
-static jobjectArray NewPlatformStringArray(JNIEnv *env, char **strv, int strc);
-static jclass LoadClass(JNIEnv *env, char *name);
-static jstring GetMainClassName(JNIEnv *env, char *jarname);
-static void SetJavaCommandLineProp(char* classname, char* jarfile, int argc, char** argv);
-static void SetJavaLauncherProp(void);
-
-#ifdef JAVA_ARGS
-static void TranslateApplicationArgs(int *pargc, char ***pargv);
-static jboolean AddApplicationOptions(void);
-#endif
-
-static void PrintJavaVersion(JNIEnv *env);
-static void PrintUsage(void);
-static jint PrintXUsage(const char *jvmpath);
-
-static void SetPaths(int argc, char **argv);
-
-#ifndef GAMMA
-
-/* Maximum supported entries from jvm.cfg. */
-#define INIT_MAX_KNOWN_VMS 10
-/* Values for vmdesc.flag */
-#define VM_UNKNOWN -1
-#define VM_KNOWN 0
-#define VM_ALIASED_TO 1
-#define VM_WARN 2
-#define VM_ERROR 3
-#define VM_IF_SERVER_CLASS 4
-#define VM_IGNORE 5
-struct vmdesc {
- char *name;
- int flag;
- char *alias;
- char *server_class;
-};
-static struct vmdesc *knownVMs = NULL;
-static int knownVMsCount = 0;
-static int knownVMsLimit = 0;
-
-static void GrowKnownVMs();
-static int KnownVMIndex(const char* name);
-static void FreeKnownVMs();
-static void ShowSplashScreen();
-
-#endif /* ifndef GAMMA */
-
-jboolean ServerClassMachine();
-
-/* flag which if set suppresses error messages from the launcher */
-static int noExitErrorMessage = 0;
-
-/*
- * Running Java code in primordial thread caused many problems. We will
- * create a new thread to invoke JVM. See 6316197 for more information.
- */
-static jlong threadStackSize = 0; /* stack size of the new thread */
-
-int JNICALL JavaMain(void * args); /* entry point */
-
-struct JavaMainArgs {
- int argc;
- char ** argv;
- char * jarfile;
- char * classname;
- InvocationFunctions ifn;
-};
-
-/*
- * Entry point.
- */
-int
-main(int argc, char ** argv)
-{
- char *jarfile = 0;
- char *classname = 0;
- char *s = 0;
- char *main_class = NULL;
- int ret;
- InvocationFunctions ifn;
- jlong start, end;
- char jrepath[MAXPATHLEN], jvmpath[MAXPATHLEN];
- char ** original_argv = argv;
-
- if (getenv("_JAVA_LAUNCHER_DEBUG") != 0) {
- _launcher_debug = JNI_TRUE;
- printf("----_JAVA_LAUNCHER_DEBUG----\n");
- }
-
-#ifndef GAMMA
- /*
- * Make sure the specified version of the JRE is running.
- *
- * There are three things to note about the SelectVersion() routine:
- * 1) If the version running isn't correct, this routine doesn't
- * return (either the correct version has been exec'd or an error
- * was issued).
- * 2) Argc and Argv in this scope are *not* altered by this routine.
- * It is the responsibility of subsequent code to ignore the
- * arguments handled by this routine.
- * 3) As a side-effect, the variable "main_class" is guaranteed to
- * be set (if it should ever be set). This isn't exactly the
- * poster child for structured programming, but it is a small
- * price to pay for not processing a jar file operand twice.
- * (Note: This side effect has been disabled. See comment on
- * bugid 5030265 below.)
- */
- SelectVersion(argc, argv, &main_class);
-#endif /* ifndef GAMMA */
-
- /* copy original argv */
- {
- int i;
- original_argv = (char**)JLI_MemAlloc(sizeof(char*)*(argc+1));
- for(i = 0; i < argc+1; i++)
- original_argv[i] = argv[i];
- }
-
- CreateExecutionEnvironment(&argc, &argv,
- jrepath, sizeof(jrepath),
- jvmpath, sizeof(jvmpath),
- original_argv);
-
- printf("Using java runtime at: %s\n", jrepath);
-
- ifn.CreateJavaVM = 0;
- ifn.GetDefaultJavaVMInitArgs = 0;
-
- if (_launcher_debug)
- start = CounterGet();
- if (!LoadJavaVM(jvmpath, &ifn)) {
- exit(6);
- }
- if (_launcher_debug) {
- end = CounterGet();
- printf("%ld micro seconds to LoadJavaVM\n",
- (long)(jint)Counter2Micros(end-start));
- }
-
-#ifdef JAVA_ARGS /* javac, jar and friends. */
- progname = "java";
-#else /* java, oldjava, javaw and friends */
-#ifdef PROGNAME
- progname = PROGNAME;
-#else
- progname = *argv;
- if ((s = strrchr(progname, FILE_SEPARATOR)) != 0) {
- progname = s + 1;
- }
-#endif /* PROGNAME */
-#endif /* JAVA_ARGS */
- ++argv;
- --argc;
-
-#ifdef JAVA_ARGS
- /* Preprocess wrapper arguments */
- TranslateApplicationArgs(&argc, &argv);
- if (!AddApplicationOptions()) {
- exit(1);
- }
-#endif
-
- /* Set default CLASSPATH */
- if ((s = getenv("CLASSPATH")) == 0) {
- s = ".";
- }
-#ifndef JAVA_ARGS
- SetClassPath(s);
-#endif
-
- /*
- * Parse command line options; if the return value of
- * ParseArguments is false, the program should exit.
- */
- if (!ParseArguments(&argc, &argv, &jarfile, &classname, &ret, jvmpath)) {
- exit(ret);
- }
-
- /* Override class path if -jar flag was specified */
- if (jarfile != 0) {
- SetClassPath(jarfile);
- }
-
- /* set the -Dsun.java.command pseudo property */
- SetJavaCommandLineProp(classname, jarfile, argc, argv);
-
- /* Set the -Dsun.java.launcher pseudo property */
- SetJavaLauncherProp();
-
- /* set the -Dsun.java.launcher.* platform properties */
- SetJavaLauncherPlatformProps();
-
-#ifndef GAMMA
- /* Show the splash screen if needed */
- ShowSplashScreen();
-#endif
-
- /*
- * Done with all command line processing and potential re-execs so
- * clean up the environment.
- */
- (void)UnsetEnv(ENV_ENTRY);
-#ifndef GAMMA
- (void)UnsetEnv(SPLASH_FILE_ENV_ENTRY);
- (void)UnsetEnv(SPLASH_JAR_ENV_ENTRY);
-
- JLI_MemFree(splash_jar_entry);
- JLI_MemFree(splash_file_entry);
-#endif
-
- /*
- * If user doesn't specify stack size, check if VM has a preference.
- * Note that HotSpot no longer supports JNI_VERSION_1_1 but it will
- * return its default stack size through the init args structure.
- */
- if (threadStackSize == 0) {
- struct JDK1_1InitArgs args1_1;
- memset((void*)&args1_1, 0, sizeof(args1_1));
- args1_1.version = JNI_VERSION_1_1;
- ifn.GetDefaultJavaVMInitArgs(&args1_1); /* ignore return value */
- if (args1_1.javaStackSize > 0) {
- threadStackSize = args1_1.javaStackSize;
- }
- }
-
- { /* Create a new thread to create JVM and invoke main method */
- struct JavaMainArgs args;
-
- args.argc = argc;
- args.argv = argv;
- args.jarfile = jarfile;
- args.classname = classname;
- args.ifn = ifn;
-
- return ContinueInNewThread(JavaMain, threadStackSize, (void*)&args);
- }
-}
-
-int JNICALL
-JavaMain(void * _args)
-{
- struct JavaMainArgs *args = (struct JavaMainArgs *)_args;
- int argc = args->argc;
- char **argv = args->argv;
- char *jarfile = args->jarfile;
- char *classname = args->classname;
- InvocationFunctions ifn = args->ifn;
-
- JavaVM *vm = 0;
- JNIEnv *env = 0;
- jstring mainClassName;
- jclass mainClass;
- jmethodID mainID;
- jobjectArray mainArgs;
- int ret = 0;
- jlong start, end;
-
- /*
- * Error message to print or display; by default the message will
- * only be displayed in a window.
- */
- char * message = "Fatal exception occurred. Program will exit.";
- jboolean messageDest = JNI_FALSE;
-
- /* Initialize the virtual machine */
-
- if (_launcher_debug)
- start = CounterGet();
- if (!InitializeJVM(&vm, &env, &ifn)) {
- ReportErrorMessage("Could not create the Java virtual machine.",
- JNI_TRUE);
- exit(1);
- }
-
- if (printVersion || showVersion) {
- PrintJavaVersion(env);
- if ((*env)->ExceptionOccurred(env)) {
- ReportExceptionDescription(env);
- goto leave;
- }
- if (printVersion) {
- ret = 0;
- message = NULL;
- goto leave;
- }
- if (showVersion) {
- fprintf(stderr, "\n");
- }
- }
-
- /* If the user specified neither a class name nor a JAR file */
- if (jarfile == 0 && classname == 0) {
- PrintUsage();
- message = NULL;
- goto leave;
- }
-
-#ifndef GAMMA
- FreeKnownVMs(); /* after last possible PrintUsage() */
-#endif
-
- if (_launcher_debug) {
- end = CounterGet();
- printf("%ld micro seconds to InitializeJVM\n",
- (long)(jint)Counter2Micros(end-start));
- }
-
- /* At this stage, argc/argv have the applications' arguments */
- if (_launcher_debug) {
- int i = 0;
- printf("Main-Class is '%s'\n", classname ? classname : "");
- printf("Apps' argc is %d\n", argc);
- for (; i < argc; i++) {
- printf(" argv[%2d] = '%s'\n", i, argv[i]);
- }
- }
-
- ret = 1;
-
- /*
- * Get the application's main class.
- *
- * See bugid 5030265. The Main-Class name has already been parsed
- * from the manifest, but not parsed properly for UTF-8 support.
- * Hence the code here ignores the value previously extracted and
- * uses the pre-existing code to reextract the value. This is
- * possibly an end of release cycle expedient. However, it has
- * also been discovered that passing some character sets through
- * the environment has "strange" behavior on some variants of
- * Windows. Hence, maybe the manifest parsing code local to the
- * launcher should never be enhanced.
- *
- * Hence, future work should either:
- * 1) Correct the local parsing code and verify that the
- * Main-Class attribute gets properly passed through
- * all environments,
- * 2) Remove the vestages of maintaining main_class through
- * the environment (and remove these comments).
- */
- if (jarfile != 0) {
- mainClassName = GetMainClassName(env, jarfile);
- if ((*env)->ExceptionOccurred(env)) {
- ReportExceptionDescription(env);
- goto leave;
- }
- if (mainClassName == NULL) {
- const char * format = "Failed to load Main-Class manifest "
- "attribute from\n%s";
- message = (char*)JLI_MemAlloc((strlen(format) + strlen(jarfile)) *
- sizeof(char));
- sprintf(message, format, jarfile);
- messageDest = JNI_TRUE;
- goto leave;
- }
- classname = (char *)(*env)->GetStringUTFChars(env, mainClassName, 0);
- if (classname == NULL) {
- ReportExceptionDescription(env);
- goto leave;
- }
- mainClass = LoadClass(env, classname);
- if(mainClass == NULL) { /* exception occured */
- const char * format = "Could not find the main class: %s. Program will exit.";
- ReportExceptionDescription(env);
- message = (char *)JLI_MemAlloc((strlen(format) +
- strlen(classname)) * sizeof(char) );
- messageDest = JNI_TRUE;
- sprintf(message, format, classname);
- goto leave;
- }
- (*env)->ReleaseStringUTFChars(env, mainClassName, classname);
- } else {
- mainClassName = NewPlatformString(env, classname);
- if (mainClassName == NULL) {
- const char * format = "Failed to load Main Class: %s";
- message = (char *)JLI_MemAlloc((strlen(format) + strlen(classname)) *
- sizeof(char) );
- sprintf(message, format, classname);
- messageDest = JNI_TRUE;
- goto leave;
- }
- classname = (char *)(*env)->GetStringUTFChars(env, mainClassName, 0);
- if (classname == NULL) {
- ReportExceptionDescription(env);
- goto leave;
- }
- mainClass = LoadClass(env, classname);
- if(mainClass == NULL) { /* exception occured */
- const char * format = "Could not find the main class: %s. Program will exit.";
- ReportExceptionDescription(env);
- message = (char *)JLI_MemAlloc((strlen(format) +
- strlen(classname)) * sizeof(char) );
- messageDest = JNI_TRUE;
- sprintf(message, format, classname);
- goto leave;
- }
- (*env)->ReleaseStringUTFChars(env, mainClassName, classname);
- }
-
- /* Get the application's main method */
- mainID = (*env)->GetStaticMethodID(env, mainClass, "main",
- "([Ljava/lang/String;)V");
- if (mainID == NULL) {
- if ((*env)->ExceptionOccurred(env)) {
- ReportExceptionDescription(env);
- } else {
- message = "No main method found in specified class.";
- messageDest = JNI_TRUE;
- }
- goto leave;
- }
-
- { /* Make sure the main method is public */
- jint mods;
- jmethodID mid;
- jobject obj = (*env)->ToReflectedMethod(env, mainClass,
- mainID, JNI_TRUE);
-
- if( obj == NULL) { /* exception occurred */
- ReportExceptionDescription(env);
- goto leave;
- }
-
- mid =
- (*env)->GetMethodID(env,
- (*env)->GetObjectClass(env, obj),
- "getModifiers", "()I");
- if ((*env)->ExceptionOccurred(env)) {
- ReportExceptionDescription(env);
- goto leave;
- }
-
- mods = (*env)->CallIntMethod(env, obj, mid);
- if ((mods & 1) == 0) { /* if (!Modifier.isPublic(mods)) ... */
- message = "Main method not public.";
- messageDest = JNI_TRUE;
- goto leave;
- }
- }
-
- /* Build argument array */
- mainArgs = NewPlatformStringArray(env, argv, argc);
- if (mainArgs == NULL) {
- ReportExceptionDescription(env);
- goto leave;
- }
-
- /* Invoke main method. */
- (*env)->CallStaticVoidMethod(env, mainClass, mainID, mainArgs);
-
- /*
- * The launcher's exit code (in the absence of calls to
- * System.exit) will be non-zero if main threw an exception.
- */
- ret = (*env)->ExceptionOccurred(env) == NULL ? 0 : 1;
-
- /*
- * Detach the main thread so that it appears to have ended when
- * the application's main method exits. This will invoke the
- * uncaught exception handler machinery if main threw an
- * exception. An uncaught exception handler cannot change the
- * launcher's return code except by calling System.exit.
- */
- if ((*vm)->DetachCurrentThread(vm) != 0) {
- message = "Could not detach main thread.";
- messageDest = JNI_TRUE;
- ret = 1;
- goto leave;
- }
-
- message = NULL;
-
- leave:
- /*
- * Wait for all non-daemon threads to end, then destroy the VM.
- * This will actually create a trivial new Java waiter thread
- * named "DestroyJavaVM", but this will be seen as a different
- * thread from the one that executed main, even though they are
- * the same C thread. This allows mainThread.join() and
- * mainThread.isAlive() to work as expected.
- */
- (*vm)->DestroyJavaVM(vm);
-
- if(message != NULL && !noExitErrorMessage)
- ReportErrorMessage(message, messageDest);
- return ret;
-}
-
-#ifndef GAMMA
-/*
- * Checks the command line options to find which JVM type was
- * specified. If no command line option was given for the JVM type,
- * the default type is used. The environment variable
- * JDK_ALTERNATE_VM and the command line option -XXaltjvm= are also
- * checked as ways of specifying which JVM type to invoke.
- */
-char *
-CheckJvmType(int *pargc, char ***argv, jboolean speculative) {
- int i, argi;
- int argc;
- char **newArgv;
- int newArgvIdx = 0;
- int isVMType;
- int jvmidx = -1;
- char *jvmtype = getenv("JDK_ALTERNATE_VM");
-
- argc = *pargc;
-
- /* To make things simpler we always copy the argv array */
- newArgv = JLI_MemAlloc((argc + 1) * sizeof(char *));
-
- /* The program name is always present */
- newArgv[newArgvIdx++] = (*argv)[0];
-
- for (argi = 1; argi < argc; argi++) {
- char *arg = (*argv)[argi];
- isVMType = 0;
-
-#ifdef JAVA_ARGS
- if (arg[0] != '-') {
- newArgv[newArgvIdx++] = arg;
- continue;
- }
-#else
- if (strcmp(arg, "-classpath") == 0 ||
- strcmp(arg, "-cp") == 0) {
- newArgv[newArgvIdx++] = arg;
- argi++;
- if (argi < argc) {
- newArgv[newArgvIdx++] = (*argv)[argi];
- }
- continue;
- }
- if (arg[0] != '-') break;
-#endif
-
- /* Did the user pass an explicit VM type? */
- i = KnownVMIndex(arg);
- if (i >= 0) {
- jvmtype = knownVMs[jvmidx = i].name + 1; /* skip the - */
- isVMType = 1;
- *pargc = *pargc - 1;
- }
-
- /* Did the user specify an "alternate" VM? */
- else if (strncmp(arg, "-XXaltjvm=", 10) == 0 || strncmp(arg, "-J-XXaltjvm=", 12) == 0) {
- isVMType = 1;
- jvmtype = arg+((arg[1]=='X')? 10 : 12);
- jvmidx = -1;
- }
-
- if (!isVMType) {
- newArgv[newArgvIdx++] = arg;
- }
- }
-
- /*
- * Finish copying the arguments if we aborted the above loop.
- * NOTE that if we aborted via "break" then we did NOT copy the
- * last argument above, and in addition argi will be less than
- * argc.
- */
- while (argi < argc) {
- newArgv[newArgvIdx++] = (*argv)[argi];
- argi++;
- }
-
- /* argv is null-terminated */
- newArgv[newArgvIdx] = 0;
-
- /* Copy back argv */
- *argv = newArgv;
- *pargc = newArgvIdx;
-
- /* use the default VM type if not specified (no alias processing) */
- if (jvmtype == NULL) {
- char* result = knownVMs[0].name+1;
- /* Use a different VM type if we are on a server class machine? */
- if ((knownVMs[0].flag == VM_IF_SERVER_CLASS) &&
- (ServerClassMachine() == JNI_TRUE)) {
- result = knownVMs[0].server_class+1;
- }
- if (_launcher_debug) {
- printf("Default VM: %s\n", result);
- }
- return result;
- }
-
- /* if using an alternate VM, no alias processing */
- if (jvmidx < 0)
- return jvmtype;
-
- /* Resolve aliases first */
- {
- int loopCount = 0;
- while (knownVMs[jvmidx].flag == VM_ALIASED_TO) {
- int nextIdx = KnownVMIndex(knownVMs[jvmidx].alias);
-
- if (loopCount > knownVMsCount) {
- if (!speculative) {
- ReportErrorMessage("Error: Corrupt jvm.cfg file; cycle in alias list.",
- JNI_TRUE);
- exit(1);
- } else {
- return "ERROR";
- /* break; */
- }
- }
-
- if (nextIdx < 0) {
- if (!speculative) {
- ReportErrorMessage2("Error: Unable to resolve VM alias %s",
- knownVMs[jvmidx].alias, JNI_TRUE);
- exit(1);
- } else {
- return "ERROR";
- }
- }
- jvmidx = nextIdx;
- jvmtype = knownVMs[jvmidx].name+1;
- loopCount++;
- }
- }
-
- switch (knownVMs[jvmidx].flag) {
- case VM_WARN:
- if (!speculative) {
- fprintf(stderr, "Warning: %s VM not supported; %s VM will be used\n",
- jvmtype, knownVMs[0].name + 1);
- }
- /* fall through */
- case VM_IGNORE:
- jvmtype = knownVMs[jvmidx=0].name + 1;
- /* fall through */
- case VM_KNOWN:
- break;
- case VM_ERROR:
- if (!speculative) {
- ReportErrorMessage2("Error: %s VM not supported", jvmtype, JNI_TRUE);
- exit(1);
- } else {
- return "ERROR";
- }
- }
-
- return jvmtype;
-}
-#endif /* ifndef GAMMA */
-
-# define KB (1024UL)
-# define MB (1024UL * KB)
-# define GB (1024UL * MB)
-
-/* copied from HotSpot function "atomll()" */
-static int
-parse_stack_size(const char *s, jlong *result) {
- jlong n = 0;
- int args_read = sscanf(s, JLONG_FORMAT, &n);
- if (args_read != 1) {
- return 0;
- }
- while (*s != '\0' && *s >= '0' && *s <= '9') {
- s++;
- }
- // 4705540: illegal if more characters are found after the first non-digit
- if (strlen(s) > 1) {
- return 0;
- }
- switch (*s) {
- case 'T': case 't':
- *result = n * GB * KB;
- return 1;
- case 'G': case 'g':
- *result = n * GB;
- return 1;
- case 'M': case 'm':
- *result = n * MB;
- return 1;
- case 'K': case 'k':
- *result = n * KB;
- return 1;
- case '\0':
- *result = n;
- return 1;
- default:
- /* Create JVM with default stack and let VM handle malformed -Xss string*/
- return 0;
- }
-}
-
-/*
- * Adds a new VM option with the given given name and value.
- */
-void
-AddOption(char *str, void *info)
-{
- /*
- * Expand options array if needed to accommodate at least one more
- * VM option.
- */
- if (numOptions >= maxOptions) {
- if (options == 0) {
- maxOptions = 4;
- options = JLI_MemAlloc(maxOptions * sizeof(JavaVMOption));
- } else {
- JavaVMOption *tmp;
- maxOptions *= 2;
- tmp = JLI_MemAlloc(maxOptions * sizeof(JavaVMOption));
- memcpy(tmp, options, numOptions * sizeof(JavaVMOption));
- JLI_MemFree(options);
- options = tmp;
- }
- }
- options[numOptions].optionString = str;
- options[numOptions++].extraInfo = info;
-
- if (strncmp(str, "-Xss", 4) == 0) {
- jlong tmp;
- if (parse_stack_size(str + 4, &tmp)) {
- threadStackSize = tmp;
- }
- }
-}
-
-static void
-SetClassPath(const char *s)
-{
- char *def;
- s = JLI_WildcardExpandClasspath(s);
- def = JLI_MemAlloc(strlen(s) + 40);
- sprintf(def, "-Djava.class.path=%s", s);
- AddOption(def, NULL);
-}
-
-#ifndef GAMMA
-/*
- * The SelectVersion() routine ensures that an appropriate version of
- * the JRE is running. The specification for the appropriate version
- * is obtained from either the manifest of a jar file (preferred) or
- * from command line options.
- * The routine also parses splash screen command line options and
- * passes on their values in private environment variables.
- */
-static void
-SelectVersion(int argc, char **argv, char **main_class)
-{
- char *arg;
- char **new_argv;
- char **new_argp;
- char *operand;
- char *version = NULL;
- char *jre = NULL;
- int jarflag = 0;
- int headlessflag = 0;
- int restrict_search = -1; /* -1 implies not known */
- manifest_info info;
- char env_entry[MAXNAMELEN + 24] = ENV_ENTRY "=";
- char *splash_file_name = NULL;
- char *splash_jar_name = NULL;
- char *env_in;
- int res;
-
- /*
- * If the version has already been selected, set *main_class
- * with the value passed through the environment (if any) and
- * simply return.
- */
- if ((env_in = getenv(ENV_ENTRY)) != NULL) {
- if (*env_in != '\0')
- *main_class = JLI_StringDup(env_in);
- return;
- }
-
- /*
- * Scan through the arguments for options relevant to multiple JRE
- * support. For reference, the command line syntax is defined as:
- *
- * SYNOPSIS
- * java [options] class [argument...]
- *
- * java [options] -jar file.jar [argument...]
- *
- * As the scan is performed, make a copy of the argument list with
- * the version specification options (new to 1.5) removed, so that
- * a version less than 1.5 can be exec'd.
- *
- * Note that due to the syntax of the native Windows interface
- * CreateProcess(), processing similar to the following exists in
- * the Windows platform specific routine ExecJRE (in java_md.c).
- * Changes here should be reproduced there.
- */
- new_argv = JLI_MemAlloc((argc + 1) * sizeof(char*));
- new_argv[0] = argv[0];
- new_argp = &new_argv[1];
- argc--;
- argv++;
- while ((arg = *argv) != 0 && *arg == '-') {
- if (strncmp(arg, "-version:", 9) == 0) {
- version = arg + 9;
- } else if (strcmp(arg, "-jre-restrict-search") == 0) {
- restrict_search = 1;
- } else if (strcmp(arg, "-no-jre-restrict-search") == 0) {
- restrict_search = 0;
- } else {
- if (strcmp(arg, "-jar") == 0)
- jarflag = 1;
- /* deal with "unfortunate" classpath syntax */
- if ((strcmp(arg, "-classpath") == 0 || strcmp(arg, "-cp") == 0) &&
- (argc >= 2)) {
- *new_argp++ = arg;
- argc--;
- argv++;
- arg = *argv;
- }
-
- /*
- * Checking for headless toolkit option in the some way as AWT does:
- * "true" means true and any other value means false
- */
- if (strcmp(arg, "-Djava.awt.headless=true") == 0) {
- headlessflag = 1;
- } else if (strncmp(arg, "-Djava.awt.headless=", 20) == 0) {
- headlessflag = 0;
- } else if (strncmp(arg, "-splash:", 8) == 0) {
- splash_file_name = arg+8;
- }
- *new_argp++ = arg;
- }
- argc--;
- argv++;
- }
- if (argc <= 0) { /* No operand? Possibly legit with -[full]version */
- operand = NULL;
- } else {
- argc--;
- *new_argp++ = operand = *argv++;
- }
- while (argc-- > 0) /* Copy over [argument...] */
- *new_argp++ = *argv++;
- *new_argp = NULL;
-
- /*
- * If there is a jar file, read the manifest. If the jarfile can't be
- * read, the manifest can't be read from the jar file, or the manifest
- * is corrupt, issue the appropriate error messages and exit.
- *
- * Even if there isn't a jar file, construct a manifest_info structure
- * containing the command line information. It's a convenient way to carry
- * this data around.
- */
- if (jarflag && operand) {
- if ((res = JLI_ParseManifest(operand, &info)) != 0) {
- if (res == -1)
- ReportErrorMessage2("Unable to access jarfile %s",
- operand, JNI_TRUE);
- else
- ReportErrorMessage2("Invalid or corrupt jarfile %s",
- operand, JNI_TRUE);
- exit(1);
- }
-
- /*
- * Command line splash screen option should have precedence
- * over the manifest, so the manifest data is used only if
- * splash_file_name has not been initialized above during command
- * line parsing
- */
- if (!headlessflag && !splash_file_name && info.splashscreen_image_file_name) {
- splash_file_name = info.splashscreen_image_file_name;
- splash_jar_name = operand;
- }
- } else {
- info.manifest_version = NULL;
- info.main_class = NULL;
- info.jre_version = NULL;
- info.jre_restrict_search = 0;
- }
-
- /*
- * Passing on splash screen info in environment variables
- */
- if (splash_file_name && !headlessflag) {
- char* splash_file_entry = JLI_MemAlloc(strlen(SPLASH_FILE_ENV_ENTRY "=")+strlen(splash_file_name)+1);
- strcpy(splash_file_entry, SPLASH_FILE_ENV_ENTRY "=");
- strcat(splash_file_entry, splash_file_name);
- putenv(splash_file_entry);
- }
- if (splash_jar_name && !headlessflag) {
- char* splash_jar_entry = JLI_MemAlloc(strlen(SPLASH_JAR_ENV_ENTRY "=")+strlen(splash_jar_name)+1);
- strcpy(splash_jar_entry, SPLASH_JAR_ENV_ENTRY "=");
- strcat(splash_jar_entry, splash_jar_name);
- putenv(splash_jar_entry);
- }
-
- /*
- * The JRE-Version and JRE-Restrict-Search values (if any) from the
- * manifest are overwritten by any specified on the command line.
- */
- if (version != NULL)
- info.jre_version = version;
- if (restrict_search != -1)
- info.jre_restrict_search = restrict_search;
-
- /*
- * "Valid" returns (other than unrecoverable errors) follow. Set
- * main_class as a side-effect of this routine.
- */
- if (info.main_class != NULL)
- *main_class = JLI_StringDup(info.main_class);
-
- /*
- * If no version selection information is found either on the command
- * line or in the manifest, simply return.
- */
- if (info.jre_version == NULL) {
- JLI_FreeManifest();
- JLI_MemFree(new_argv);
- return;
- }
-
- /*
- * Check for correct syntax of the version specification (JSR 56).
- */
- if (!JLI_ValidVersionString(info.jre_version)) {
- ReportErrorMessage2("Syntax error in version specification \"%s\"",
- info.jre_version, JNI_TRUE);
- exit(1);
- }
-
- /*
- * Find the appropriate JVM on the system. Just to be as forgiving as
- * possible, if the standard algorithms don't locate an appropriate
- * jre, check to see if the one running will satisfy the requirements.
- * This can happen on systems which haven't been set-up for multiple
- * JRE support.
- */
- jre = LocateJRE(&info);
- if (_launcher_debug)
- printf("JRE-Version = %s, JRE-Restrict-Search = %s Selected = %s\n",
- (info.jre_version?info.jre_version:"null"),
- (info.jre_restrict_search?"true":"false"), (jre?jre:"null"));
- if (jre == NULL) {
- if (JLI_AcceptableRelease(FULL_VERSION, info.jre_version)) {
- JLI_FreeManifest();
- JLI_MemFree(new_argv);
- return;
- } else {
- ReportErrorMessage2(
- "Unable to locate JRE meeting specification \"%s\"",
- info.jre_version, JNI_TRUE);
- exit(1);
- }
- }
-
- /*
- * If I'm not the chosen one, exec the chosen one. Returning from
- * ExecJRE indicates that I am indeed the chosen one.
- *
- * The private environment variable _JAVA_VERSION_SET is used to
- * prevent the chosen one from re-reading the manifest file and
- * using the values found within to override the (potential) command
- * line flags stripped from argv (because the target may not
- * understand them). Passing the MainClass value is an optimization
- * to avoid locating, expanding and parsing the manifest extra
- * times.
- */
- if (info.main_class != NULL) {
- if (strlen(info.main_class) <= MAXNAMELEN) {
- (void)strcat(env_entry, info.main_class);
- } else {
- ReportErrorMessage("Error: main-class: attribute exceeds system limits\n", JNI_TRUE);
- exit(1);
- }
- }
- (void)putenv(env_entry);
- ExecJRE(jre, new_argv);
- JLI_FreeManifest();
- JLI_MemFree(new_argv);
- return;
-}
-#endif /* ifndef GAMMA */
-
-/*
- * Parses command line arguments. Returns JNI_FALSE if launcher
- * should exit without starting vm (e.g. certain version and usage
- * options); returns JNI_TRUE if vm needs to be started to process
- * given options. *pret (the launcher process return value) is set to
- * 0 for a normal exit.
- */
-static jboolean
-ParseArguments(int *pargc, char ***pargv, char **pjarfile,
- char **pclassname, int *pret, const char *jvmpath)
-{
- int argc = *pargc;
- char **argv = *pargv;
- jboolean jarflag = JNI_FALSE;
- char *arg;
-
- *pret = 1;
- while ((arg = *argv) != 0 && *arg == '-') {
- argv++; --argc;
- if (strcmp(arg, "-classpath") == 0 || strcmp(arg, "-cp") == 0) {
- if (argc < 1) {
- ReportErrorMessage2("%s requires class path specification",
- arg, JNI_TRUE);
- PrintUsage();
- return JNI_FALSE;
- }
- SetClassPath(*argv);
- argv++; --argc;
- } else if (strcmp(arg, "-jar") == 0) {
- jarflag = JNI_TRUE;
- } else if (strcmp(arg, "-help") == 0 ||
- strcmp(arg, "-h") == 0 ||
- strcmp(arg, "-?") == 0) {
- PrintUsage();
- *pret = 0;
- return JNI_FALSE;
- } else if (strcmp(arg, "-version") == 0) {
- printVersion = JNI_TRUE;
- return JNI_TRUE;
- } else if (strcmp(arg, "-showversion") == 0) {
- showVersion = JNI_TRUE;
- } else if (strcmp(arg, "-X") == 0) {
- *pret = PrintXUsage(jvmpath);
- return JNI_FALSE;
-/*
- * The following case provide backward compatibility with old-style
- * command line options.
- */
- } else if (strcmp(arg, "-fullversion") == 0) {
- fprintf(stderr, "%s full version \"%s\"\n", progname,
- FULL_VERSION);
- *pret = 0;
- return JNI_FALSE;
- } else if (strcmp(arg, "-verbosegc") == 0) {
- AddOption("-verbose:gc", NULL);
- } else if (strcmp(arg, "-t") == 0) {
- AddOption("-Xt", NULL);
- } else if (strcmp(arg, "-tm") == 0) {
- AddOption("-Xtm", NULL);
- } else if (strcmp(arg, "-debug") == 0) {
- AddOption("-Xdebug", NULL);
- } else if (strcmp(arg, "-noclassgc") == 0) {
- AddOption("-Xnoclassgc", NULL);
- } else if (strcmp(arg, "-Xfuture") == 0) {
- AddOption("-Xverify:all", NULL);
- } else if (strcmp(arg, "-verify") == 0) {
- AddOption("-Xverify:all", NULL);
- } else if (strcmp(arg, "-verifyremote") == 0) {
- AddOption("-Xverify:remote", NULL);
- } else if (strcmp(arg, "-noverify") == 0) {
- AddOption("-Xverify:none", NULL);
- } else if (strcmp(arg, "-XXsuppressExitMessage") == 0) {
- noExitErrorMessage = 1;
- } else if (strncmp(arg, "-prof", 5) == 0) {
- char *p = arg + 5;
- char *tmp = JLI_MemAlloc(strlen(arg) + 50);
- if (*p) {
- sprintf(tmp, "-Xrunhprof:cpu=old,file=%s", p + 1);
- } else {
- sprintf(tmp, "-Xrunhprof:cpu=old,file=java.prof");
- }
- AddOption(tmp, NULL);
- } else if (strncmp(arg, "-ss", 3) == 0 ||
- strncmp(arg, "-oss", 4) == 0 ||
- strncmp(arg, "-ms", 3) == 0 ||
- strncmp(arg, "-mx", 3) == 0) {
- char *tmp = JLI_MemAlloc(strlen(arg) + 6);
- sprintf(tmp, "-X%s", arg + 1); /* skip '-' */
- AddOption(tmp, NULL);
- } else if (strcmp(arg, "-checksource") == 0 ||
- strcmp(arg, "-cs") == 0 ||
- strcmp(arg, "-noasyncgc") == 0) {
- /* No longer supported */
- fprintf(stderr,
- "Warning: %s option is no longer supported.\n",
- arg);
- } else if (strncmp(arg, "-version:", 9) == 0 ||
- strcmp(arg, "-no-jre-restrict-search") == 0 ||
- strcmp(arg, "-jre-restrict-search") == 0 ||
- strncmp(arg, "-splash:", 8) == 0) {
- ; /* Ignore machine independent options already handled */
- } else if (RemovableMachineDependentOption(arg) ) {
- ; /* Do not pass option to vm. */
- }
- else {
- AddOption(arg, NULL);
- }
- }
-
- if (--argc >= 0) {
- if (jarflag) {
- *pjarfile = *argv++;
- *pclassname = 0;
- } else {
- *pjarfile = 0;
- *pclassname = *argv++;
- }
- *pargc = argc;
- *pargv = argv;
- }
-
- return JNI_TRUE;
-}
-
-/*
- * Initializes the Java Virtual Machine. Also frees options array when
- * finished.
- */
-static jboolean
-InitializeJVM(JavaVM **pvm, JNIEnv **penv, InvocationFunctions *ifn)
-{
- JavaVMInitArgs args;
- jint r;
-
- memset(&args, 0, sizeof(args));
- args.version = JNI_VERSION_1_2;
- args.nOptions = numOptions;
- args.options = options;
- args.ignoreUnrecognized = JNI_FALSE;
-
- if (_launcher_debug) {
- int i = 0;
- printf("JavaVM args:\n ");
- printf("version 0x%08lx, ", (long)args.version);
- printf("ignoreUnrecognized is %s, ",
- args.ignoreUnrecognized ? "JNI_TRUE" : "JNI_FALSE");
- printf("nOptions is %ld\n", (long)args.nOptions);
- for (i = 0; i < numOptions; i++)
- printf(" option[%2d] = '%s'\n",
- i, args.options[i].optionString);
- }
-
- r = ifn->CreateJavaVM(pvm, (void **)penv, &args);
- JLI_MemFree(options);
- return r == JNI_OK;
-}
-
-
-#define NULL_CHECK0(e) if ((e) == 0) return 0
-#define NULL_CHECK(e) if ((e) == 0) return
-
-static jstring platformEncoding = NULL;
-static jstring getPlatformEncoding(JNIEnv *env) {
- if (platformEncoding == NULL) {
- jstring propname = (*env)->NewStringUTF(env, "sun.jnu.encoding");
- if (propname) {
- jclass cls;
- jmethodID mid;
- NULL_CHECK0 (cls = (*env)->FindClass(env, "java/lang/System"));
- NULL_CHECK0 (mid = (*env)->GetStaticMethodID(
- env, cls,
- "getProperty",
- "(Ljava/lang/String;)Ljava/lang/String;"));
- platformEncoding = (*env)->CallStaticObjectMethod (
- env, cls, mid, propname);
- }
- }
- return platformEncoding;
-}
-
-static jboolean isEncodingSupported(JNIEnv *env, jstring enc) {
- jclass cls;
- jmethodID mid;
- NULL_CHECK0 (cls = (*env)->FindClass(env, "java/nio/charset/Charset"));
- NULL_CHECK0 (mid = (*env)->GetStaticMethodID(
- env, cls,
- "isSupported",
- "(Ljava/lang/String;)Z"));
- return (*env)->CallStaticBooleanMethod(env, cls, mid, enc);
-}
-
-/*
- * Returns a new Java string object for the specified platform string.
- */
-static jstring
-NewPlatformString(JNIEnv *env, char *s)
-{
- int len = (int)strlen(s);
- jclass cls;
- jmethodID mid;
- jbyteArray ary;
- jstring enc;
-
- if (s == NULL)
- return 0;
- enc = getPlatformEncoding(env);
-
- ary = (*env)->NewByteArray(env, len);
- if (ary != 0) {
- jstring str = 0;
- (*env)->SetByteArrayRegion(env, ary, 0, len, (jbyte *)s);
- if (!(*env)->ExceptionOccurred(env)) {
- if (isEncodingSupported(env, enc) == JNI_TRUE) {
- NULL_CHECK0(cls = (*env)->FindClass(env, "java/lang/String"));
- NULL_CHECK0(mid = (*env)->GetMethodID(env, cls, "<init>",
- "([BLjava/lang/String;)V"));
- str = (*env)->NewObject(env, cls, mid, ary, enc);
- } else {
- /*If the encoding specified in sun.jnu.encoding is not
- endorsed by "Charset.isSupported" we have to fall back
- to use String(byte[]) explicitly here without specifying
- the encoding name, in which the StringCoding class will
- pickup the iso-8859-1 as the fallback converter for us.
- */
- NULL_CHECK0(cls = (*env)->FindClass(env, "java/lang/String"));
- NULL_CHECK0(mid = (*env)->GetMethodID(env, cls, "<init>",
- "([B)V"));
- str = (*env)->NewObject(env, cls, mid, ary);
- }
- (*env)->DeleteLocalRef(env, ary);
- return str;
- }
- }
- return 0;
-}
-
-/*
- * Returns a new array of Java string objects for the specified
- * array of platform strings.
- */
-static jobjectArray
-NewPlatformStringArray(JNIEnv *env, char **strv, int strc)
-{
- jarray cls;
- jarray ary;
- int i;
-
- NULL_CHECK0(cls = (*env)->FindClass(env, "java/lang/String"));
- NULL_CHECK0(ary = (*env)->NewObjectArray(env, strc, cls, 0));
- for (i = 0; i < strc; i++) {
- jstring str = NewPlatformString(env, *strv++);
- NULL_CHECK0(str);
- (*env)->SetObjectArrayElement(env, ary, i, str);
- (*env)->DeleteLocalRef(env, str);
- }
- return ary;
-}
-
-/*
- * Loads a class, convert the '.' to '/'.
- */
-static jclass
-LoadClass(JNIEnv *env, char *name)
-{
- char *buf = JLI_MemAlloc(strlen(name) + 1);
- char *s = buf, *t = name, c;
- jclass cls;
- jlong start, end;
-
- if (_launcher_debug)
- start = CounterGet();
-
- do {
- c = *t++;
- *s++ = (c == '.') ? '/' : c;
- } while (c != '\0');
- cls = (*env)->FindClass(env, buf);
- JLI_MemFree(buf);
-
- if (_launcher_debug) {
- end = CounterGet();
- printf("%ld micro seconds to load main class\n",
- (long)(jint)Counter2Micros(end-start));
- printf("----_JAVA_LAUNCHER_DEBUG----\n");
- }
-
- return cls;
-}
-
-
-/*
- * Returns the main class name for the specified jar file.
- */
-static jstring
-GetMainClassName(JNIEnv *env, char *jarname)
-{
-#define MAIN_CLASS "Main-Class"
- jclass cls;
- jmethodID mid;
- jobject jar, man, attr;
- jstring str, result = 0;
-
- NULL_CHECK0(cls = (*env)->FindClass(env, "java/util/jar/JarFile"));
- NULL_CHECK0(mid = (*env)->GetMethodID(env, cls, "<init>",
- "(Ljava/lang/String;)V"));
- NULL_CHECK0(str = NewPlatformString(env, jarname));
- NULL_CHECK0(jar = (*env)->NewObject(env, cls, mid, str));
- NULL_CHECK0(mid = (*env)->GetMethodID(env, cls, "getManifest",
- "()Ljava/util/jar/Manifest;"));
- man = (*env)->CallObjectMethod(env, jar, mid);
- if (man != 0) {
- NULL_CHECK0(mid = (*env)->GetMethodID(env,
- (*env)->GetObjectClass(env, man),
- "getMainAttributes",
- "()Ljava/util/jar/Attributes;"));
- attr = (*env)->CallObjectMethod(env, man, mid);
- if (attr != 0) {
- NULL_CHECK0(mid = (*env)->GetMethodID(env,
- (*env)->GetObjectClass(env, attr),
- "getValue",
- "(Ljava/lang/String;)Ljava/lang/String;"));
- NULL_CHECK0(str = NewPlatformString(env, MAIN_CLASS));
- result = (*env)->CallObjectMethod(env, attr, mid, str);
- }
- }
- return result;
-}
-
-#ifdef JAVA_ARGS
-static char *java_args[] = JAVA_ARGS;
-static char *app_classpath[] = APP_CLASSPATH;
-
-/*
- * For tools, convert command line args thus:
- * javac -cp foo:foo/"*" -J-ms32m ...
- * java -ms32m -cp JLI_WildcardExpandClasspath(foo:foo/"*") ...
- */
-static void
-TranslateApplicationArgs(int *pargc, char ***pargv)
-{
- const int NUM_ARGS = (sizeof(java_args) / sizeof(char *));
- int argc = *pargc;
- char **argv = *pargv;
- int nargc = argc + NUM_ARGS;
- char **nargv = JLI_MemAlloc((nargc + 1) * sizeof(char *));
- int i;
-
- *pargc = nargc;
- *pargv = nargv;
-
- /* Copy the VM arguments (i.e. prefixed with -J) */
- for (i = 0; i < NUM_ARGS; i++) {
- char *arg = java_args[i];
- if (arg[0] == '-' && arg[1] == 'J') {
- *nargv++ = arg + 2;
- }
- }
-
- for (i = 0; i < argc; i++) {
- char *arg = argv[i];
- if (arg[0] == '-' && arg[1] == 'J') {
- if (arg[2] == '\0') {
- ReportErrorMessage("Error: the -J option should not be "
- "followed by a space.", JNI_TRUE);
- exit(1);
- }
- *nargv++ = arg + 2;
- }
- }
-
- /* Copy the rest of the arguments */
- for (i = 0; i < NUM_ARGS; i++) {
- char *arg = java_args[i];
- if (arg[0] != '-' || arg[1] != 'J') {
- *nargv++ = arg;
- }
- }
- for (i = 0; i < argc; i++) {
- char *arg = argv[i];
- if (arg[0] == '-') {
- if (arg[1] == 'J')
- continue;
-#ifdef EXPAND_CLASSPATH_WILDCARDS
- if (arg[1] == 'c'
- && (strcmp(arg, "-cp") == 0 ||
- strcmp(arg, "-classpath") == 0)
- && i < argc - 1) {
- *nargv++ = arg;
- *nargv++ = (char *) JLI_WildcardExpandClasspath(argv[i+1]);
- i++;
- continue;
- }
-#endif
- }
- *nargv++ = arg;
- }
- *nargv = 0;
-}
-
-/*
- * For our tools, we try to add 3 VM options:
- * -Denv.class.path=<envcp>
- * -Dapplication.home=<apphome>
- * -Djava.class.path=<appcp>
- * <envcp> is the user's setting of CLASSPATH -- for instance the user
- * tells javac where to find binary classes through this environment
- * variable. Notice that users will be able to compile against our
- * tools classes (sun.tools.javac.Main) only if they explicitly add
- * tools.jar to CLASSPATH.
- * <apphome> is the directory where the application is installed.
- * <appcp> is the classpath to where our apps' classfiles are.
- */
-static jboolean
-AddApplicationOptions()
-{
- const int NUM_APP_CLASSPATH = (sizeof(app_classpath) / sizeof(char *));
- char *envcp, *appcp, *apphome;
- char home[MAXPATHLEN]; /* application home */
- char separator[] = { PATH_SEPARATOR, '\0' };
- int size, i;
- int strlenHome;
-
- {
- const char *s = getenv("CLASSPATH");
- if (s) {
- s = (char *) JLI_WildcardExpandClasspath(s);
- /* 40 for -Denv.class.path= */
- envcp = (char *)JLI_MemAlloc(strlen(s) + 40);
- sprintf(envcp, "-Denv.class.path=%s", s);
- AddOption(envcp, NULL);
- }
- }
-
- if (!GetApplicationHome(home, sizeof(home))) {
- ReportErrorMessage("Can't determine application home", JNI_TRUE);
- return JNI_FALSE;
- }
-
- /* 40 for '-Dapplication.home=' */
- apphome = (char *)JLI_MemAlloc(strlen(home) + 40);
- sprintf(apphome, "-Dapplication.home=%s", home);
- AddOption(apphome, NULL);
-
- /* How big is the application's classpath? */
- size = 40; /* 40: "-Djava.class.path=" */
- strlenHome = (int)strlen(home);
- for (i = 0; i < NUM_APP_CLASSPATH; i++) {
- size += strlenHome + (int)strlen(app_classpath[i]) + 1; /* 1: separator */
- }
- appcp = (char *)JLI_MemAlloc(size + 1);
- strcpy(appcp, "-Djava.class.path=");
- for (i = 0; i < NUM_APP_CLASSPATH; i++) {
- strcat(appcp, home); /* c:\program files\myapp */
- strcat(appcp, app_classpath[i]); /* \lib\myapp.jar */
- strcat(appcp, separator); /* ; */
- }
- appcp[strlen(appcp)-1] = '\0'; /* remove trailing path separator */
- AddOption(appcp, NULL);
- return JNI_TRUE;
-}
-#endif /* JAVA_ARGS */
-
-/*
- * inject the -Dsun.java.command pseudo property into the args structure
- * this pseudo property is used in the HotSpot VM to expose the
- * Java class name and arguments to the main method to the VM. The
- * HotSpot VM uses this pseudo property to store the Java class name
- * (or jar file name) and the arguments to the class's main method
- * to the instrumentation memory region. The sun.java.command pseudo
- * property is not exported by HotSpot to the Java layer.
- */
-void
-SetJavaCommandLineProp(char *classname, char *jarfile,
- int argc, char **argv)
-{
-
- int i = 0;
- size_t len = 0;
- char* javaCommand = NULL;
- char* dashDstr = "-Dsun.java.command=";
-
- if (classname == NULL && jarfile == NULL) {
- /* unexpected, one of these should be set. just return without
- * setting the property
- */
- return;
- }
-
- /* if the class name is not set, then use the jarfile name */
- if (classname == NULL) {
- classname = jarfile;
- }
-
- /* determine the amount of memory to allocate assuming
- * the individual components will be space separated
- */
- len = strlen(classname);
- for (i = 0; i < argc; i++) {
- len += strlen(argv[i]) + 1;
- }
-
- /* allocate the memory */
- javaCommand = (char*) JLI_MemAlloc(len + strlen(dashDstr) + 1);
-
- /* build the -D string */
- *javaCommand = '\0';
- strcat(javaCommand, dashDstr);
- strcat(javaCommand, classname);
-
- for (i = 0; i < argc; i++) {
- /* the components of the string are space separated. In
- * the case of embedded white space, the relationship of
- * the white space separated components to their true
- * positional arguments will be ambiguous. This issue may
- * be addressed in a future release.
- */
- strcat(javaCommand, " ");
- strcat(javaCommand, argv[i]);
- }
-
- AddOption(javaCommand, NULL);
-}
-
-/*
- * JVM would like to know if it's created by a standard Sun launcher, or by
- * user native application, the following property indicates the former.
- */
-void SetJavaLauncherProp() {
- AddOption("-Dsun.java.launcher=" LAUNCHER_TYPE, NULL);
-}
-
-/*
- * Prints the version information from the java.version and other properties.
- */
-static void
-PrintJavaVersion(JNIEnv *env)
-{
- jclass ver;
- jmethodID print;
-
- NULL_CHECK(ver = (*env)->FindClass(env, "sun/misc/Version"));
- NULL_CHECK(print = (*env)->GetStaticMethodID(env, ver, "print", "()V"));
-
- (*env)->CallStaticVoidMethod(env, ver, print);
-}
-
-/*
- * Prints default usage message.
- */
-static void
-PrintUsage(void)
-{
-#ifndef GAMMA
- int i;
-#endif
-
- fprintf(stdout,
- "Usage: %s [-options] class [args...]\n"
- " (to execute a class)\n"
- " or %s [-options] -jar jarfile [args...]\n"
- " (to execute a jar file)\n"
- "\n"
- "where options include:\n",
- progname,
- progname);
-
-#ifndef GAMMA
- PrintMachineDependentOptions();
-
- if ((knownVMs[0].flag == VM_KNOWN) ||
- (knownVMs[0].flag == VM_IF_SERVER_CLASS)) {
- fprintf(stdout, " %s\t to select the \"%s\" VM\n",
- knownVMs[0].name, knownVMs[0].name+1);
- }
- for (i=1; i<knownVMsCount; i++) {
- if (knownVMs[i].flag == VM_KNOWN)
- fprintf(stdout, " %s\t to select the \"%s\" VM\n",
- knownVMs[i].name, knownVMs[i].name+1);
- }
- for (i=1; i<knownVMsCount; i++) {
- if (knownVMs[i].flag == VM_ALIASED_TO)
- fprintf(stdout, " %s\t is a synonym for "
- "the \"%s\" VM [deprecated]\n",
- knownVMs[i].name, knownVMs[i].alias+1);
- }
- /* The first known VM is the default */
- {
- const char* defaultVM = knownVMs[0].name+1;
- const char* punctuation = ".";
- const char* reason = "";
- if ((knownVMs[0].flag == VM_IF_SERVER_CLASS) &&
- (ServerClassMachine() == JNI_TRUE)) {
- defaultVM = knownVMs[0].server_class+1;
- punctuation = ", ";
- reason = "because you are running on a server-class machine.\n";
- }
- fprintf(stdout, " The default VM is %s%s\n",
- defaultVM, punctuation);
- fprintf(stdout, " %s\n",
- reason);
- }
-#endif /* ifndef GAMMA */
-
- fprintf(stdout,
-" -cp <class search path of directories and zip/jar files>\n"
-" -classpath <class search path of directories and zip/jar files>\n"
-" A %c separated list of directories, JAR archives,\n"
-" and ZIP archives to search for class files.\n"
-" -D<name>=<value>\n"
-" set a system property\n"
-" -verbose[:class|gc|jni]\n"
-" enable verbose output\n"
-" -version print product version and exit\n"
-" -version:<value>\n"
-" require the specified version to run\n"
-" -showversion print product version and continue\n"
-" -jre-restrict-search | -jre-no-restrict-search\n"
-" include/exclude user private JREs in the version search\n"
-" -? -help print this help message\n"
-" -X print help on non-standard options\n"
-" -ea[:<packagename>...|:<classname>]\n"
-" -enableassertions[:<packagename>...|:<classname>]\n"
-" enable assertions\n"
-" -da[:<packagename>...|:<classname>]\n"
-" -disableassertions[:<packagename>...|:<classname>]\n"
-" disable assertions\n"
-" -esa | -enablesystemassertions\n"
-" enable system assertions\n"
-" -dsa | -disablesystemassertions\n"
-" disable system assertions\n"
-" -agentlib:<libname>[=<options>]\n"
-" load native agent library <libname>, e.g. -agentlib:hprof\n"
-" see also, -agentlib:jdwp=help and -agentlib:hprof=help\n"
-" -agentpath:<pathname>[=<options>]\n"
-" load native agent library by full pathname\n"
-" -javaagent:<jarpath>[=<options>]\n"
-" load Java programming language agent, see java.lang.instrument\n"
-" -splash:<imagepath>\n"
-" show splash screen with specified image\n"
-
- ,PATH_SEPARATOR);
-}
-
-/*
- * Print usage message for -X options.
- */
-static jint
-PrintXUsage(const char *jvmpath)
-{
- /*
- A 32 bit cushion to prevent buffer overrun, noting that
- fopen(3C) may fail if the buffer exceeds MAXPATHLEN.
- */
- char path[MAXPATHLEN+32];
- char buf[128];
- size_t n;
- FILE *fp;
- static const char Xusage_txt[] = "/Xusage.txt";
-
- strcpy(path, jvmpath);
- /* Note the FILE_SEPARATOR is platform dependent */
- strcpy(strrchr(path, FILE_SEPARATOR), Xusage_txt);
- fp = fopen(path, "r");
- if (fp == 0) {
- fprintf(stderr, "Can't open %s\n", path);
- return 1;
- }
- while ((n = fread(buf, 1, sizeof(buf), fp)) != 0) {
- fwrite(buf, 1, n, stdout);
- }
- fclose(fp);
- return 0;
-}
-
-#ifndef GAMMA
-/*
- * Read the jvm.cfg file and fill the knownJVMs[] array.
- *
- * The functionality of the jvm.cfg file is subject to change without
- * notice and the mechanism will be removed in the future.
- *
- * The lexical structure of the jvm.cfg file is as follows:
- *
- * jvmcfg := { vmLine }
- * vmLine := knownLine
- * | aliasLine
- * | warnLine
- * | ignoreLine
- * | errorLine
- * | predicateLine
- * | commentLine
- * knownLine := flag "KNOWN" EOL
- * warnLine := flag "WARN" EOL
- * ignoreLine := flag "IGNORE" EOL
- * errorLine := flag "ERROR" EOL
- * aliasLine := flag "ALIASED_TO" flag EOL
- * predicateLine := flag "IF_SERVER_CLASS" flag EOL
- * commentLine := "#" text EOL
- * flag := "-" identifier
- *
- * The semantics are that when someone specifies a flag on the command line:
- * - if the flag appears on a knownLine, then the identifier is used as
- * the name of the directory holding the JVM library (the name of the JVM).
- * - if the flag appears as the first flag on an aliasLine, the identifier
- * of the second flag is used as the name of the JVM.
- * - if the flag appears on a warnLine, the identifier is used as the
- * name of the JVM, but a warning is generated.
- * - if the flag appears on an ignoreLine, the identifier is recognized as the
- * name of a JVM, but the identifier is ignored and the default vm used
- * - if the flag appears on an errorLine, an error is generated.
- * - if the flag appears as the first flag on a predicateLine, and
- * the machine on which you are running passes the predicate indicated,
- * then the identifier of the second flag is used as the name of the JVM,
- * otherwise the identifier of the first flag is used as the name of the JVM.
- * If no flag is given on the command line, the first vmLine of the jvm.cfg
- * file determines the name of the JVM.
- * PredicateLines are only interpreted on first vmLine of a jvm.cfg file,
- * since they only make sense if someone hasn't specified the name of the
- * JVM on the command line.
- *
- * The intent of the jvm.cfg file is to allow several JVM libraries to
- * be installed in different subdirectories of a single JRE installation,
- * for space-savings and convenience in testing.
- * The intent is explicitly not to provide a full aliasing or predicate
- * mechanism.
- */
-jint
-ReadKnownVMs(const char *jrepath, char * arch, jboolean speculative)
-{
- FILE *jvmCfg;
- char jvmCfgName[MAXPATHLEN+20];
- char line[MAXPATHLEN+20];
- int cnt = 0;
- int lineno = 0;
- jlong start, end;
- int vmType;
- char *tmpPtr;
- char *altVMName = NULL;
- char *serverClassVMName = NULL;
- static char *whiteSpace = " \t";
- if (_launcher_debug) {
- start = CounterGet();
- }
-
- strcpy(jvmCfgName, jrepath);
- strcat(jvmCfgName, FILESEP "lib" FILESEP);
- strcat(jvmCfgName, arch);
- strcat(jvmCfgName, FILESEP "jvm.cfg");
-
- jvmCfg = fopen(jvmCfgName, "r");
- if (jvmCfg == NULL) {
- if (!speculative) {
- ReportErrorMessage2("Error: could not open `%s'", jvmCfgName,
- JNI_TRUE);
- exit(1);
- } else {
- return -1;
- }
- }
- while (fgets(line, sizeof(line), jvmCfg) != NULL) {
- vmType = VM_UNKNOWN;
- lineno++;
- if (line[0] == '#')
- continue;
- if (line[0] != '-') {
- fprintf(stderr, "Warning: no leading - on line %d of `%s'\n",
- lineno, jvmCfgName);
- }
- if (cnt >= knownVMsLimit) {
- GrowKnownVMs(cnt);
- }
- line[strlen(line)-1] = '\0'; /* remove trailing newline */
- tmpPtr = line + strcspn(line, whiteSpace);
- if (*tmpPtr == 0) {
- fprintf(stderr, "Warning: missing VM type on line %d of `%s'\n",
- lineno, jvmCfgName);
- } else {
- /* Null-terminate this string for JLI_StringDup below */
- *tmpPtr++ = 0;
- tmpPtr += strspn(tmpPtr, whiteSpace);
- if (*tmpPtr == 0) {
- fprintf(stderr, "Warning: missing VM type on line %d of `%s'\n",
- lineno, jvmCfgName);
- } else {
- if (!strncmp(tmpPtr, "KNOWN", strlen("KNOWN"))) {
- vmType = VM_KNOWN;
- } else if (!strncmp(tmpPtr, "ALIASED_TO", strlen("ALIASED_TO"))) {
- tmpPtr += strcspn(tmpPtr, whiteSpace);
- if (*tmpPtr != 0) {
- tmpPtr += strspn(tmpPtr, whiteSpace);
- }
- if (*tmpPtr == 0) {
- fprintf(stderr, "Warning: missing VM alias on line %d of `%s'\n",
- lineno, jvmCfgName);
- } else {
- /* Null terminate altVMName */
- altVMName = tmpPtr;
- tmpPtr += strcspn(tmpPtr, whiteSpace);
- *tmpPtr = 0;
- vmType = VM_ALIASED_TO;
- }
- } else if (!strncmp(tmpPtr, "WARN", strlen("WARN"))) {
- vmType = VM_WARN;
- } else if (!strncmp(tmpPtr, "IGNORE", strlen("IGNORE"))) {
- vmType = VM_IGNORE;
- } else if (!strncmp(tmpPtr, "ERROR", strlen("ERROR"))) {
- vmType = VM_ERROR;
- } else if (!strncmp(tmpPtr,
- "IF_SERVER_CLASS",
- strlen("IF_SERVER_CLASS"))) {
- tmpPtr += strcspn(tmpPtr, whiteSpace);
- if (*tmpPtr != 0) {
- tmpPtr += strspn(tmpPtr, whiteSpace);
- }
- if (*tmpPtr == 0) {
- fprintf(stderr, "Warning: missing server class VM on line %d of `%s'\n",
- lineno, jvmCfgName);
- } else {
- /* Null terminate server class VM name */
- serverClassVMName = tmpPtr;
- tmpPtr += strcspn(tmpPtr, whiteSpace);
- *tmpPtr = 0;
- vmType = VM_IF_SERVER_CLASS;
- }
- } else {
- fprintf(stderr, "Warning: unknown VM type on line %d of `%s'\n",
- lineno, &jvmCfgName[0]);
- vmType = VM_KNOWN;
- }
- }
- }
-
- if (_launcher_debug)
- printf("jvm.cfg[%d] = ->%s<-\n", cnt, line);
- if (vmType != VM_UNKNOWN) {
- knownVMs[cnt].name = JLI_StringDup(line);
- knownVMs[cnt].flag = vmType;
- switch (vmType) {
- default:
- break;
- case VM_ALIASED_TO:
- knownVMs[cnt].alias = JLI_StringDup(altVMName);
- if (_launcher_debug) {
- printf(" name: %s vmType: %s alias: %s\n",
- knownVMs[cnt].name, "VM_ALIASED_TO", knownVMs[cnt].alias);
- }
- break;
- case VM_IF_SERVER_CLASS:
- knownVMs[cnt].server_class = JLI_StringDup(serverClassVMName);
- if (_launcher_debug) {
- printf(" name: %s vmType: %s server_class: %s\n",
- knownVMs[cnt].name, "VM_IF_SERVER_CLASS", knownVMs[cnt].server_class);
- }
- break;
- }
- cnt++;
- }
- }
- fclose(jvmCfg);
- knownVMsCount = cnt;
-
- if (_launcher_debug) {
- end = CounterGet();
- printf("%ld micro seconds to parse jvm.cfg\n",
- (long)(jint)Counter2Micros(end-start));
- }
-
- return cnt;
-}
-
-
-static void
-GrowKnownVMs(int minimum)
-{
- struct vmdesc* newKnownVMs;
- int newMax;
-
- newMax = (knownVMsLimit == 0 ? INIT_MAX_KNOWN_VMS : (2 * knownVMsLimit));
- if (newMax <= minimum) {
- newMax = minimum;
- }
- newKnownVMs = (struct vmdesc*) JLI_MemAlloc(newMax * sizeof(struct vmdesc));
- if (knownVMs != NULL) {
- memcpy(newKnownVMs, knownVMs, knownVMsLimit * sizeof(struct vmdesc));
- }
- JLI_MemFree(knownVMs);
- knownVMs = newKnownVMs;
- knownVMsLimit = newMax;
-}
-
-
-/* Returns index of VM or -1 if not found */
-static int
-KnownVMIndex(const char* name)
-{
- int i;
- if (strncmp(name, "-J", 2) == 0) name += 2;
- for (i = 0; i < knownVMsCount; i++) {
- if (!strcmp(name, knownVMs[i].name)) {
- return i;
- }
- }
- return -1;
-}
-
-static void
-FreeKnownVMs()
-{
- int i;
- for (i = 0; i < knownVMsCount; i++) {
- JLI_MemFree(knownVMs[i].name);
- knownVMs[i].name = NULL;
- }
- JLI_MemFree(knownVMs);
-}
-
-
-/*
- * Displays the splash screen according to the jar file name
- * and image file names stored in environment variables
- */
-static void
-ShowSplashScreen()
-{
- const char *jar_name = getenv(SPLASH_JAR_ENV_ENTRY);
- const char *file_name = getenv(SPLASH_FILE_ENV_ENTRY);
- int data_size;
- void *image_data;
- if (jar_name) {
- image_data = JLI_JarUnpackFile(jar_name, file_name, &data_size);
- if (image_data) {
- DoSplashInit();
- DoSplashLoadMemory(image_data, data_size);
- JLI_MemFree(image_data);
- }
- } else if (file_name) {
- DoSplashInit();
- DoSplashLoadFile(file_name);
- } else {
- return;
- }
- DoSplashSetFileJarName(file_name, jar_name);
-}
-
-#endif /* ifndef GAMMA */
--- a/hotspot/src/share/tools/launcher/java.h Tue May 14 17:33:07 2013 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,110 +0,0 @@
-/*
- * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * 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 _JAVA_H_
-#define _JAVA_H_
-
-/*
- * Get system specific defines.
- */
-#include "jni.h"
-#include "java_md.h"
-#include "jli_util.h"
-
-/*
- * Pointers to the needed JNI invocation API, initialized by LoadJavaVM.
- */
-typedef jint (JNICALL *CreateJavaVM_t)(JavaVM **pvm, void **env, void *args);
-typedef jint (JNICALL *GetDefaultJavaVMInitArgs_t)(void *args);
-
-typedef struct {
- CreateJavaVM_t CreateJavaVM;
- GetDefaultJavaVMInitArgs_t GetDefaultJavaVMInitArgs;
-} InvocationFunctions;
-
-/*
- * Prototypes for launcher functions in the system specific java_md.c.
- */
-
-jboolean
-LoadJavaVM(const char *jvmpath, InvocationFunctions *ifn);
-
-void
-GetXUsagePath(char *buf, jint bufsize);
-
-jboolean
-GetApplicationHome(char *buf, jint bufsize);
-
-const char *
-GetArch();
-
-void CreateExecutionEnvironment(int *_argc,
- char ***_argv,
- char jrepath[],
- jint so_jrepath,
- char jvmpath[],
- jint so_jvmpath,
- char **original_argv);
-
-/*
- * Report an error message to stderr or a window as appropriate. The
- * flag always is set to JNI_TRUE if message is to be reported to both
- * strerr and windows and set to JNI_FALSE if the message should only
- * be sent to a window.
- */
-void ReportErrorMessage(char * message, jboolean always);
-void ReportErrorMessage2(char * format, char * string, jboolean always);
-
-/*
- * Report an exception which terminates the vm to stderr or a window
- * as appropriate.
- */
-void ReportExceptionDescription(JNIEnv * env);
-
-jboolean RemovableMachineDependentOption(char * option);
-void PrintMachineDependentOptions();
-
-/*
- * Block current thread and continue execution in new thread
- */
-int ContinueInNewThread(int (JNICALL *continuation)(void *),
- jlong stack_size, void * args);
-
-/* sun.java.launcher.* platform properties. */
-void SetJavaLauncherPlatformProps(void);
-
-/*
- * Functions defined in java.c and used in java_md.c.
- */
-jint ReadKnownVMs(const char *jrepath, char * arch, jboolean speculative);
-char *CheckJvmType(int *argc, char ***argv, jboolean speculative);
-void AddOption(char *str, void *info);
-
-/*
- * Make launcher spit debug output.
- */
-extern jboolean _launcher_debug;
-
-#endif /* _JAVA_H_ */
--- a/hotspot/src/share/tools/launcher/jli_util.c Tue May 14 17:33:07 2013 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,89 +0,0 @@
-
-/*
- * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * 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 <stdio.h>
-#include <string.h>
-#include "jli_util.h"
-
-#ifdef GAMMA
-#ifdef TARGET_OS_FAMILY_windows
-#define strdup _strdup
-#endif
-#endif
-
-/*
- * Returns a pointer to a block of at least 'size' bytes of memory.
- * Prints error message and exits if the memory could not be allocated.
- */
-void *
-JLI_MemAlloc(size_t size)
-{
- void *p = malloc(size);
- if (p == 0) {
- perror("malloc");
- exit(1);
- }
- return p;
-}
-
-/*
- * Equivalent to realloc(size).
- * Prints error message and exits if the memory could not be reallocated.
- */
-void *
-JLI_MemRealloc(void *ptr, size_t size)
-{
- void *p = realloc(ptr, size);
- if (p == 0) {
- perror("realloc");
- exit(1);
- }
- return p;
-}
-
-/*
- * Wrapper over strdup(3C) which prints an error message and exits if memory
- * could not be allocated.
- */
-char *
-JLI_StringDup(const char *s1)
-{
- char *s = strdup(s1);
- if (s == NULL) {
- perror("strdup");
- exit(1);
- }
- return s;
-}
-
-/*
- * Very equivalent to free(ptr).
- * Here to maintain pairing with the above routines.
- */
-void
-JLI_MemFree(void *ptr)
-{
- free(ptr);
-}
--- a/hotspot/src/share/tools/launcher/jli_util.h Tue May 14 17:33:07 2013 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,35 +0,0 @@
-/*
- * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * 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 _JLI_UTIL_H
-#define _JLI_UTIL_H
-
-#include <stdlib.h>
-
-void *JLI_MemAlloc(size_t size);
-void *JLI_MemRealloc(void *ptr, size_t size);
-char *JLI_StringDup(const char *s1);
-void JLI_MemFree(void *ptr);
-
-#endif /* _JLI_UTIL_H */
--- a/hotspot/src/share/tools/launcher/wildcard.c Tue May 14 17:33:07 2013 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,496 +0,0 @@
-/*
- * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * 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.
- *
- */
-
-/*
- * Class-Path Wildcards
- *
- * The syntax for wildcards is a single asterisk. The class path
- * foo/"*", e.g., loads all jar files in the directory named foo.
- * (This requires careful quotation when used in shell scripts.)
- *
- * Only files whose names end in .jar or .JAR are matched.
- * Files whose names end in .zip, or which have a particular
- * magic number, regardless of filename extension, are not
- * matched.
- *
- * Files are considered regardless of whether or not they are
- * "hidden" in the UNIX sense, i.e., have names beginning with '.'.
- *
- * A wildcard only matches jar files, not class files in the same
- * directory. If you want to load both class files and jar files from
- * a single directory foo then you can say foo:foo/"*", or foo/"*":foo
- * if you want the jar files to take precedence.
- *
- * Subdirectories are not searched recursively, i.e., foo/"*" only
- * looks for jar files in foo, not in foo/bar, foo/baz, etc.
- *
- * Expansion of wildcards is done early, prior to the invocation of a
- * program's main method, rather than late, during the class-loading
- * process itself. Each element of the input class path containing a
- * wildcard is replaced by the (possibly empty) sequence of elements
- * generated by enumerating the jar files in the named directory. If
- * the directory foo contains a.jar, b.jar, and c.jar,
- * e.g., then the class path foo/"*" is expanded into
- * foo/a.jar:foo/b.jar:foo/c.jar, and that string would be the value
- * of the system property java.class.path.
- *
- * The order in which the jar files in a directory are enumerated in
- * the expanded class path is not specified and may vary from platform
- * to platform and even from moment to moment on the same machine. A
- * well-constructed application should not depend upon any particular
- * order. If a specific order is required then the jar files can be
- * enumerated explicitly in the class path.
- *
- * The CLASSPATH environment variable is not treated any differently
- * from the -classpath (equiv. -cp) command-line option,
- * i.e. wildcards are honored in all these cases.
- *
- * Class-path wildcards are not honored in the Class-Path jar-manifest
- * header.
- *
- * Class-path wildcards are honored not only by the Java launcher but
- * also by most other command-line tools that accept class paths, and
- * in particular by javac and javadoc.
- *
- * Class-path wildcards are not honored in any other kind of path, and
- * especially not in the bootstrap class path, which is a mere
- * artifact of our implementation and not something that developers
- * should use.
- *
- * Classpath wildcards are only expanded in the Java launcher code,
- * supporting the use of wildcards on the command line and in the
- * CLASSPATH environment variable. We do not support the use of
- * wildcards by applications that embed the JVM.
- */
-
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/types.h>
-#include "java.h" /* Strictly for PATH_SEPARATOR/FILE_SEPARATOR */
-#include "jli_util.h"
-
-#ifdef _WIN32
-#include <windows.h>
-#else /* Unix */
-#include <unistd.h>
-#include <dirent.h>
-#endif /* Unix */
-
-static int
-exists(const char* filename)
-{
-#ifdef _WIN32
- return _access(filename, 0) == 0;
-#else
- return access(filename, F_OK) == 0;
-#endif
-}
-
-#define NEW_(TYPE) ((TYPE) JLI_MemAlloc(sizeof(struct TYPE##_)))
-
-/*
- * Wildcard directory iteration.
- * WildcardIterator_for(wildcard) returns an iterator.
- * Each call to that iterator's next() method returns the basename
- * of an entry in the wildcard's directory. The basename's memory
- * belongs to the iterator. The caller is responsible for prepending
- * the directory name and file separator, if necessary.
- * When done with the iterator, call the close method to clean up.
- */
-typedef struct WildcardIterator_* WildcardIterator;
-
-#ifdef _WIN32
-struct WildcardIterator_
-{
- HANDLE handle;
- char *firstFile; /* Stupid FindFirstFile...FindNextFile */
-};
-
-static WildcardIterator
-WildcardIterator_for(const char *wildcard)
-{
- WIN32_FIND_DATA find_data;
- WildcardIterator it = NEW_(WildcardIterator);
- HANDLE handle = FindFirstFile(wildcard, &find_data);
- if (handle == INVALID_HANDLE_VALUE)
- return NULL;
- it->handle = handle;
- it->firstFile = find_data.cFileName;
- return it;
-}
-
-static char *
-WildcardIterator_next(WildcardIterator it)
-{
- WIN32_FIND_DATA find_data;
- if (it->firstFile != NULL) {
- char *firstFile = it->firstFile;
- it->firstFile = NULL;
- return firstFile;
- }
- return FindNextFile(it->handle, &find_data)
- ? find_data.cFileName : NULL;
-}
-
-static void
-WildcardIterator_close(WildcardIterator it)
-{
- if (it) {
- FindClose(it->handle);
- JLI_MemFree(it->firstFile);
- JLI_MemFree(it);
- }
-}
-
-#else /* Unix */
-struct WildcardIterator_
-{
- DIR *dir;
-};
-
-static WildcardIterator
-WildcardIterator_for(const char *wildcard)
-{
- DIR *dir;
- int wildlen = strlen(wildcard);
- if (wildlen < 2) {
- dir = opendir(".");
- } else {
- char *dirname = JLI_StringDup(wildcard);
- dirname[wildlen - 1] = '\0';
- dir = opendir(dirname);
- JLI_MemFree(dirname);
- }
- if (dir == NULL)
- return NULL;
- else {
- WildcardIterator it = NEW_(WildcardIterator);
- it->dir = dir;
- return it;
- }
-}
-
-static char *
-WildcardIterator_next(WildcardIterator it)
-{
- struct dirent* dirp = readdir(it->dir);
- return dirp ? dirp->d_name : NULL;
-}
-
-static void
-WildcardIterator_close(WildcardIterator it)
-{
- if (it) {
- closedir(it->dir);
- JLI_MemFree(it);
- }
-}
-#endif /* Unix */
-
-static int
-equal(const char *s1, const char *s2)
-{
- return strcmp(s1, s2) == 0;
-}
-
-/*
- * FileList ADT - a dynamic list of C filenames
- */
-struct FileList_
-{
- char **files;
- int size;
- int capacity;
-};
-typedef struct FileList_ *FileList;
-
-static FileList
-FileList_new(int capacity)
-{
- FileList fl = NEW_(FileList);
- fl->capacity = capacity;
- fl->files = (char **) JLI_MemAlloc(capacity * sizeof(fl->files[0]));
- fl->size = 0;
- return fl;
-}
-
-#ifdef DEBUG_WILDCARD
-static void
-FileList_print(FileList fl)
-{
- int i;
- putchar('[');
- for (i = 0; i < fl->size; i++) {
- if (i > 0) printf(", ");
- printf("\"%s\"",fl->files[i]);
- }
- putchar(']');
-}
-#endif
-
-static void
-FileList_free(FileList fl)
-{
- if (fl) {
- if (fl->files) {
- int i;
- for (i = 0; i < fl->size; i++)
- JLI_MemFree(fl->files[i]);
- JLI_MemFree(fl->files);
- }
- JLI_MemFree(fl);
- }
-}
-
-static void
-FileList_ensureCapacity(FileList fl, int capacity)
-{
- if (fl->capacity < capacity) {
- while (fl->capacity < capacity)
- fl->capacity *= 2;
- fl->files = JLI_MemRealloc(fl->files,
- fl->capacity * sizeof(fl->files[0]));
- }
-}
-
-static void
-FileList_add(FileList fl, char *file)
-{
- FileList_ensureCapacity(fl, fl->size+1);
- fl->files[fl->size++] = file;
-}
-
-static void
-FileList_addSubstring(FileList fl, const char *beg, int len)
-{
- char *filename = (char *) JLI_MemAlloc(len+1);
- memcpy(filename, beg, len);
- filename[len] = '\0';
- FileList_ensureCapacity(fl, fl->size+1);
- fl->files[fl->size++] = filename;
-}
-
-static char *
-FileList_join(FileList fl, char sep)
-{
- int i;
- int size;
- char *path;
- char *p;
- for (i = 0, size = 1; i < fl->size; i++)
- size += strlen(fl->files[i]) + 1;
-
- path = JLI_MemAlloc(size);
-
- for (i = 0, p = path; i < fl->size; i++) {
- int len = strlen(fl->files[i]);
- if (i > 0) *p++ = sep;
- memcpy(p, fl->files[i], len);
- p += len;
- }
- *p = '\0';
-
- return path;
-}
-
-static FileList
-FileList_split(const char *path, char sep)
-{
- const char *p, *q;
- int len = strlen(path);
- int count;
- FileList fl;
- for (count = 1, p = path; p < path + len; p++)
- count += (*p == sep);
- fl = FileList_new(count);
- for (p = path;;) {
- for (q = p; q <= path + len; q++) {
- if (*q == sep || *q == '\0') {
- FileList_addSubstring(fl, p, q - p);
- if (*q == '\0')
- return fl;
- p = q + 1;
- }
- }
- }
-}
-
-static int
-isJarFileName(const char *filename)
-{
- int len = strlen(filename);
- return (len >= 4) &&
- (filename[len - 4] == '.') &&
- (equal(filename + len - 3, "jar") ||
- equal(filename + len - 3, "JAR")) &&
- /* Paranoia: Maybe filename is "DIR:foo.jar" */
- (strchr(filename, PATH_SEPARATOR) == NULL);
-}
-
-static char *
-wildcardConcat(const char *wildcard, const char *basename)
-{
- int wildlen = strlen(wildcard);
- int baselen = strlen(basename);
- char *filename = (char *) JLI_MemAlloc(wildlen + baselen);
- /* Replace the trailing '*' with basename */
- memcpy(filename, wildcard, wildlen-1);
- memcpy(filename+wildlen-1, basename, baselen+1);
- return filename;
-}
-
-static FileList
-wildcardFileList(const char *wildcard)
-{
- const char *basename;
- FileList fl = FileList_new(16);
- WildcardIterator it = WildcardIterator_for(wildcard);
- if (it == NULL) {
- FileList_free(fl);
- return NULL;
- }
- while ((basename = WildcardIterator_next(it)) != NULL)
- if (isJarFileName(basename))
- FileList_add(fl, wildcardConcat(wildcard, basename));
- WildcardIterator_close(it);
- return fl;
-}
-
-static int
-isWildcard(const char *filename)
-{
- int len = strlen(filename);
- return (len > 0) &&
- (filename[len - 1] == '*') &&
- (len == 1 || IS_FILE_SEPARATOR(filename[len - 2])) &&
- (! exists(filename));
-}
-
-static void
-FileList_expandWildcards(FileList fl)
-{
- int i, j;
- for (i = 0; i < fl->size; i++) {
- if (isWildcard(fl->files[i])) {
- FileList expanded = wildcardFileList(fl->files[i]);
- if (expanded != NULL && expanded->size > 0) {
- JLI_MemFree(fl->files[i]);
- FileList_ensureCapacity(fl, fl->size + expanded->size);
- for (j = fl->size - 1; j >= i+1; j--)
- fl->files[j+expanded->size-1] = fl->files[j];
- for (j = 0; j < expanded->size; j++)
- fl->files[i+j] = expanded->files[j];
- i += expanded->size - 1;
- fl->size += expanded->size - 1;
- /* fl expropriates expanded's elements. */
- expanded->size = 0;
- }
- FileList_free(expanded);
- }
- }
-}
-
-const char *
-JLI_WildcardExpandClasspath(const char *classpath)
-{
- char *expanded;
- FileList fl;
-
- if (strchr(classpath, '*') == NULL)
- return classpath;
- fl = FileList_split(classpath, PATH_SEPARATOR);
- FileList_expandWildcards(fl);
- expanded = FileList_join(fl, PATH_SEPARATOR);
- FileList_free(fl);
- if (getenv("_JAVA_LAUNCHER_DEBUG") != 0)
- printf("Expanded wildcards:\n"
- " before: \"%s\"\n"
- " after : \"%s\"\n",
- classpath, expanded);
- return expanded;
-}
-
-#ifdef DEBUG_WILDCARD
-static void
-wildcardExpandArgv(const char ***argv)
-{
- int i;
- for (i = 0; (*argv)[i]; i++) {
- if (equal((*argv)[i], "-cp") ||
- equal((*argv)[i], "-classpath")) {
- i++;
- (*argv)[i] = wildcardExpandClasspath((*argv)[i]);
- }
- }
-}
-
-static void
-debugPrintArgv(char *argv[])
-{
- int i;
- putchar('[');
- for (i = 0; argv[i]; i++) {
- if (i > 0) printf(", ");
- printf("\"%s\"", argv[i]);
- }
- printf("]\n");
-}
-
-int
-main(int argc, char *argv[])
-{
- argv[0] = "java";
- wildcardExpandArgv((const char***)&argv);
- debugPrintArgv(argv);
- /* execvp("java", argv); */
- return 0;
-}
-#endif /* DEBUG_WILDCARD */
-
-/* Cute little perl prototype implementation....
-
-my $sep = ($^O =~ /^(Windows|cygwin)/) ? ";" : ":";
-
-sub expand($) {
- opendir DIR, $_[0] or return $_[0];
- join $sep, map {"$_[0]/$_"} grep {/\.(jar|JAR)$/} readdir DIR;
-}
-
-sub munge($) {
- join $sep,
- map {(! -r $_ and s/[\/\\]+\*$//) ? expand $_ : $_} split $sep, $_[0];
-}
-
-for (my $i = 0; $i < @ARGV - 1; $i++) {
- $ARGV[$i+1] = munge $ARGV[$i+1] if $ARGV[$i] =~ /^-c(p|lasspath)$/;
-}
-
-$ENV{CLASSPATH} = munge $ENV{CLASSPATH} if exists $ENV{CLASSPATH};
-@ARGV = ("java", @ARGV);
-print "@ARGV\n";
-exec @ARGV;
-
-*/
--- a/hotspot/src/share/tools/launcher/wildcard.h Tue May 14 17:33:07 2013 +0000
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,34 +0,0 @@
-/*
- * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * 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 WILDCARD_H_
-#define WILDCARD_H_
-
-#ifdef EXPAND_CLASSPATH_WILDCARDS
-const char *JLI_WildcardExpandClasspath(const char *classpath);
-#else
-#define JLI_WildcardExpandClasspath(s) (s)
-#endif
-
-#endif /* include guard */
--- a/hotspot/src/share/vm/ci/ciInstanceKlass.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/ci/ciInstanceKlass.cpp Thu May 16 13:47:55 2013 -0700
@@ -211,13 +211,42 @@
// ------------------------------------------------------------------
// ciInstanceKlass::uses_default_loader
-bool ciInstanceKlass::uses_default_loader() {
+bool ciInstanceKlass::uses_default_loader() const {
// Note: We do not need to resolve the handle or enter the VM
// in order to test null-ness.
return _loader == NULL;
}
// ------------------------------------------------------------------
+
+/**
+ * Return basic type of boxed value for box klass or T_OBJECT if not.
+ */
+BasicType ciInstanceKlass::box_klass_type() const {
+ if (uses_default_loader() && is_loaded()) {
+ return SystemDictionary::box_klass_type(get_Klass());
+ } else {
+ return T_OBJECT;
+ }
+}
+
+/**
+ * Is this boxing klass?
+ */
+bool ciInstanceKlass::is_box_klass() const {
+ return is_java_primitive(box_klass_type());
+}
+
+/**
+ * Is this boxed value offset?
+ */
+bool ciInstanceKlass::is_boxed_value_offset(int offset) const {
+ BasicType bt = box_klass_type();
+ return is_java_primitive(bt) &&
+ (offset == java_lang_boxing_object::value_offset_in_bytes(bt));
+}
+
+// ------------------------------------------------------------------
// ciInstanceKlass::is_in_package
//
// Is this klass in the given package?
--- a/hotspot/src/share/vm/ci/ciInstanceKlass.hpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/ci/ciInstanceKlass.hpp Thu May 16 13:47:55 2013 -0700
@@ -217,10 +217,14 @@
ciInstanceKlass* implementor();
// Is the defining class loader of this class the default loader?
- bool uses_default_loader();
+ bool uses_default_loader() const;
bool is_java_lang_Object() const;
+ BasicType box_klass_type() const;
+ bool is_box_klass() const;
+ bool is_boxed_value_offset(int offset) const;
+
// Is this klass in the given package?
bool is_in_package(const char* packagename) {
return is_in_package(packagename, (int) strlen(packagename));
--- a/hotspot/src/share/vm/ci/ciMethod.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/ci/ciMethod.cpp Thu May 16 13:47:55 2013 -0700
@@ -1179,6 +1179,44 @@
bool ciMethod::is_accessor () const { FETCH_FLAG_FROM_VM(is_accessor); }
bool ciMethod::is_initializer () const { FETCH_FLAG_FROM_VM(is_initializer); }
+bool ciMethod::is_boxing_method() const {
+ if (holder()->is_box_klass()) {
+ switch (intrinsic_id()) {
+ case vmIntrinsics::_Boolean_valueOf:
+ case vmIntrinsics::_Byte_valueOf:
+ case vmIntrinsics::_Character_valueOf:
+ case vmIntrinsics::_Short_valueOf:
+ case vmIntrinsics::_Integer_valueOf:
+ case vmIntrinsics::_Long_valueOf:
+ case vmIntrinsics::_Float_valueOf:
+ case vmIntrinsics::_Double_valueOf:
+ return true;
+ default:
+ return false;
+ }
+ }
+ return false;
+}
+
+bool ciMethod::is_unboxing_method() const {
+ if (holder()->is_box_klass()) {
+ switch (intrinsic_id()) {
+ case vmIntrinsics::_booleanValue:
+ case vmIntrinsics::_byteValue:
+ case vmIntrinsics::_charValue:
+ case vmIntrinsics::_shortValue:
+ case vmIntrinsics::_intValue:
+ case vmIntrinsics::_longValue:
+ case vmIntrinsics::_floatValue:
+ case vmIntrinsics::_doubleValue:
+ return true;
+ default:
+ return false;
+ }
+ }
+ return false;
+}
+
BCEscapeAnalyzer *ciMethod::get_bcea() {
#ifdef COMPILER2
if (_bcea == NULL) {
--- a/hotspot/src/share/vm/ci/ciMethod.hpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/ci/ciMethod.hpp Thu May 16 13:47:55 2013 -0700
@@ -298,6 +298,8 @@
bool is_initializer () const;
bool can_be_statically_bound() const { return _can_be_statically_bound; }
void dump_replay_data(outputStream* st);
+ bool is_boxing_method() const;
+ bool is_unboxing_method() const;
// Print the bytecodes of this method.
void print_codes_on(outputStream* st);
--- a/hotspot/src/share/vm/classfile/classFileParser.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/classfile/classFileParser.cpp Thu May 16 13:47:55 2013 -0700
@@ -3028,7 +3028,7 @@
}
-#ifndef PRODUCT
+#ifdef ASSERT
static void parseAndPrintGenericSignatures(
instanceKlassHandle this_klass, TRAPS) {
assert(ParseAllGenericSignatures == true, "Shouldn't call otherwise");
@@ -3053,7 +3053,7 @@
}
}
}
-#endif // ndef PRODUCT
+#endif // def ASSERT
instanceKlassHandle ClassFileParser::parse_super_class(int super_class_index,
--- a/hotspot/src/share/vm/classfile/vmSymbols.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/classfile/vmSymbols.cpp Thu May 16 13:47:55 2013 -0700
@@ -49,7 +49,7 @@
}
}
-#ifndef PRODUCT
+#ifdef ASSERT
#define VM_SYMBOL_ENUM_NAME_BODY(name, string) #name "\0"
static const char* vm_symbol_enum_names =
VM_SYMBOLS_DO(VM_SYMBOL_ENUM_NAME_BODY, VM_ALIAS_IGNORE)
@@ -64,7 +64,7 @@
}
return string;
}
-#endif //PRODUCT
+#endif //ASSERT
// Put all the VM symbol strings in one place.
// Makes for a more compact libjvm.
--- a/hotspot/src/share/vm/classfile/vmSymbols.hpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/classfile/vmSymbols.hpp Thu May 16 13:47:55 2013 -0700
@@ -68,7 +68,7 @@
template(java_lang_Float, "java/lang/Float") \
template(java_lang_Double, "java/lang/Double") \
template(java_lang_Byte, "java/lang/Byte") \
- template(java_lang_Byte_Cache, "java/lang/Byte$ByteCache") \
+ template(java_lang_Byte_ByteCache, "java/lang/Byte$ByteCache") \
template(java_lang_Short, "java/lang/Short") \
template(java_lang_Short_ShortCache, "java/lang/Short$ShortCache") \
template(java_lang_Integer, "java/lang/Integer") \
--- a/hotspot/src/share/vm/compiler/compileBroker.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/compiler/compileBroker.cpp Thu May 16 13:47:55 2013 -0700
@@ -1854,8 +1854,10 @@
tty->print("%7d ", (int) tty->time_stamp().milliseconds()); // print timestamp
tty->print("%4d ", compile_id); // print compilation number
tty->print("%s ", (is_osr ? "%" : " "));
- int code_size = (task->code() == NULL) ? 0 : task->code()->total_size();
- tty->print_cr("size: %d time: %d inlined: %d bytes", code_size, (int)time.milliseconds(), task->num_inlined_bytecodes());
+ if (task->code() != NULL) {
+ tty->print("size: %d(%d) ", task->code()->total_size(), task->code()->insts_size());
+ }
+ tty->print_cr("time: %d inlined: %d bytes", (int)time.milliseconds(), task->num_inlined_bytecodes());
}
if (PrintCodeCacheOnCompilation)
--- a/hotspot/src/share/vm/oops/method.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/oops/method.cpp Thu May 16 13:47:55 2013 -0700
@@ -832,7 +832,9 @@
assert(entry != NULL, "interpreter entry must be non-null");
// Sets both _i2i_entry and _from_interpreted_entry
set_interpreter_entry(entry);
- if (is_native() && !is_method_handle_intrinsic()) {
+
+ // Don't overwrite already registered native entries.
+ if (is_native() && !has_native_function()) {
set_native_function(
SharedRuntime::native_method_throw_unsatisfied_link_error_entry(),
!native_bind_event_is_interesting);
--- a/hotspot/src/share/vm/opto/bytecodeInfo.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/bytecodeInfo.cpp Thu May 16 13:47:55 2013 -0700
@@ -85,16 +85,35 @@
assert(!UseOldInlining, "do not use for old stuff");
}
+/**
+ * Return true when EA is ON and a java constructor is called or
+ * a super constructor is called from an inlined java constructor.
+ * Also return true for boxing methods.
+ */
static bool is_init_with_ea(ciMethod* callee_method,
ciMethod* caller_method, Compile* C) {
- // True when EA is ON and a java constructor is called or
- // a super constructor is called from an inlined java constructor.
- return C->do_escape_analysis() && EliminateAllocations &&
- ( callee_method->is_initializer() ||
- (caller_method->is_initializer() &&
- caller_method != C->method() &&
- caller_method->holder()->is_subclass_of(callee_method->holder()))
- );
+ if (!C->do_escape_analysis() || !EliminateAllocations) {
+ return false; // EA is off
+ }
+ if (callee_method->is_initializer()) {
+ return true; // constuctor
+ }
+ if (caller_method->is_initializer() &&
+ caller_method != C->method() &&
+ caller_method->holder()->is_subclass_of(callee_method->holder())) {
+ return true; // super constructor is called from inlined constructor
+ }
+ if (C->eliminate_boxing() && callee_method->is_boxing_method()) {
+ return true;
+ }
+ return false;
+}
+
+/**
+ * Force inlining unboxing accessor.
+ */
+static bool is_unboxing_method(ciMethod* callee_method, Compile* C) {
+ return C->eliminate_boxing() && callee_method->is_unboxing_method();
}
// positive filter: should callee be inlined?
@@ -144,6 +163,7 @@
// bump the max size if the call is frequent
if ((freq >= InlineFrequencyRatio) ||
(call_site_count >= InlineFrequencyCount) ||
+ is_unboxing_method(callee_method, C) ||
is_init_with_ea(callee_method, caller_method, C)) {
max_inline_size = C->freq_inline_size();
@@ -237,8 +257,25 @@
return false;
}
+ if (callee_method->should_not_inline()) {
+ set_msg("disallowed by CompilerOracle");
+ return true;
+ }
+
+#ifndef PRODUCT
+ if (ciReplay::should_not_inline(callee_method)) {
+ set_msg("disallowed by ciReplay");
+ return true;
+ }
+#endif
+
// Now perform checks which are heuristic
+ if (is_unboxing_method(callee_method, C)) {
+ // Inline unboxing methods.
+ return false;
+ }
+
if (!callee_method->force_inline()) {
if (callee_method->has_compiled_code() &&
callee_method->instructions_size() > InlineSmallCode) {
@@ -260,18 +297,6 @@
}
}
- if (callee_method->should_not_inline()) {
- set_msg("disallowed by CompilerOracle");
- return true;
- }
-
-#ifndef PRODUCT
- if (ciReplay::should_not_inline(callee_method)) {
- set_msg("disallowed by ciReplay");
- return true;
- }
-#endif
-
if (UseStringCache) {
// Do not inline StringCache::profile() method used only at the beginning.
if (callee_method->name() == ciSymbol::profile_name() &&
@@ -296,9 +321,8 @@
}
if (is_init_with_ea(callee_method, caller_method, C)) {
-
// Escape Analysis: inline all executed constructors
-
+ return false;
} else if (!callee_method->was_executed_more_than(MIN2(MinInliningThreshold,
CompileThreshold >> 1))) {
set_msg("executed < MinInliningThreshold times");
--- a/hotspot/src/share/vm/opto/c2_globals.hpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/c2_globals.hpp Thu May 16 13:47:55 2013 -0700
@@ -442,12 +442,15 @@
notproduct(bool, PrintEliminateLocks, false, \
"Print out when locks are eliminated") \
\
- diagnostic(bool, EliminateAutoBox, false, \
- "Private flag to control optimizations for autobox elimination") \
+ product(bool, EliminateAutoBox, true, \
+ "Control optimizations for autobox elimination") \
\
product(intx, AutoBoxCacheMax, 128, \
"Sets max value cached by the java.lang.Integer autobox cache") \
\
+ experimental(bool, AggressiveUnboxing, false, \
+ "Control optimizations for aggressive boxing elimination") \
+ \
product(bool, DoEscapeAnalysis, true, \
"Perform escape analysis") \
\
--- a/hotspot/src/share/vm/opto/c2compiler.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/c2compiler.cpp Thu May 16 13:47:55 2013 -0700
@@ -125,9 +125,10 @@
bool subsume_loads = SubsumeLoads;
bool do_escape_analysis = DoEscapeAnalysis &&
!env->jvmti_can_access_local_variables();
+ bool eliminate_boxing = EliminateAutoBox;
while (!env->failing()) {
// Attempt to compile while subsuming loads into machine instructions.
- Compile C(env, this, target, entry_bci, subsume_loads, do_escape_analysis);
+ Compile C(env, this, target, entry_bci, subsume_loads, do_escape_analysis, eliminate_boxing);
// Check result and retry if appropriate.
@@ -142,6 +143,12 @@
do_escape_analysis = false;
continue; // retry
}
+ if (C.has_boxed_value()) {
+ // Recompile without boxing elimination regardless failure reason.
+ assert(eliminate_boxing, "must make progress");
+ eliminate_boxing = false;
+ continue; // retry
+ }
// Pass any other failure reason up to the ciEnv.
// Note that serious, irreversible failures are already logged
// on the ciEnv via env->record_method_not_compilable().
--- a/hotspot/src/share/vm/opto/callGenerator.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/callGenerator.cpp Thu May 16 13:47:55 2013 -0700
@@ -134,7 +134,7 @@
kit.C->log()->elem("direct_call bci='%d'", jvms->bci());
}
- CallStaticJavaNode *call = new (kit.C) CallStaticJavaNode(tf(), target, method(), kit.bci());
+ CallStaticJavaNode *call = new (kit.C) CallStaticJavaNode(kit.C, tf(), target, method(), kit.bci());
_call_node = call; // Save the call node in case we need it later
if (!is_static) {
// Make an explicit receiver null_check as part of this call.
@@ -304,29 +304,34 @@
void LateInlineCallGenerator::do_late_inline() {
// Can't inline it
- if (call_node() == NULL || call_node()->outcnt() == 0 ||
- call_node()->in(0) == NULL || call_node()->in(0)->is_top()) {
+ CallStaticJavaNode* call = call_node();
+ if (call == NULL || call->outcnt() == 0 ||
+ call->in(0) == NULL || call->in(0)->is_top()) {
return;
}
- const TypeTuple *r = call_node()->tf()->domain();
+ const TypeTuple *r = call->tf()->domain();
for (int i1 = 0; i1 < method()->arg_size(); i1++) {
- if (call_node()->in(TypeFunc::Parms + i1)->is_top() && r->field_at(TypeFunc::Parms + i1) != Type::HALF) {
+ if (call->in(TypeFunc::Parms + i1)->is_top() && r->field_at(TypeFunc::Parms + i1) != Type::HALF) {
assert(Compile::current()->inlining_incrementally(), "shouldn't happen during parsing");
return;
}
}
- if (call_node()->in(TypeFunc::Memory)->is_top()) {
+ if (call->in(TypeFunc::Memory)->is_top()) {
assert(Compile::current()->inlining_incrementally(), "shouldn't happen during parsing");
return;
}
- CallStaticJavaNode* call = call_node();
+ Compile* C = Compile::current();
+ // Remove inlined methods from Compiler's lists.
+ if (call->is_macro()) {
+ C->remove_macro_node(call);
+ }
// Make a clone of the JVMState that appropriate to use for driving a parse
- Compile* C = Compile::current();
- JVMState* jvms = call->jvms()->clone_shallow(C);
+ JVMState* old_jvms = call->jvms();
+ JVMState* jvms = old_jvms->clone_shallow(C);
uint size = call->req();
SafePointNode* map = new (C) SafePointNode(size, jvms);
for (uint i1 = 0; i1 < size; i1++) {
@@ -340,16 +345,23 @@
map->set_req(TypeFunc::Memory, mem);
}
- // Make enough space for the expression stack and transfer the incoming arguments
- int nargs = method()->arg_size();
+ uint nargs = method()->arg_size();
+ // blow away old call arguments
+ Node* top = C->top();
+ for (uint i1 = 0; i1 < nargs; i1++) {
+ map->set_req(TypeFunc::Parms + i1, top);
+ }
jvms->set_map(map);
+
+ // Make enough space in the expression stack to transfer
+ // the incoming arguments and return value.
map->ensure_stack(jvms, jvms->method()->max_stack());
- if (nargs > 0) {
- for (int i1 = 0; i1 < nargs; i1++) {
- map->set_req(i1 + jvms->argoff(), call->in(TypeFunc::Parms + i1));
- }
+ for (uint i1 = 0; i1 < nargs; i1++) {
+ map->set_argument(jvms, i1, call->in(TypeFunc::Parms + i1));
}
+ // This check is done here because for_method_handle_inline() method
+ // needs jvms for inlined state.
if (!do_late_inline_check(jvms)) {
map->disconnect_inputs(NULL, C);
return;
@@ -480,6 +492,26 @@
return new LateInlineStringCallGenerator(method, inline_cg);
}
+class LateInlineBoxingCallGenerator : public LateInlineCallGenerator {
+
+ public:
+ LateInlineBoxingCallGenerator(ciMethod* method, CallGenerator* inline_cg) :
+ LateInlineCallGenerator(method, inline_cg) {}
+
+ virtual JVMState* generate(JVMState* jvms) {
+ Compile *C = Compile::current();
+ C->print_inlining_skip(this);
+
+ C->add_boxing_late_inline(this);
+
+ JVMState* new_jvms = DirectCallGenerator::generate(jvms);
+ return new_jvms;
+ }
+};
+
+CallGenerator* CallGenerator::for_boxing_late_inline(ciMethod* method, CallGenerator* inline_cg) {
+ return new LateInlineBoxingCallGenerator(method, inline_cg);
+}
//---------------------------WarmCallGenerator--------------------------------
// Internal class which handles initial deferral of inlining decisions.
--- a/hotspot/src/share/vm/opto/callGenerator.hpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/callGenerator.hpp Thu May 16 13:47:55 2013 -0700
@@ -125,6 +125,7 @@
static CallGenerator* for_late_inline(ciMethod* m, CallGenerator* inline_cg);
static CallGenerator* for_mh_late_inline(ciMethod* caller, ciMethod* callee, bool input_not_const);
static CallGenerator* for_string_late_inline(ciMethod* m, CallGenerator* inline_cg);
+ static CallGenerator* for_boxing_late_inline(ciMethod* m, CallGenerator* inline_cg);
// How to make a call but defer the decision whether to inline or not.
static CallGenerator* for_warm_call(WarmCallInfo* ci,
--- a/hotspot/src/share/vm/opto/callnode.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/callnode.cpp Thu May 16 13:47:55 2013 -0700
@@ -523,7 +523,9 @@
void JVMState::dump_on(outputStream* st) const {
- if (_map && !((uintptr_t)_map & 1)) {
+ bool print_map = _map && !((uintptr_t)_map & 1) &&
+ ((caller() == NULL) || (caller()->map() != _map));
+ if (print_map) {
if (_map->len() > _map->req()) { // _map->has_exceptions()
Node* ex = _map->in(_map->req()); // _map->next_exception()
// skip the first one; it's already being printed
@@ -532,7 +534,10 @@
ex->dump(1);
}
}
- _map->dump(2);
+ _map->dump(Verbose ? 2 : 1);
+ }
+ if (caller() != NULL) {
+ caller()->dump_on(st);
}
st->print("JVMS depth=%d loc=%d stk=%d arg=%d mon=%d scalar=%d end=%d mondepth=%d sp=%d bci=%d reexecute=%s method=",
depth(), locoff(), stkoff(), argoff(), monoff(), scloff(), endoff(), monitor_depth(), sp(), bci(), should_reexecute()?"true":"false");
@@ -546,9 +551,6 @@
_method->print_codes_on(bci(), bci()+1, st);
}
}
- if (caller() != NULL) {
- caller()->dump_on(st);
- }
}
// Extra way to dump a jvms from the debugger,
@@ -584,6 +586,15 @@
return n;
}
+/**
+ * Reset map for all callers
+ */
+void JVMState::set_map_deep(SafePointNode* map) {
+ for (JVMState* p = this; p->_caller != NULL; p = p->_caller) {
+ p->set_map(map);
+ }
+}
+
//=============================================================================
uint CallNode::cmp( const Node &n ) const
{ return _tf == ((CallNode&)n)._tf && _jvms == ((CallNode&)n)._jvms; }
@@ -663,17 +674,49 @@
// Determine whether the call could modify the field of the specified
// instance at the specified offset.
//
-bool CallNode::may_modify(const TypePtr *addr_t, PhaseTransform *phase) {
- const TypeOopPtr *adrInst_t = addr_t->isa_oopptr();
-
- // If not an OopPtr or not an instance type, assume the worst.
- // Note: currently this method is called only for instance types.
- if (adrInst_t == NULL || !adrInst_t->is_known_instance()) {
- return true;
+bool CallNode::may_modify(const TypeOopPtr *t_oop, PhaseTransform *phase) {
+ assert((t_oop != NULL), "sanity");
+ if (t_oop->is_known_instance()) {
+ // The instance_id is set only for scalar-replaceable allocations which
+ // are not passed as arguments according to Escape Analysis.
+ return false;
}
- // The instance_id is set only for scalar-replaceable allocations which
- // are not passed as arguments according to Escape Analysis.
- return false;
+ if (t_oop->is_ptr_to_boxed_value()) {
+ ciKlass* boxing_klass = t_oop->klass();
+ if (is_CallStaticJava() && as_CallStaticJava()->is_boxing_method()) {
+ // Skip unrelated boxing methods.
+ Node* proj = proj_out(TypeFunc::Parms);
+ if ((proj == NULL) || (phase->type(proj)->is_instptr()->klass() != boxing_klass)) {
+ return false;
+ }
+ }
+ if (is_CallJava() && as_CallJava()->method() != NULL) {
+ ciMethod* meth = as_CallJava()->method();
+ if (meth->is_accessor()) {
+ return false;
+ }
+ // May modify (by reflection) if an boxing object is passed
+ // as argument or returned.
+ if (returns_pointer() && (proj_out(TypeFunc::Parms) != NULL)) {
+ Node* proj = proj_out(TypeFunc::Parms);
+ const TypeInstPtr* inst_t = phase->type(proj)->isa_instptr();
+ if ((inst_t != NULL) && (!inst_t->klass_is_exact() ||
+ (inst_t->klass() == boxing_klass))) {
+ return true;
+ }
+ }
+ const TypeTuple* d = tf()->domain();
+ for (uint i = TypeFunc::Parms; i < d->cnt(); i++) {
+ const TypeInstPtr* inst_t = d->field_at(i)->isa_instptr();
+ if ((inst_t != NULL) && (!inst_t->klass_is_exact() ||
+ (inst_t->klass() == boxing_klass))) {
+ return true;
+ }
+ }
+ return false;
+ }
+ }
+ return true;
}
// Does this call have a direct reference to n other than debug information?
@@ -1020,6 +1063,7 @@
int scloff = jvms->scloff();
int endoff = jvms->endoff();
assert(endoff == (int)req(), "no other states or debug info after me");
+ assert(jvms->scl_size() == 0, "parsed code should not have scalar objects");
Node* top = Compile::current()->top();
for (uint i = 0; i < grow_by; i++) {
ins_req(monoff, top);
@@ -1035,6 +1079,7 @@
const int MonitorEdges = 2;
assert(JVMState::logMonitorEdges == exact_log2(MonitorEdges), "correct MonitorEdges");
assert(req() == jvms()->endoff(), "correct sizing");
+ assert((jvms()->scl_size() == 0), "parsed code should not have scalar objects");
int nextmon = jvms()->scloff();
if (GenerateSynchronizationCode) {
add_req(lock->box_node());
@@ -1050,6 +1095,7 @@
void SafePointNode::pop_monitor() {
// Delete last monitor from debug info
+ assert((jvms()->scl_size() == 0), "parsed code should not have scalar objects");
debug_only(int num_before_pop = jvms()->nof_monitors());
const int MonitorEdges = (1<<JVMState::logMonitorEdges);
int scloff = jvms()->scloff();
@@ -1154,6 +1200,7 @@
init_class_id(Class_Allocate);
init_flags(Flag_is_macro);
_is_scalar_replaceable = false;
+ _is_non_escaping = false;
Node *topnode = C->top();
init_req( TypeFunc::Control , ctrl );
@@ -1169,8 +1216,6 @@
}
//=============================================================================
-uint AllocateArrayNode::size_of() const { return sizeof(*this); }
-
Node* AllocateArrayNode::Ideal(PhaseGVN *phase, bool can_reshape) {
if (remove_dead_region(phase, can_reshape)) return this;
// Don't bother trying to transform a dead node
@@ -1235,6 +1280,8 @@
// - the narrow_length is 0
// - the narrow_length is not wider than length
assert(narrow_length_type == TypeInt::ZERO ||
+ length_type->is_con() && narrow_length_type->is_con() &&
+ (narrow_length_type->_hi <= length_type->_lo) ||
(narrow_length_type->_hi <= length_type->_hi &&
narrow_length_type->_lo >= length_type->_lo),
"narrow type must be narrower than length type");
--- a/hotspot/src/share/vm/opto/callnode.hpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/callnode.hpp Thu May 16 13:47:55 2013 -0700
@@ -49,6 +49,7 @@
class CallLeafNoFPNode;
class AllocateNode;
class AllocateArrayNode;
+class BoxLockNode;
class LockNode;
class UnlockNode;
class JVMState;
@@ -235,7 +236,6 @@
int loc_size() const { return stkoff() - locoff(); }
int stk_size() const { return monoff() - stkoff(); }
- int arg_size() const { return monoff() - argoff(); }
int mon_size() const { return scloff() - monoff(); }
int scl_size() const { return endoff() - scloff(); }
@@ -298,6 +298,7 @@
// Miscellaneous utility functions
JVMState* clone_deep(Compile* C) const; // recursively clones caller chain
JVMState* clone_shallow(Compile* C) const; // retains uncloned caller
+ void set_map_deep(SafePointNode *map);// reset map for all callers
#ifndef PRODUCT
void format(PhaseRegAlloc *regalloc, const Node *n, outputStream* st) const;
@@ -439,7 +440,7 @@
static bool needs_polling_address_input();
#ifndef PRODUCT
- virtual void dump_spec(outputStream *st) const;
+ virtual void dump_spec(outputStream *st) const;
#endif
};
@@ -554,10 +555,10 @@
virtual bool guaranteed_safepoint() { return true; }
// For macro nodes, the JVMState gets modified during expansion, so when cloning
// the node the JVMState must be cloned.
- virtual void clone_jvms() { } // default is not to clone
+ virtual void clone_jvms(Compile* C) { } // default is not to clone
// Returns true if the call may modify n
- virtual bool may_modify(const TypePtr *addr_t, PhaseTransform *phase);
+ virtual bool may_modify(const TypeOopPtr *t_oop, PhaseTransform *phase);
// Does this node have a use of n other than in debug information?
bool has_non_debug_use(Node *n);
// Returns the unique CheckCastPP of a call
@@ -630,9 +631,15 @@
virtual uint cmp( const Node &n ) const;
virtual uint size_of() const; // Size is bigger
public:
- CallStaticJavaNode(const TypeFunc* tf, address addr, ciMethod* method, int bci)
+ CallStaticJavaNode(Compile* C, const TypeFunc* tf, address addr, ciMethod* method, int bci)
: CallJavaNode(tf, addr, method, bci), _name(NULL) {
init_class_id(Class_CallStaticJava);
+ if (C->eliminate_boxing() && (method != NULL) && method->is_boxing_method()) {
+ init_flags(Flag_is_macro);
+ C->add_macro_node(this);
+ }
+ _is_scalar_replaceable = false;
+ _is_non_escaping = false;
}
CallStaticJavaNode(const TypeFunc* tf, address addr, const char* name, int bci,
const TypePtr* adr_type)
@@ -640,13 +647,31 @@
init_class_id(Class_CallStaticJava);
// This node calls a runtime stub, which often has narrow memory effects.
_adr_type = adr_type;
+ _is_scalar_replaceable = false;
+ _is_non_escaping = false;
}
- const char *_name; // Runtime wrapper name
+ const char *_name; // Runtime wrapper name
+
+ // Result of Escape Analysis
+ bool _is_scalar_replaceable;
+ bool _is_non_escaping;
// If this is an uncommon trap, return the request code, else zero.
int uncommon_trap_request() const;
static int extract_uncommon_trap_request(const Node* call);
+ bool is_boxing_method() const {
+ return is_macro() && (method() != NULL) && method()->is_boxing_method();
+ }
+ // Later inlining modifies the JVMState, so we need to clone it
+ // when the call node is cloned (because it is macro node).
+ virtual void clone_jvms(Compile* C) {
+ if ((jvms() != NULL) && is_boxing_method()) {
+ set_jvms(jvms()->clone_deep(C));
+ jvms()->set_map_deep(this);
+ }
+ }
+
virtual int Opcode() const;
#ifndef PRODUCT
virtual void dump_spec(outputStream *st) const;
@@ -748,12 +773,12 @@
ParmLimit
};
- static const TypeFunc* alloc_type() {
+ static const TypeFunc* alloc_type(const Type* t) {
const Type** fields = TypeTuple::fields(ParmLimit - TypeFunc::Parms);
fields[AllocSize] = TypeInt::POS;
fields[KlassNode] = TypeInstPtr::NOTNULL;
fields[InitialTest] = TypeInt::BOOL;
- fields[ALength] = TypeInt::INT; // length (can be a bad length)
+ fields[ALength] = t; // length (can be a bad length)
const TypeTuple *domain = TypeTuple::make(ParmLimit, fields);
@@ -766,21 +791,26 @@
return TypeFunc::make(domain, range);
}
- bool _is_scalar_replaceable; // Result of Escape Analysis
+ // Result of Escape Analysis
+ bool _is_scalar_replaceable;
+ bool _is_non_escaping;
virtual uint size_of() const; // Size is bigger
AllocateNode(Compile* C, const TypeFunc *atype, Node *ctrl, Node *mem, Node *abio,
Node *size, Node *klass_node, Node *initial_test);
// Expansion modifies the JVMState, so we need to clone it
- virtual void clone_jvms() {
- set_jvms(jvms()->clone_deep(Compile::current()));
+ virtual void clone_jvms(Compile* C) {
+ if (jvms() != NULL) {
+ set_jvms(jvms()->clone_deep(C));
+ jvms()->set_map_deep(this);
+ }
}
virtual int Opcode() const;
virtual uint ideal_reg() const { return Op_RegP; }
virtual bool guaranteed_safepoint() { return false; }
// allocations do not modify their arguments
- virtual bool may_modify(const TypePtr *addr_t, PhaseTransform *phase) { return false;}
+ virtual bool may_modify(const TypeOopPtr *t_oop, PhaseTransform *phase) { return false;}
// Pattern-match a possible usage of AllocateNode.
// Return null if no allocation is recognized.
@@ -815,10 +845,6 @@
// are defined in graphKit.cpp, which sets up the bidirectional relation.)
InitializeNode* initialization();
- // Return the corresponding storestore barrier (or null if none).
- // Walks out edges to find it...
- MemBarStoreStoreNode* storestore();
-
// Convenience for initialization->maybe_set_complete(phase)
bool maybe_set_complete(PhaseGVN* phase);
};
@@ -840,7 +866,6 @@
set_req(AllocateNode::ALength, count_val);
}
virtual int Opcode() const;
- virtual uint size_of() const; // Size is bigger
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
// Dig the length operand out of a array allocation site.
@@ -918,7 +943,7 @@
void set_nested() { _kind = Nested; set_eliminated_lock_counter(); }
// locking does not modify its arguments
- virtual bool may_modify(const TypePtr *addr_t, PhaseTransform *phase){ return false;}
+ virtual bool may_modify(const TypeOopPtr *t_oop, PhaseTransform *phase){ return false;}
#ifndef PRODUCT
void create_lock_counter(JVMState* s);
@@ -965,8 +990,11 @@
virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
// Expansion modifies the JVMState, so we need to clone it
- virtual void clone_jvms() {
- set_jvms(jvms()->clone_deep(Compile::current()));
+ virtual void clone_jvms(Compile* C) {
+ if (jvms() != NULL) {
+ set_jvms(jvms()->clone_deep(C));
+ jvms()->set_map_deep(this);
+ }
}
bool is_nested_lock_region(); // Is this Lock nested?
--- a/hotspot/src/share/vm/opto/cfgnode.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/cfgnode.cpp Thu May 16 13:47:55 2013 -0700
@@ -806,7 +806,7 @@
Node *in = ophi->in(i);
if (in == NULL || igvn->type(in) == Type::TOP)
continue;
- Node *opt = MemNode::optimize_simple_memory_chain(in, at, igvn);
+ Node *opt = MemNode::optimize_simple_memory_chain(in, t_oop, NULL, igvn);
PhiNode *optphi = opt->is_Phi() ? opt->as_Phi() : NULL;
if (optphi != NULL && optphi->adr_type() == TypePtr::BOTTOM) {
opt = node_map[optphi->_idx];
@@ -1921,7 +1921,7 @@
const TypePtr* at = adr_type();
for( uint i=1; i<req(); ++i ) {// For all paths in
Node *ii = in(i);
- Node *new_in = MemNode::optimize_memory_chain(ii, at, phase);
+ Node *new_in = MemNode::optimize_memory_chain(ii, at, NULL, phase);
if (ii != new_in ) {
set_req(i, new_in);
progress = this;
--- a/hotspot/src/share/vm/opto/compile.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/compile.cpp Thu May 16 13:47:55 2013 -0700
@@ -418,6 +418,7 @@
}
// clean up the late inline lists
remove_useless_late_inlines(&_string_late_inlines, useful);
+ remove_useless_late_inlines(&_boxing_late_inlines, useful);
remove_useless_late_inlines(&_late_inlines, useful);
debug_only(verify_graph_edges(true/*check for no_dead_code*/);)
}
@@ -485,6 +486,12 @@
tty->print_cr("** Bailout: Recompile without escape analysis **");
tty->print_cr("*********************************************************");
}
+ if (_eliminate_boxing != EliminateAutoBox && PrintOpto) {
+ // Recompiling without boxing elimination
+ tty->print_cr("*********************************************************");
+ tty->print_cr("** Bailout: Recompile without boxing elimination **");
+ tty->print_cr("*********************************************************");
+ }
if (env()->break_at_compile()) {
// Open the debugger when compiling this method.
tty->print("### Breaking when compiling: ");
@@ -601,7 +608,8 @@
// the continuation bci for on stack replacement.
-Compile::Compile( ciEnv* ci_env, C2Compiler* compiler, ciMethod* target, int osr_bci, bool subsume_loads, bool do_escape_analysis )
+Compile::Compile( ciEnv* ci_env, C2Compiler* compiler, ciMethod* target, int osr_bci,
+ bool subsume_loads, bool do_escape_analysis, bool eliminate_boxing )
: Phase(Compiler),
_env(ci_env),
_log(ci_env->log()),
@@ -617,6 +625,7 @@
_warm_calls(NULL),
_subsume_loads(subsume_loads),
_do_escape_analysis(do_escape_analysis),
+ _eliminate_boxing(eliminate_boxing),
_failure_reason(NULL),
_code_buffer("Compile::Fill_buffer"),
_orig_pc_slot(0),
@@ -638,6 +647,7 @@
_congraph(NULL),
_late_inlines(comp_arena(), 2, 0, NULL),
_string_late_inlines(comp_arena(), 2, 0, NULL),
+ _boxing_late_inlines(comp_arena(), 2, 0, NULL),
_late_inlines_pos(0),
_number_of_mh_late_inlines(0),
_inlining_progress(false),
@@ -906,6 +916,7 @@
_orig_pc_slot_offset_in_bytes(0),
_subsume_loads(true),
_do_escape_analysis(false),
+ _eliminate_boxing(false),
_failure_reason(NULL),
_code_buffer("Compile::Fill_buffer"),
_has_method_handle_invokes(false),
@@ -1016,6 +1027,7 @@
set_has_split_ifs(false);
set_has_loops(has_method() && method()->has_loops()); // first approximation
set_has_stringbuilder(false);
+ set_has_boxed_value(false);
_trap_can_recompile = false; // no traps emitted yet
_major_progress = true; // start out assuming good things will happen
set_has_unsafe_access(false);
@@ -1807,6 +1819,38 @@
_string_late_inlines.trunc_to(0);
}
+// Late inlining of boxing methods
+void Compile::inline_boxing_calls(PhaseIterGVN& igvn) {
+ if (_boxing_late_inlines.length() > 0) {
+ assert(has_boxed_value(), "inconsistent");
+
+ PhaseGVN* gvn = initial_gvn();
+ set_inlining_incrementally(true);
+
+ assert( igvn._worklist.size() == 0, "should be done with igvn" );
+ for_igvn()->clear();
+ gvn->replace_with(&igvn);
+
+ while (_boxing_late_inlines.length() > 0) {
+ CallGenerator* cg = _boxing_late_inlines.pop();
+ cg->do_late_inline();
+ if (failing()) return;
+ }
+ _boxing_late_inlines.trunc_to(0);
+
+ {
+ ResourceMark rm;
+ PhaseRemoveUseless pru(gvn, for_igvn());
+ }
+
+ igvn = PhaseIterGVN(gvn);
+ igvn.optimize();
+
+ set_inlining_progress(false);
+ set_inlining_incrementally(false);
+ }
+}
+
void Compile::inline_incrementally_one(PhaseIterGVN& igvn) {
assert(IncrementalInline, "incremental inlining should be on");
PhaseGVN* gvn = initial_gvn();
@@ -1831,7 +1875,7 @@
{
ResourceMark rm;
- PhaseRemoveUseless pru(C->initial_gvn(), C->for_igvn());
+ PhaseRemoveUseless pru(gvn, for_igvn());
}
igvn = PhaseIterGVN(gvn);
@@ -1929,12 +1973,25 @@
if (failing()) return;
- inline_incrementally(igvn);
+ {
+ NOT_PRODUCT( TracePhase t2("incrementalInline", &_t_incrInline, TimeCompiler); )
+ inline_incrementally(igvn);
+ }
print_method("Incremental Inline", 2);
if (failing()) return;
+ if (eliminate_boxing()) {
+ NOT_PRODUCT( TracePhase t2("incrementalInline", &_t_incrInline, TimeCompiler); )
+ // Inline valueOf() methods now.
+ inline_boxing_calls(igvn);
+
+ print_method("Incremental Boxing Inline", 2);
+
+ if (failing()) return;
+ }
+
// No more new expensive nodes will be added to the list from here
// so keep only the actual candidates for optimizations.
cleanup_expensive_nodes(igvn);
@@ -2896,6 +2953,7 @@
}
break;
case Op_MemBarStoreStore:
+ case Op_MemBarRelease:
// Break the link with AllocateNode: it is no longer useful and
// confuses register allocation.
if (n->req() > MemBarNode::Precedent) {
--- a/hotspot/src/share/vm/opto/compile.hpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/compile.hpp Thu May 16 13:47:55 2013 -0700
@@ -262,6 +262,7 @@
const bool _save_argument_registers; // save/restore arg regs for trampolines
const bool _subsume_loads; // Load can be matched as part of a larger op.
const bool _do_escape_analysis; // Do escape analysis.
+ const bool _eliminate_boxing; // Do boxing elimination.
ciMethod* _method; // The method being compiled.
int _entry_bci; // entry bci for osr methods.
const TypeFunc* _tf; // My kind of signature
@@ -287,6 +288,7 @@
bool _has_split_ifs; // True if the method _may_ have some split-if
bool _has_unsafe_access; // True if the method _may_ produce faults in unsafe loads or stores.
bool _has_stringbuilder; // True StringBuffers or StringBuilders are allocated
+ bool _has_boxed_value; // True if a boxed object is allocated
int _max_vector_size; // Maximum size of generated vectors
uint _trap_hist[trapHistLength]; // Cumulative traps
bool _trap_can_recompile; // Have we emitted a recompiling trap?
@@ -375,6 +377,8 @@
// main parsing has finished.
GrowableArray<CallGenerator*> _string_late_inlines; // same but for string operations
+ GrowableArray<CallGenerator*> _boxing_late_inlines; // same but for boxing operations
+
int _late_inlines_pos; // Where in the queue should the next late inlining candidate go (emulate depth first inlining)
uint _number_of_mh_late_inlines; // number of method handle late inlining still pending
@@ -486,8 +490,12 @@
// instructions that subsume a load may result in an unschedulable
// instruction sequence.
bool subsume_loads() const { return _subsume_loads; }
- // Do escape analysis.
+ /** Do escape analysis. */
bool do_escape_analysis() const { return _do_escape_analysis; }
+ /** Do boxing elimination. */
+ bool eliminate_boxing() const { return _eliminate_boxing; }
+ /** Do aggressive boxing elimination. */
+ bool aggressive_unboxing() const { return _eliminate_boxing && AggressiveUnboxing; }
bool save_argument_registers() const { return _save_argument_registers; }
@@ -527,6 +535,8 @@
void set_has_unsafe_access(bool z) { _has_unsafe_access = z; }
bool has_stringbuilder() const { return _has_stringbuilder; }
void set_has_stringbuilder(bool z) { _has_stringbuilder = z; }
+ bool has_boxed_value() const { return _has_boxed_value; }
+ void set_has_boxed_value(bool z) { _has_boxed_value = z; }
int max_vector_size() const { return _max_vector_size; }
void set_max_vector_size(int s) { _max_vector_size = s; }
void set_trap_count(uint r, uint c) { assert(r < trapHistLength, "oob"); _trap_hist[r] = c; }
@@ -579,12 +589,12 @@
#endif
}
- int macro_count() { return _macro_nodes->length(); }
- int predicate_count() { return _predicate_opaqs->length();}
- int expensive_count() { return _expensive_nodes->length(); }
- Node* macro_node(int idx) { return _macro_nodes->at(idx); }
- Node* predicate_opaque1_node(int idx) { return _predicate_opaqs->at(idx);}
- Node* expensive_node(int idx) { return _expensive_nodes->at(idx); }
+ int macro_count() const { return _macro_nodes->length(); }
+ int predicate_count() const { return _predicate_opaqs->length();}
+ int expensive_count() const { return _expensive_nodes->length(); }
+ Node* macro_node(int idx) const { return _macro_nodes->at(idx); }
+ Node* predicate_opaque1_node(int idx) const { return _predicate_opaqs->at(idx);}
+ Node* expensive_node(int idx) const { return _expensive_nodes->at(idx); }
ConnectionGraph* congraph() { return _congraph;}
void set_congraph(ConnectionGraph* congraph) { _congraph = congraph;}
void add_macro_node(Node * n) {
@@ -766,7 +776,12 @@
// Decide how to build a call.
// The profile factor is a discount to apply to this site's interp. profile.
CallGenerator* call_generator(ciMethod* call_method, int vtable_index, bool call_does_dispatch, JVMState* jvms, bool allow_inline, float profile_factor, bool allow_intrinsics = true, bool delayed_forbidden = false);
- bool should_delay_inlining(ciMethod* call_method, JVMState* jvms);
+ bool should_delay_inlining(ciMethod* call_method, JVMState* jvms) {
+ return should_delay_string_inlining(call_method, jvms) ||
+ should_delay_boxing_inlining(call_method, jvms);
+ }
+ bool should_delay_string_inlining(ciMethod* call_method, JVMState* jvms);
+ bool should_delay_boxing_inlining(ciMethod* call_method, JVMState* jvms);
// Helper functions to identify inlining potential at call-site
ciMethod* optimize_virtual_call(ciMethod* caller, int bci, ciInstanceKlass* klass,
@@ -822,6 +837,10 @@
_string_late_inlines.push(cg);
}
+ void add_boxing_late_inline(CallGenerator* cg) {
+ _boxing_late_inlines.push(cg);
+ }
+
void remove_useless_late_inlines(GrowableArray<CallGenerator*>* inlines, Unique_Node_List &useful);
void dump_inlining();
@@ -841,6 +860,7 @@
void inline_incrementally_one(PhaseIterGVN& igvn);
void inline_incrementally(PhaseIterGVN& igvn);
void inline_string_calls(bool parse_time);
+ void inline_boxing_calls(PhaseIterGVN& igvn);
// Matching, CFG layout, allocation, code generation
PhaseCFG* cfg() { return _cfg; }
@@ -913,7 +933,8 @@
// replacement, entry_bci indicates the bytecode for which to compile a
// continuation.
Compile(ciEnv* ci_env, C2Compiler* compiler, ciMethod* target,
- int entry_bci, bool subsume_loads, bool do_escape_analysis);
+ int entry_bci, bool subsume_loads, bool do_escape_analysis,
+ bool eliminate_boxing);
// Second major entry point. From the TypeFunc signature, generate code
// to pass arguments from the Java calling convention to the C calling
--- a/hotspot/src/share/vm/opto/doCall.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/doCall.cpp Thu May 16 13:47:55 2013 -0700
@@ -176,9 +176,12 @@
// Delay the inlining of this method to give us the
// opportunity to perform some high level optimizations
// first.
- if (should_delay_inlining(callee, jvms)) {
+ if (should_delay_string_inlining(callee, jvms)) {
assert(!delayed_forbidden, "strange");
return CallGenerator::for_string_late_inline(callee, cg);
+ } else if (should_delay_boxing_inlining(callee, jvms)) {
+ assert(!delayed_forbidden, "strange");
+ return CallGenerator::for_boxing_late_inline(callee, cg);
} else if ((should_delay || AlwaysIncrementalInline) && !delayed_forbidden) {
return CallGenerator::for_late_inline(callee, cg);
}
@@ -276,7 +279,7 @@
// Return true for methods that shouldn't be inlined early so that
// they are easier to analyze and optimize as intrinsics.
-bool Compile::should_delay_inlining(ciMethod* call_method, JVMState* jvms) {
+bool Compile::should_delay_string_inlining(ciMethod* call_method, JVMState* jvms) {
if (has_stringbuilder()) {
if ((call_method->holder() == C->env()->StringBuilder_klass() ||
@@ -327,6 +330,13 @@
return false;
}
+bool Compile::should_delay_boxing_inlining(ciMethod* call_method, JVMState* jvms) {
+ if (eliminate_boxing() && call_method->is_boxing_method()) {
+ set_has_boxed_value(true);
+ return true;
+ }
+ return false;
+}
// uncommon-trap call-sites where callee is unloaded, uninitialized or will not link
bool Parse::can_not_compile_call_site(ciMethod *dest_method, ciInstanceKlass* klass) {
--- a/hotspot/src/share/vm/opto/escape.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/escape.cpp Thu May 16 13:47:55 2013 -0700
@@ -63,15 +63,19 @@
// EA brings benefits only when the code has allocations and/or locks which
// are represented by ideal Macro nodes.
int cnt = C->macro_count();
- for( int i=0; i < cnt; i++ ) {
+ for (int i = 0; i < cnt; i++) {
Node *n = C->macro_node(i);
- if ( n->is_Allocate() )
+ if (n->is_Allocate())
return true;
- if( n->is_Lock() ) {
+ if (n->is_Lock()) {
Node* obj = n->as_Lock()->obj_node()->uncast();
- if( !(obj->is_Parm() || obj->is_Con()) )
+ if (!(obj->is_Parm() || obj->is_Con()))
return true;
}
+ if (n->is_CallStaticJava() &&
+ n->as_CallStaticJava()->is_boxing_method()) {
+ return true;
+ }
}
return false;
}
@@ -115,7 +119,7 @@
{ Compile::TracePhase t3("connectionGraph", &Phase::_t_connectionGraph, true);
// 1. Populate Connection Graph (CG) with PointsTo nodes.
- ideal_nodes.map(C->unique(), NULL); // preallocate space
+ ideal_nodes.map(C->live_nodes(), NULL); // preallocate space
// Initialize worklist
if (C->root() != NULL) {
ideal_nodes.push(C->root());
@@ -152,8 +156,11 @@
// escape status of the associated Allocate node some of them
// may be eliminated.
storestore_worklist.append(n);
+ } else if (n->is_MemBar() && (n->Opcode() == Op_MemBarRelease) &&
+ (n->req() > MemBarNode::Precedent)) {
+ record_for_optimizer(n);
#ifdef ASSERT
- } else if(n->is_AddP()) {
+ } else if (n->is_AddP()) {
// Collect address nodes for graph verification.
addp_worklist.append(n);
#endif
@@ -206,8 +213,15 @@
int non_escaped_length = non_escaped_worklist.length();
for (int next = 0; next < non_escaped_length; next++) {
JavaObjectNode* ptn = non_escaped_worklist.at(next);
- if (ptn->escape_state() == PointsToNode::NoEscape &&
- ptn->scalar_replaceable()) {
+ bool noescape = (ptn->escape_state() == PointsToNode::NoEscape);
+ Node* n = ptn->ideal_node();
+ if (n->is_Allocate()) {
+ n->as_Allocate()->_is_non_escaping = noescape;
+ }
+ if (n->is_CallStaticJava()) {
+ n->as_CallStaticJava()->_is_non_escaping = noescape;
+ }
+ if (noescape && ptn->scalar_replaceable()) {
adjust_scalar_replaceable_state(ptn);
if (ptn->scalar_replaceable()) {
alloc_worklist.append(ptn->ideal_node());
@@ -330,8 +344,10 @@
// Don't mark as processed since call's arguments have to be processed.
delayed_worklist->push(n);
// Check if a call returns an object.
- if (n->as_Call()->returns_pointer() &&
- n->as_Call()->proj_out(TypeFunc::Parms) != NULL) {
+ if ((n->as_Call()->returns_pointer() &&
+ n->as_Call()->proj_out(TypeFunc::Parms) != NULL) ||
+ (n->is_CallStaticJava() &&
+ n->as_CallStaticJava()->is_boxing_method())) {
add_call_node(n->as_Call());
}
}
@@ -387,8 +403,8 @@
case Op_ConNKlass: {
// assume all oop constants globally escape except for null
PointsToNode::EscapeState es;
- if (igvn->type(n) == TypePtr::NULL_PTR ||
- igvn->type(n) == TypeNarrowOop::NULL_PTR) {
+ const Type* t = igvn->type(n);
+ if (t == TypePtr::NULL_PTR || t == TypeNarrowOop::NULL_PTR) {
es = PointsToNode::NoEscape;
} else {
es = PointsToNode::GlobalEscape;
@@ -468,6 +484,9 @@
Node* adr = n->in(MemNode::Address);
const Type *adr_type = igvn->type(adr);
adr_type = adr_type->make_ptr();
+ if (adr_type == NULL) {
+ break; // skip dead nodes
+ }
if (adr_type->isa_oopptr() ||
(opcode == Op_StoreP || opcode == Op_StoreN || opcode == Op_StoreNKlass) &&
(adr_type == TypeRawPtr::NOTNULL &&
@@ -660,14 +679,18 @@
case Op_GetAndSetP:
case Op_GetAndSetN: {
Node* adr = n->in(MemNode::Address);
- if (opcode == Op_GetAndSetP || opcode == Op_GetAndSetN) {
- const Type* t = _igvn->type(n);
- if (t->make_ptr() != NULL) {
- add_local_var_and_edge(n, PointsToNode::NoEscape, adr, NULL);
- }
- }
const Type *adr_type = _igvn->type(adr);
adr_type = adr_type->make_ptr();
+#ifdef ASSERT
+ if (adr_type == NULL) {
+ n->dump(1);
+ assert(adr_type != NULL, "dead node should not be on list");
+ break;
+ }
+#endif
+ if (opcode == Op_GetAndSetP || opcode == Op_GetAndSetN) {
+ add_local_var_and_edge(n, PointsToNode::NoEscape, adr, NULL);
+ }
if (adr_type->isa_oopptr() ||
(opcode == Op_StoreP || opcode == Op_StoreN || opcode == Op_StoreNKlass) &&
(adr_type == TypeRawPtr::NOTNULL &&
@@ -797,6 +820,18 @@
// Returns a newly allocated unescaped object.
add_java_object(call, PointsToNode::NoEscape);
ptnode_adr(call_idx)->set_scalar_replaceable(false);
+ } else if (meth->is_boxing_method()) {
+ // Returns boxing object
+ PointsToNode::EscapeState es;
+ vmIntrinsics::ID intr = meth->intrinsic_id();
+ if (intr == vmIntrinsics::_floatValue || intr == vmIntrinsics::_doubleValue) {
+ // It does not escape if object is always allocated.
+ es = PointsToNode::NoEscape;
+ } else {
+ // It escapes globally if object could be loaded from cache.
+ es = PointsToNode::GlobalEscape;
+ }
+ add_java_object(call, es);
} else {
BCEscapeAnalyzer* call_analyzer = meth->get_bcea();
call_analyzer->copy_dependencies(_compile->dependencies());
@@ -943,6 +978,9 @@
assert((name == NULL || strcmp(name, "uncommon_trap") != 0), "normal calls only");
#endif
ciMethod* meth = call->as_CallJava()->method();
+ if ((meth != NULL) && meth->is_boxing_method()) {
+ break; // Boxing methods do not modify any oops.
+ }
BCEscapeAnalyzer* call_analyzer = (meth !=NULL) ? meth->get_bcea() : NULL;
// fall-through if not a Java method or no analyzer information
if (call_analyzer != NULL) {
@@ -1791,9 +1829,8 @@
jobj2->ideal_node()->is_Con()) {
// Klass or String constants compare. Need to be careful with
// compressed pointers - compare types of ConN and ConP instead of nodes.
- const Type* t1 = jobj1->ideal_node()->bottom_type()->make_ptr();
- const Type* t2 = jobj2->ideal_node()->bottom_type()->make_ptr();
- assert(t1 != NULL && t2 != NULL, "sanity");
+ const Type* t1 = jobj1->ideal_node()->get_ptr_type();
+ const Type* t2 = jobj2->ideal_node()->get_ptr_type();
if (t1->make_ptr() == t2->make_ptr()) {
return _pcmp_eq;
} else {
@@ -2744,6 +2781,11 @@
// so it could be eliminated if it has no uses.
alloc->as_Allocate()->_is_scalar_replaceable = true;
}
+ if (alloc->is_CallStaticJava()) {
+ // Set the scalar_replaceable flag for boxing method
+ // so it could be eliminated if it has no uses.
+ alloc->as_CallStaticJava()->_is_scalar_replaceable = true;
+ }
continue;
}
if (!n->is_CheckCastPP()) { // not unique CheckCastPP.
@@ -2782,6 +2824,11 @@
// so it could be eliminated.
alloc->as_Allocate()->_is_scalar_replaceable = true;
}
+ if (alloc->is_CallStaticJava()) {
+ // Set the scalar_replaceable flag for boxing method
+ // so it could be eliminated.
+ alloc->as_CallStaticJava()->_is_scalar_replaceable = true;
+ }
set_escape_state(ptnode_adr(n->_idx), es); // CheckCastPP escape state
// in order for an object to be scalar-replaceable, it must be:
// - a direct allocation (not a call returning an object)
@@ -2911,7 +2958,9 @@
// Load/store to instance's field
memnode_worklist.append_if_missing(use);
} else if (use->is_MemBar()) {
- memnode_worklist.append_if_missing(use);
+ if (use->in(TypeFunc::Memory) == n) { // Ignore precedent edge
+ memnode_worklist.append_if_missing(use);
+ }
} else if (use->is_AddP() && use->outcnt() > 0) { // No dead nodes
Node* addp2 = find_second_addp(use, n);
if (addp2 != NULL) {
@@ -3028,7 +3077,9 @@
continue;
memnode_worklist.append_if_missing(use);
} else if (use->is_MemBar()) {
- memnode_worklist.append_if_missing(use);
+ if (use->in(TypeFunc::Memory) == n) { // Ignore precedent edge
+ memnode_worklist.append_if_missing(use);
+ }
#ifdef ASSERT
} else if(use->is_Mem()) {
assert(use->in(MemNode::Memory) != n, "EA: missing memory path");
@@ -3264,7 +3315,12 @@
if (ptn == NULL || !ptn->is_JavaObject())
continue;
PointsToNode::EscapeState es = ptn->escape_state();
- if (ptn->ideal_node()->is_Allocate() && (es == PointsToNode::NoEscape || Verbose)) {
+ if ((es != PointsToNode::NoEscape) && !Verbose) {
+ continue;
+ }
+ Node* n = ptn->ideal_node();
+ if (n->is_Allocate() || (n->is_CallStaticJava() &&
+ n->as_CallStaticJava()->is_boxing_method())) {
if (first) {
tty->cr();
tty->print("======== Connection graph for ");
--- a/hotspot/src/share/vm/opto/graphKit.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/graphKit.cpp Thu May 16 13:47:55 2013 -0700
@@ -333,6 +333,7 @@
assert(ex_jvms->stkoff() == phi_map->_jvms->stkoff(), "matching locals");
assert(ex_jvms->sp() == phi_map->_jvms->sp(), "matching stack sizes");
assert(ex_jvms->monoff() == phi_map->_jvms->monoff(), "matching JVMS");
+ assert(ex_jvms->scloff() == phi_map->_jvms->scloff(), "matching scalar replaced objects");
assert(ex_map->req() == phi_map->req(), "matching maps");
uint tos = ex_jvms->stkoff() + ex_jvms->sp();
Node* hidden_merge_mark = root();
@@ -409,7 +410,7 @@
while (dst->req() > orig_width) dst->del_req(dst->req()-1);
} else {
assert(dst->is_Phi(), "nobody else uses a hidden region");
- phi = (PhiNode*)dst;
+ phi = dst->as_Phi();
}
if (add_multiple && src->in(0) == ex_control) {
// Both are phis.
@@ -1438,7 +1439,12 @@
} else {
ld = LoadNode::make(_gvn, ctl, mem, adr, adr_type, t, bt);
}
- return _gvn.transform(ld);
+ ld = _gvn.transform(ld);
+ if ((bt == T_OBJECT) && C->do_escape_analysis() || C->eliminate_boxing()) {
+ // Improve graph before escape analysis and boxing elimination.
+ record_for_igvn(ld);
+ }
+ return ld;
}
Node* GraphKit::store_to_memory(Node* ctl, Node* adr, Node *val, BasicType bt,
@@ -3144,7 +3150,7 @@
set_all_memory(mem); // Create new memory state
AllocateNode* alloc
- = new (C) AllocateNode(C, AllocateNode::alloc_type(),
+ = new (C) AllocateNode(C, AllocateNode::alloc_type(Type::TOP),
control(), mem, i_o(),
size, klass_node,
initial_slow_test);
@@ -3285,7 +3291,7 @@
// Create the AllocateArrayNode and its result projections
AllocateArrayNode* alloc
- = new (C) AllocateArrayNode(C, AllocateArrayNode::alloc_type(),
+ = new (C) AllocateArrayNode(C, AllocateArrayNode::alloc_type(TypeInt::INT),
control(), mem, i_o(),
size, klass_node,
initial_slow_test,
@@ -3326,10 +3332,9 @@
if (ptr == NULL) { // reduce dumb test in callers
return NULL;
}
- if (ptr->is_CheckCastPP()) { // strip a raw-to-oop cast
- ptr = ptr->in(1);
- if (ptr == NULL) return NULL;
- }
+ ptr = ptr->uncast(); // strip a raw-to-oop cast
+ if (ptr == NULL) return NULL;
+
if (ptr->is_Proj()) {
Node* allo = ptr->in(0);
if (allo != NULL && allo->is_Allocate()) {
@@ -3374,19 +3379,6 @@
return NULL;
}
-// Trace Allocate -> Proj[Parm] -> MemBarStoreStore
-MemBarStoreStoreNode* AllocateNode::storestore() {
- ProjNode* rawoop = proj_out(AllocateNode::RawAddress);
- if (rawoop == NULL) return NULL;
- for (DUIterator_Fast imax, i = rawoop->fast_outs(imax); i < imax; i++) {
- Node* storestore = rawoop->fast_out(i);
- if (storestore->is_MemBarStoreStore()) {
- return storestore->as_MemBarStoreStore();
- }
- }
- return NULL;
-}
-
//----------------------------- loop predicates ---------------------------
//------------------------------add_predicate_impl----------------------------
--- a/hotspot/src/share/vm/opto/ifnode.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/ifnode.cpp Thu May 16 13:47:55 2013 -0700
@@ -673,7 +673,7 @@
// / Region
//
Node* IfNode::fold_compares(PhaseGVN* phase) {
- if (!EliminateAutoBox || Opcode() != Op_If) return NULL;
+ if (!phase->C->eliminate_boxing() || Opcode() != Op_If) return NULL;
Node* this_cmp = in(1)->in(1);
if (this_cmp != NULL && this_cmp->Opcode() == Op_CmpI &&
--- a/hotspot/src/share/vm/opto/lcm.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/lcm.cpp Thu May 16 13:47:55 2013 -0700
@@ -219,9 +219,10 @@
// cannot reason about it; is probably not implicit null exception
} else {
const TypePtr* tptr;
- if (UseCompressedOops && Universe::narrow_oop_shift() == 0) {
+ if (UseCompressedOops && (Universe::narrow_oop_shift() == 0 ||
+ Universe::narrow_klass_shift() == 0)) {
// 32-bits narrow oop can be the base of address expressions
- tptr = base->bottom_type()->make_ptr();
+ tptr = base->get_ptr_type();
} else {
// only regular oops are expected here
tptr = base->bottom_type()->is_ptr();
--- a/hotspot/src/share/vm/opto/library_call.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/library_call.cpp Thu May 16 13:47:55 2013 -0700
@@ -2783,7 +2783,7 @@
#ifdef _LP64
if (type == T_OBJECT && adr->bottom_type()->is_ptr_to_narrowoop() && kind == LS_xchg) {
- load_store = _gvn.transform(new (C) DecodeNNode(load_store, load_store->bottom_type()->make_ptr()));
+ load_store = _gvn.transform(new (C) DecodeNNode(load_store, load_store->get_ptr_type()));
}
#endif
@@ -3703,7 +3703,7 @@
CallJavaNode* slow_call;
if (is_static) {
assert(!is_virtual, "");
- slow_call = new(C) CallStaticJavaNode(tf,
+ slow_call = new(C) CallStaticJavaNode(C, tf,
SharedRuntime::get_resolve_static_call_stub(),
method, bci());
} else if (is_virtual) {
@@ -3722,7 +3722,7 @@
method, vtable_index, bci());
} else { // neither virtual nor static: opt_virtual
null_check_receiver();
- slow_call = new(C) CallStaticJavaNode(tf,
+ slow_call = new(C) CallStaticJavaNode(C, tf,
SharedRuntime::get_resolve_opt_virtual_call_stub(),
method, bci());
slow_call->set_optimized_virtual(true);
--- a/hotspot/src/share/vm/opto/loopPredicate.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/loopPredicate.cpp Thu May 16 13:47:55 2013 -0700
@@ -821,8 +821,8 @@
loop->dump_head();
}
#endif
- } else if (cl != NULL && loop->is_range_check_if(iff, this, invar)) {
- assert(proj->_con == predicate_proj->_con, "must match");
+ } else if ((cl != NULL) && (proj->_con == predicate_proj->_con) &&
+ loop->is_range_check_if(iff, this, invar)) {
// Range check for counted loops
const Node* cmp = bol->in(1)->as_Cmp();
--- a/hotspot/src/share/vm/opto/machnode.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/machnode.cpp Thu May 16 13:47:55 2013 -0700
@@ -349,11 +349,11 @@
if (base == NodeSentinel) return TypePtr::BOTTOM;
const Type* t = base->bottom_type();
- if (UseCompressedOops && Universe::narrow_oop_shift() == 0) {
+ if (t->isa_narrowoop() && Universe::narrow_oop_shift() == 0) {
// 32-bit unscaled narrow oop can be the base of any address expression
t = t->make_ptr();
}
- if (UseCompressedKlassPointers && Universe::narrow_klass_shift() == 0) {
+ if (t->isa_narrowklass() && Universe::narrow_klass_shift() == 0) {
// 32-bit unscaled narrow oop can be the base of any address expression
t = t->make_ptr();
}
--- a/hotspot/src/share/vm/opto/macro.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/macro.cpp Thu May 16 13:47:55 2013 -0700
@@ -666,7 +666,7 @@
alloc->dump();
else
res->dump();
- } else {
+ } else if (alloc->_is_scalar_replaceable) {
tty->print("NotScalar (%s)", fail_eliminate);
if (res == NULL)
alloc->dump();
@@ -834,7 +834,7 @@
if (field_val->is_EncodeP()) {
field_val = field_val->in(1);
} else {
- field_val = transform_later(new (C) DecodeNNode(field_val, field_val->bottom_type()->make_ptr()));
+ field_val = transform_later(new (C) DecodeNNode(field_val, field_val->get_ptr_type()));
}
}
sfpt->add_req(field_val);
@@ -845,18 +845,14 @@
// to the allocated object with "sobj"
int start = jvms->debug_start();
int end = jvms->debug_end();
- for (int i = start; i < end; i++) {
- if (sfpt->in(i) == res) {
- sfpt->set_req(i, sobj);
- }
- }
+ sfpt->replace_edges_in_range(res, sobj, start, end);
safepoints_done.append_if_missing(sfpt); // keep it for rollback
}
return true;
}
// Process users of eliminated allocation.
-void PhaseMacroExpand::process_users_of_allocation(AllocateNode *alloc) {
+void PhaseMacroExpand::process_users_of_allocation(CallNode *alloc) {
Node* res = alloc->result_cast();
if (res != NULL) {
for (DUIterator_Last jmin, j = res->last_outs(jmin); j >= jmin; ) {
@@ -899,6 +895,17 @@
// Process other users of allocation's projections
//
if (_resproj != NULL && _resproj->outcnt() != 0) {
+ // First disconnect stores captured by Initialize node.
+ // If Initialize node is eliminated first in the following code,
+ // it will kill such stores and DUIterator_Last will assert.
+ for (DUIterator_Fast jmax, j = _resproj->fast_outs(jmax); j < jmax; j++) {
+ Node *use = _resproj->fast_out(j);
+ if (use->is_AddP()) {
+ // raw memory addresses used only by the initialization
+ _igvn.replace_node(use, C->top());
+ --j; --jmax;
+ }
+ }
for (DUIterator_Last jmin, j = _resproj->last_outs(jmin); j >= jmin; ) {
Node *use = _resproj->last_out(j);
uint oc1 = _resproj->outcnt();
@@ -923,9 +930,6 @@
#endif
_igvn.replace_node(mem_proj, mem);
}
- } else if (use->is_AddP()) {
- // raw memory addresses used only by the initialization
- _igvn.replace_node(use, C->top());
} else {
assert(false, "only Initialize or AddP expected");
}
@@ -953,8 +957,18 @@
}
bool PhaseMacroExpand::eliminate_allocate_node(AllocateNode *alloc) {
-
- if (!EliminateAllocations || !alloc->_is_scalar_replaceable) {
+ if (!EliminateAllocations || !alloc->_is_non_escaping) {
+ return false;
+ }
+ Node* klass = alloc->in(AllocateNode::KlassNode);
+ const TypeKlassPtr* tklass = _igvn.type(klass)->is_klassptr();
+ Node* res = alloc->result_cast();
+ // Eliminate boxing allocations which are not used
+ // regardless scalar replacable status.
+ bool boxing_alloc = C->eliminate_boxing() &&
+ tklass->klass()->is_instance_klass() &&
+ tklass->klass()->as_instance_klass()->is_box_klass();
+ if (!alloc->_is_scalar_replaceable && (!boxing_alloc || (res != NULL))) {
return false;
}
@@ -965,14 +979,22 @@
return false;
}
+ if (!alloc->_is_scalar_replaceable) {
+ assert(res == NULL, "sanity");
+ // We can only eliminate allocation if all debug info references
+ // are already replaced with SafePointScalarObject because
+ // we can't search for a fields value without instance_id.
+ if (safepoints.length() > 0) {
+ return false;
+ }
+ }
+
if (!scalar_replacement(alloc, safepoints)) {
return false;
}
CompileLog* log = C->log();
if (log != NULL) {
- Node* klass = alloc->in(AllocateNode::KlassNode);
- const TypeKlassPtr* tklass = _igvn.type(klass)->is_klassptr();
log->head("eliminate_allocation type='%d'",
log->identify(tklass->klass()));
JVMState* p = alloc->jvms();
@@ -997,6 +1019,43 @@
return true;
}
+bool PhaseMacroExpand::eliminate_boxing_node(CallStaticJavaNode *boxing) {
+ // EA should remove all uses of non-escaping boxing node.
+ if (!C->eliminate_boxing() || boxing->proj_out(TypeFunc::Parms) != NULL) {
+ return false;
+ }
+
+ extract_call_projections(boxing);
+
+ const TypeTuple* r = boxing->tf()->range();
+ assert(r->cnt() > TypeFunc::Parms, "sanity");
+ const TypeInstPtr* t = r->field_at(TypeFunc::Parms)->isa_instptr();
+ assert(t != NULL, "sanity");
+
+ CompileLog* log = C->log();
+ if (log != NULL) {
+ log->head("eliminate_boxing type='%d'",
+ log->identify(t->klass()));
+ JVMState* p = boxing->jvms();
+ while (p != NULL) {
+ log->elem("jvms bci='%d' method='%d'", p->bci(), log->identify(p->method()));
+ p = p->caller();
+ }
+ log->tail("eliminate_boxing");
+ }
+
+ process_users_of_allocation(boxing);
+
+#ifndef PRODUCT
+ if (PrintEliminateAllocations) {
+ tty->print("++++ Eliminated: %d ", boxing->_idx);
+ boxing->method()->print_short_name(tty);
+ tty->cr();
+ }
+#endif
+
+ return true;
+}
//---------------------------set_eden_pointers-------------------------
void PhaseMacroExpand::set_eden_pointers(Node* &eden_top_adr, Node* &eden_end_adr) {
@@ -2384,6 +2443,9 @@
case Node::Class_AllocateArray:
success = eliminate_allocate_node(n->as_Allocate());
break;
+ case Node::Class_CallStaticJava:
+ success = eliminate_boxing_node(n->as_CallStaticJava());
+ break;
case Node::Class_Lock:
case Node::Class_Unlock:
assert(!n->as_AbstractLock()->is_eliminated(), "sanity");
@@ -2424,6 +2486,11 @@
C->remove_macro_node(n);
_igvn._worklist.push(n);
success = true;
+ } else if (n->Opcode() == Op_CallStaticJava) {
+ // Remove it from macro list and put on IGVN worklist to optimize.
+ C->remove_macro_node(n);
+ _igvn._worklist.push(n);
+ success = true;
} else if (n->Opcode() == Op_Opaque1 || n->Opcode() == Op_Opaque2) {
_igvn.replace_node(n, n->in(1));
success = true;
--- a/hotspot/src/share/vm/opto/macro.hpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/macro.hpp Thu May 16 13:47:55 2013 -0700
@@ -86,10 +86,11 @@
Node *value_from_mem(Node *mem, BasicType ft, const Type *ftype, const TypeOopPtr *adr_t, Node *alloc);
Node *value_from_mem_phi(Node *mem, BasicType ft, const Type *ftype, const TypeOopPtr *adr_t, Node *alloc, Node_Stack *value_phis, int level);
+ bool eliminate_boxing_node(CallStaticJavaNode *boxing);
bool eliminate_allocate_node(AllocateNode *alloc);
bool can_eliminate_allocation(AllocateNode *alloc, GrowableArray <SafePointNode *>& safepoints);
bool scalar_replacement(AllocateNode *alloc, GrowableArray <SafePointNode *>& safepoints_done);
- void process_users_of_allocation(AllocateNode *alloc);
+ void process_users_of_allocation(CallNode *alloc);
void eliminate_card_mark(Node *cm);
void mark_eliminated_box(Node* box, Node* obj);
--- a/hotspot/src/share/vm/opto/memnode.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/memnode.cpp Thu May 16 13:47:55 2013 -0700
@@ -103,11 +103,15 @@
#endif
-Node *MemNode::optimize_simple_memory_chain(Node *mchain, const TypePtr *t_adr, PhaseGVN *phase) {
- const TypeOopPtr *tinst = t_adr->isa_oopptr();
- if (tinst == NULL || !tinst->is_known_instance_field())
+Node *MemNode::optimize_simple_memory_chain(Node *mchain, const TypeOopPtr *t_oop, Node *load, PhaseGVN *phase) {
+ assert((t_oop != NULL), "sanity");
+ bool is_instance = t_oop->is_known_instance_field();
+ bool is_boxed_value_load = t_oop->is_ptr_to_boxed_value() &&
+ (load != NULL) && load->is_Load() &&
+ (phase->is_IterGVN() != NULL);
+ if (!(is_instance || is_boxed_value_load))
return mchain; // don't try to optimize non-instance types
- uint instance_id = tinst->instance_id();
+ uint instance_id = t_oop->instance_id();
Node *start_mem = phase->C->start()->proj_out(TypeFunc::Memory);
Node *prev = NULL;
Node *result = mchain;
@@ -122,15 +126,24 @@
break; // hit one of our sentinels
} else if (proj_in->is_Call()) {
CallNode *call = proj_in->as_Call();
- if (!call->may_modify(t_adr, phase)) {
+ if (!call->may_modify(t_oop, phase)) { // returns false for instances
result = call->in(TypeFunc::Memory);
}
} else if (proj_in->is_Initialize()) {
AllocateNode* alloc = proj_in->as_Initialize()->allocation();
// Stop if this is the initialization for the object instance which
// which contains this memory slice, otherwise skip over it.
- if (alloc != NULL && alloc->_idx != instance_id) {
+ if ((alloc == NULL) || (alloc->_idx == instance_id)) {
+ break;
+ }
+ if (is_instance) {
result = proj_in->in(TypeFunc::Memory);
+ } else if (is_boxed_value_load) {
+ Node* klass = alloc->in(AllocateNode::KlassNode);
+ const TypeKlassPtr* tklass = phase->type(klass)->is_klassptr();
+ if (tklass->klass_is_exact() && !tklass->klass()->equals(t_oop->klass())) {
+ result = proj_in->in(TypeFunc::Memory); // not related allocation
+ }
}
} else if (proj_in->is_MemBar()) {
result = proj_in->in(TypeFunc::Memory);
@@ -138,25 +151,26 @@
assert(false, "unexpected projection");
}
} else if (result->is_ClearArray()) {
- if (!ClearArrayNode::step_through(&result, instance_id, phase)) {
+ if (!is_instance || !ClearArrayNode::step_through(&result, instance_id, phase)) {
// Can not bypass initialization of the instance
// we are looking for.
break;
}
// Otherwise skip it (the call updated 'result' value).
} else if (result->is_MergeMem()) {
- result = step_through_mergemem(phase, result->as_MergeMem(), t_adr, NULL, tty);
+ result = step_through_mergemem(phase, result->as_MergeMem(), t_oop, NULL, tty);
}
}
return result;
}
-Node *MemNode::optimize_memory_chain(Node *mchain, const TypePtr *t_adr, PhaseGVN *phase) {
- const TypeOopPtr *t_oop = t_adr->isa_oopptr();
- bool is_instance = (t_oop != NULL) && t_oop->is_known_instance_field();
+Node *MemNode::optimize_memory_chain(Node *mchain, const TypePtr *t_adr, Node *load, PhaseGVN *phase) {
+ const TypeOopPtr* t_oop = t_adr->isa_oopptr();
+ if (t_oop == NULL)
+ return mchain; // don't try to optimize non-oop types
+ Node* result = optimize_simple_memory_chain(mchain, t_oop, load, phase);
+ bool is_instance = t_oop->is_known_instance_field();
PhaseIterGVN *igvn = phase->is_IterGVN();
- Node *result = mchain;
- result = optimize_simple_memory_chain(result, t_adr, phase);
if (is_instance && igvn != NULL && result->is_Phi()) {
PhiNode *mphi = result->as_Phi();
assert(mphi->bottom_type() == Type::MEMORY, "memory phi required");
@@ -383,7 +397,7 @@
// Or Region for the check in LoadNode::Ideal();
// 'sub' should have sub->in(0) != NULL.
assert(sub->is_Allocate() || sub->is_Initialize() || sub->is_Start() ||
- sub->is_Region(), "expecting only these nodes");
+ sub->is_Region() || sub->is_Call(), "expecting only these nodes");
// Get control edge of 'sub'.
Node* orig_sub = sub;
@@ -957,11 +971,14 @@
// of aliasing.
Node* MemNode::can_see_stored_value(Node* st, PhaseTransform* phase) const {
Node* ld_adr = in(MemNode::Address);
-
+ intptr_t ld_off = 0;
+ AllocateNode* ld_alloc = AllocateNode::Ideal_allocation(ld_adr, phase, ld_off);
const TypeInstPtr* tp = phase->type(ld_adr)->isa_instptr();
- Compile::AliasType* atp = tp != NULL ? phase->C->alias_type(tp) : NULL;
- if (EliminateAutoBox && atp != NULL && atp->index() >= Compile::AliasIdxRaw &&
- atp->field() != NULL && !atp->field()->is_volatile()) {
+ Compile::AliasType* atp = (tp != NULL) ? phase->C->alias_type(tp) : NULL;
+ // This is more general than load from boxing objects.
+ if (phase->C->eliminate_boxing() && (atp != NULL) &&
+ (atp->index() >= Compile::AliasIdxRaw) &&
+ (atp->field() != NULL) && !atp->field()->is_volatile()) {
uint alias_idx = atp->index();
bool final = atp->field()->is_final();
Node* result = NULL;
@@ -983,7 +1000,7 @@
Node* new_st = merge->memory_at(alias_idx);
if (new_st == merge->base_memory()) {
// Keep searching
- current = merge->base_memory();
+ current = new_st;
continue;
}
// Save the new memory state for the slice and fall through
@@ -1010,9 +1027,7 @@
intptr_t st_off = 0;
AllocateNode* alloc = AllocateNode::Ideal_allocation(st_adr, phase, st_off);
if (alloc == NULL) return NULL;
- intptr_t ld_off = 0;
- AllocateNode* allo2 = AllocateNode::Ideal_allocation(ld_adr, phase, ld_off);
- if (alloc != allo2) return NULL;
+ if (alloc != ld_alloc) return NULL;
if (ld_off != st_off) return NULL;
// At this point we have proven something like this setup:
// A = Allocate(...)
@@ -1029,14 +1044,12 @@
return st->in(MemNode::ValueIn);
}
- intptr_t offset = 0; // scratch
-
// A load from a freshly-created object always returns zero.
// (This can happen after LoadNode::Ideal resets the load's memory input
// to find_captured_store, which returned InitializeNode::zero_memory.)
if (st->is_Proj() && st->in(0)->is_Allocate() &&
- st->in(0) == AllocateNode::Ideal_allocation(ld_adr, phase, offset) &&
- offset >= st->in(0)->as_Allocate()->minimum_header_size()) {
+ (st->in(0) == ld_alloc) &&
+ (ld_off >= st->in(0)->as_Allocate()->minimum_header_size())) {
// return a zero value for the load's basic type
// (This is one of the few places where a generic PhaseTransform
// can create new nodes. Think of it as lazily manifesting
@@ -1048,15 +1061,27 @@
if (st->is_Proj() && st->in(0)->is_Initialize()) {
InitializeNode* init = st->in(0)->as_Initialize();
AllocateNode* alloc = init->allocation();
- if (alloc != NULL &&
- alloc == AllocateNode::Ideal_allocation(ld_adr, phase, offset)) {
+ if ((alloc != NULL) && (alloc == ld_alloc)) {
// examine a captured store value
- st = init->find_captured_store(offset, memory_size(), phase);
+ st = init->find_captured_store(ld_off, memory_size(), phase);
if (st != NULL)
continue; // take one more trip around
}
}
+ // Load boxed value from result of valueOf() call is input parameter.
+ if (this->is_Load() && ld_adr->is_AddP() &&
+ (tp != NULL) && tp->is_ptr_to_boxed_value()) {
+ intptr_t ignore = 0;
+ Node* base = AddPNode::Ideal_base_and_offset(ld_adr, phase, ignore);
+ if (base != NULL && base->is_Proj() &&
+ base->as_Proj()->_con == TypeFunc::Parms &&
+ base->in(0)->is_CallStaticJava() &&
+ base->in(0)->as_CallStaticJava()->is_boxing_method()) {
+ return base->in(0)->in(TypeFunc::Parms);
+ }
+ }
+
break;
}
@@ -1065,11 +1090,13 @@
//----------------------is_instance_field_load_with_local_phi------------------
bool LoadNode::is_instance_field_load_with_local_phi(Node* ctrl) {
- if( in(MemNode::Memory)->is_Phi() && in(MemNode::Memory)->in(0) == ctrl &&
- in(MemNode::Address)->is_AddP() ) {
- const TypeOopPtr* t_oop = in(MemNode::Address)->bottom_type()->isa_oopptr();
- // Only instances.
- if( t_oop != NULL && t_oop->is_known_instance_field() &&
+ if( in(Memory)->is_Phi() && in(Memory)->in(0) == ctrl &&
+ in(Address)->is_AddP() ) {
+ const TypeOopPtr* t_oop = in(Address)->bottom_type()->isa_oopptr();
+ // Only instances and boxed values.
+ if( t_oop != NULL &&
+ (t_oop->is_ptr_to_boxed_value() ||
+ t_oop->is_known_instance_field()) &&
t_oop->offset() != Type::OffsetBot &&
t_oop->offset() != Type::OffsetTop) {
return true;
@@ -1083,7 +1110,7 @@
Node *LoadNode::Identity( PhaseTransform *phase ) {
// If the previous store-maker is the right kind of Store, and the store is
// to the same address, then we are equal to the value stored.
- Node* mem = in(MemNode::Memory);
+ Node* mem = in(Memory);
Node* value = can_see_stored_value(mem, phase);
if( value ) {
// byte, short & char stores truncate naturally.
@@ -1105,15 +1132,22 @@
// instance's field to avoid infinite generation of phis in a loop.
Node *region = mem->in(0);
if (is_instance_field_load_with_local_phi(region)) {
- const TypePtr *addr_t = in(MemNode::Address)->bottom_type()->isa_ptr();
+ const TypeOopPtr *addr_t = in(Address)->bottom_type()->isa_oopptr();
int this_index = phase->C->get_alias_index(addr_t);
int this_offset = addr_t->offset();
- int this_id = addr_t->is_oopptr()->instance_id();
+ int this_iid = addr_t->instance_id();
+ if (!addr_t->is_known_instance() &&
+ addr_t->is_ptr_to_boxed_value()) {
+ // Use _idx of address base (could be Phi node) for boxed values.
+ intptr_t ignore = 0;
+ Node* base = AddPNode::Ideal_base_and_offset(in(Address), phase, ignore);
+ this_iid = base->_idx;
+ }
const Type* this_type = bottom_type();
for (DUIterator_Fast imax, i = region->fast_outs(imax); i < imax; i++) {
Node* phi = region->fast_out(i);
if (phi->is_Phi() && phi != mem &&
- phi->as_Phi()->is_same_inst_field(this_type, this_id, this_index, this_offset)) {
+ phi->as_Phi()->is_same_inst_field(this_type, this_iid, this_index, this_offset)) {
return phi;
}
}
@@ -1122,170 +1156,106 @@
return this;
}
-
-// Returns true if the AliasType refers to the field that holds the
-// cached box array. Currently only handles the IntegerCache case.
-static bool is_autobox_cache(Compile::AliasType* atp) {
- if (atp != NULL && atp->field() != NULL) {
- ciField* field = atp->field();
- ciSymbol* klass = field->holder()->name();
- if (field->name() == ciSymbol::cache_field_name() &&
- field->holder()->uses_default_loader() &&
- klass == ciSymbol::java_lang_Integer_IntegerCache()) {
- return true;
- }
- }
- return false;
-}
-
-// Fetch the base value in the autobox array
-static bool fetch_autobox_base(Compile::AliasType* atp, int& cache_offset) {
- if (atp != NULL && atp->field() != NULL) {
- ciField* field = atp->field();
- ciSymbol* klass = field->holder()->name();
- if (field->name() == ciSymbol::cache_field_name() &&
- field->holder()->uses_default_loader() &&
- klass == ciSymbol::java_lang_Integer_IntegerCache()) {
- assert(field->is_constant(), "what?");
- ciObjArray* array = field->constant_value().as_object()->as_obj_array();
- // Fetch the box object at the base of the array and get its value
- ciInstance* box = array->obj_at(0)->as_instance();
- ciInstanceKlass* ik = box->klass()->as_instance_klass();
- if (ik->nof_nonstatic_fields() == 1) {
- // This should be true nonstatic_field_at requires calling
- // nof_nonstatic_fields so check it anyway
- ciConstant c = box->field_value(ik->nonstatic_field_at(0));
- cache_offset = c.as_int();
- }
- return true;
- }
- }
- return false;
-}
-
-// Returns true if the AliasType refers to the value field of an
-// autobox object. Currently only handles Integer.
-static bool is_autobox_object(Compile::AliasType* atp) {
- if (atp != NULL && atp->field() != NULL) {
- ciField* field = atp->field();
- ciSymbol* klass = field->holder()->name();
- if (field->name() == ciSymbol::value_name() &&
- field->holder()->uses_default_loader() &&
- klass == ciSymbol::java_lang_Integer()) {
- return true;
- }
- }
- return false;
-}
-
-
// We're loading from an object which has autobox behaviour.
// If this object is result of a valueOf call we'll have a phi
// merging a newly allocated object and a load from the cache.
// We want to replace this load with the original incoming
// argument to the valueOf call.
Node* LoadNode::eliminate_autobox(PhaseGVN* phase) {
- Node* base = in(Address)->in(AddPNode::Base);
- if (base->is_Phi() && base->req() == 3) {
- AllocateNode* allocation = NULL;
- int allocation_index = -1;
- int load_index = -1;
- for (uint i = 1; i < base->req(); i++) {
- allocation = AllocateNode::Ideal_allocation(base->in(i), phase);
- if (allocation != NULL) {
- allocation_index = i;
- load_index = 3 - allocation_index;
- break;
- }
- }
- bool has_load = ( allocation != NULL &&
- (base->in(load_index)->is_Load() ||
- base->in(load_index)->is_DecodeN() &&
- base->in(load_index)->in(1)->is_Load()) );
- if (has_load && in(Memory)->is_Phi() && in(Memory)->in(0) == base->in(0)) {
- // Push the loads from the phi that comes from valueOf up
- // through it to allow elimination of the loads and the recovery
- // of the original value.
- Node* mem_phi = in(Memory);
- Node* offset = in(Address)->in(AddPNode::Offset);
- Node* region = base->in(0);
-
- Node* in1 = clone();
- Node* in1_addr = in1->in(Address)->clone();
- in1_addr->set_req(AddPNode::Base, base->in(allocation_index));
- in1_addr->set_req(AddPNode::Address, base->in(allocation_index));
- in1_addr->set_req(AddPNode::Offset, offset);
- in1->set_req(0, region->in(allocation_index));
- in1->set_req(Address, in1_addr);
- in1->set_req(Memory, mem_phi->in(allocation_index));
-
- Node* in2 = clone();
- Node* in2_addr = in2->in(Address)->clone();
- in2_addr->set_req(AddPNode::Base, base->in(load_index));
- in2_addr->set_req(AddPNode::Address, base->in(load_index));
- in2_addr->set_req(AddPNode::Offset, offset);
- in2->set_req(0, region->in(load_index));
- in2->set_req(Address, in2_addr);
- in2->set_req(Memory, mem_phi->in(load_index));
-
- in1_addr = phase->transform(in1_addr);
- in1 = phase->transform(in1);
- in2_addr = phase->transform(in2_addr);
- in2 = phase->transform(in2);
-
- PhiNode* result = PhiNode::make_blank(region, this);
- result->set_req(allocation_index, in1);
- result->set_req(load_index, in2);
- return result;
- }
+ assert(phase->C->eliminate_boxing(), "sanity");
+ intptr_t ignore = 0;
+ Node* base = AddPNode::Ideal_base_and_offset(in(Address), phase, ignore);
+ if ((base == NULL) || base->is_Phi()) {
+ // Push the loads from the phi that comes from valueOf up
+ // through it to allow elimination of the loads and the recovery
+ // of the original value. It is done in split_through_phi().
+ return NULL;
} else if (base->is_Load() ||
base->is_DecodeN() && base->in(1)->is_Load()) {
- if (base->is_DecodeN()) {
- // Get LoadN node which loads cached Integer object
- base = base->in(1);
- }
- // Eliminate the load of Integer.value for integers from the cache
+ // Eliminate the load of boxed value for integer types from the cache
// array by deriving the value from the index into the array.
// Capture the offset of the load and then reverse the computation.
- Node* load_base = base->in(Address)->in(AddPNode::Base);
- if (load_base->is_DecodeN()) {
- // Get LoadN node which loads IntegerCache.cache field
- load_base = load_base->in(1);
+
+ // Get LoadN node which loads a boxing object from 'cache' array.
+ if (base->is_DecodeN()) {
+ base = base->in(1);
+ }
+ if (!base->in(Address)->is_AddP()) {
+ return NULL; // Complex address
}
- if (load_base != NULL) {
- Compile::AliasType* atp = phase->C->alias_type(load_base->adr_type());
- intptr_t cache_offset;
- int shift = -1;
- Node* cache = NULL;
- if (is_autobox_cache(atp)) {
- shift = exact_log2(type2aelembytes(T_OBJECT));
- cache = AddPNode::Ideal_base_and_offset(load_base->in(Address), phase, cache_offset);
- }
- if (cache != NULL && base->in(Address)->is_AddP()) {
+ AddPNode* address = base->in(Address)->as_AddP();
+ Node* cache_base = address->in(AddPNode::Base);
+ if ((cache_base != NULL) && cache_base->is_DecodeN()) {
+ // Get ConP node which is static 'cache' field.
+ cache_base = cache_base->in(1);
+ }
+ if ((cache_base != NULL) && cache_base->is_Con()) {
+ const TypeAryPtr* base_type = cache_base->bottom_type()->isa_aryptr();
+ if ((base_type != NULL) && base_type->is_autobox_cache()) {
Node* elements[4];
- int count = base->in(Address)->as_AddP()->unpack_offsets(elements, ARRAY_SIZE(elements));
- int cache_low;
- if (count > 0 && fetch_autobox_base(atp, cache_low)) {
- int offset = arrayOopDesc::base_offset_in_bytes(memory_type()) - (cache_low << shift);
- // Add up all the offsets making of the address of the load
- Node* result = elements[0];
- for (int i = 1; i < count; i++) {
- result = phase->transform(new (phase->C) AddXNode(result, elements[i]));
+ int shift = exact_log2(type2aelembytes(T_OBJECT));
+ int count = address->unpack_offsets(elements, ARRAY_SIZE(elements));
+ if ((count > 0) && elements[0]->is_Con() &&
+ ((count == 1) ||
+ (count == 2) && elements[1]->Opcode() == Op_LShiftX &&
+ elements[1]->in(2) == phase->intcon(shift))) {
+ ciObjArray* array = base_type->const_oop()->as_obj_array();
+ // Fetch the box object cache[0] at the base of the array and get its value
+ ciInstance* box = array->obj_at(0)->as_instance();
+ ciInstanceKlass* ik = box->klass()->as_instance_klass();
+ assert(ik->is_box_klass(), "sanity");
+ assert(ik->nof_nonstatic_fields() == 1, "change following code");
+ if (ik->nof_nonstatic_fields() == 1) {
+ // This should be true nonstatic_field_at requires calling
+ // nof_nonstatic_fields so check it anyway
+ ciConstant c = box->field_value(ik->nonstatic_field_at(0));
+ BasicType bt = c.basic_type();
+ // Only integer types have boxing cache.
+ assert(bt == T_BOOLEAN || bt == T_CHAR ||
+ bt == T_BYTE || bt == T_SHORT ||
+ bt == T_INT || bt == T_LONG, err_msg_res("wrong type = %s", type2name(bt)));
+ jlong cache_low = (bt == T_LONG) ? c.as_long() : c.as_int();
+ if (cache_low != (int)cache_low) {
+ return NULL; // should not happen since cache is array indexed by value
+ }
+ jlong offset = arrayOopDesc::base_offset_in_bytes(T_OBJECT) - (cache_low << shift);
+ if (offset != (int)offset) {
+ return NULL; // should not happen since cache is array indexed by value
+ }
+ // Add up all the offsets making of the address of the load
+ Node* result = elements[0];
+ for (int i = 1; i < count; i++) {
+ result = phase->transform(new (phase->C) AddXNode(result, elements[i]));
+ }
+ // Remove the constant offset from the address and then
+ result = phase->transform(new (phase->C) AddXNode(result, phase->MakeConX(-(int)offset)));
+ // remove the scaling of the offset to recover the original index.
+ if (result->Opcode() == Op_LShiftX && result->in(2) == phase->intcon(shift)) {
+ // Peel the shift off directly but wrap it in a dummy node
+ // since Ideal can't return existing nodes
+ result = new (phase->C) RShiftXNode(result->in(1), phase->intcon(0));
+ } else if (result->is_Add() && result->in(2)->is_Con() &&
+ result->in(1)->Opcode() == Op_LShiftX &&
+ result->in(1)->in(2) == phase->intcon(shift)) {
+ // We can't do general optimization: ((X<<Z) + Y) >> Z ==> X + (Y>>Z)
+ // but for boxing cache access we know that X<<Z will not overflow
+ // (there is range check) so we do this optimizatrion by hand here.
+ Node* add_con = new (phase->C) RShiftXNode(result->in(2), phase->intcon(shift));
+ result = new (phase->C) AddXNode(result->in(1)->in(1), phase->transform(add_con));
+ } else {
+ result = new (phase->C) RShiftXNode(result, phase->intcon(shift));
+ }
+#ifdef _LP64
+ if (bt != T_LONG) {
+ result = new (phase->C) ConvL2INode(phase->transform(result));
+ }
+#else
+ if (bt == T_LONG) {
+ result = new (phase->C) ConvI2LNode(phase->transform(result));
+ }
+#endif
+ return result;
}
- // Remove the constant offset from the address and then
- // remove the scaling of the offset to recover the original index.
- result = phase->transform(new (phase->C) AddXNode(result, phase->MakeConX(-offset)));
- if (result->Opcode() == Op_LShiftX && result->in(2) == phase->intcon(shift)) {
- // Peel the shift off directly but wrap it in a dummy node
- // since Ideal can't return existing nodes
- result = new (phase->C) RShiftXNode(result->in(1), phase->intcon(0));
- } else {
- result = new (phase->C) RShiftXNode(result, phase->intcon(shift));
- }
-#ifdef _LP64
- result = new (phase->C) ConvL2INode(phase->transform(result));
-#endif
- return result;
}
}
}
@@ -1293,65 +1263,131 @@
return NULL;
}
-//------------------------------split_through_phi------------------------------
-// Split instance field load through Phi.
-Node *LoadNode::split_through_phi(PhaseGVN *phase) {
- Node* mem = in(MemNode::Memory);
- Node* address = in(MemNode::Address);
- const TypePtr *addr_t = phase->type(address)->isa_ptr();
- const TypeOopPtr *t_oop = addr_t->isa_oopptr();
-
- assert(mem->is_Phi() && (t_oop != NULL) &&
- t_oop->is_known_instance_field(), "invalide conditions");
-
- Node *region = mem->in(0);
+static bool stable_phi(PhiNode* phi, PhaseGVN *phase) {
+ Node* region = phi->in(0);
if (region == NULL) {
- return NULL; // Wait stable graph
+ return false; // Wait stable graph
}
- uint cnt = mem->req();
+ uint cnt = phi->req();
for (uint i = 1; i < cnt; i++) {
Node* rc = region->in(i);
if (rc == NULL || phase->type(rc) == Type::TOP)
- return NULL; // Wait stable graph
- Node *in = mem->in(i);
- if (in == NULL) {
+ return false; // Wait stable graph
+ Node* in = phi->in(i);
+ if (in == NULL || phase->type(in) == Type::TOP)
+ return false; // Wait stable graph
+ }
+ return true;
+}
+//------------------------------split_through_phi------------------------------
+// Split instance or boxed field load through Phi.
+Node *LoadNode::split_through_phi(PhaseGVN *phase) {
+ Node* mem = in(Memory);
+ Node* address = in(Address);
+ const TypeOopPtr *t_oop = phase->type(address)->isa_oopptr();
+
+ assert((t_oop != NULL) &&
+ (t_oop->is_known_instance_field() ||
+ t_oop->is_ptr_to_boxed_value()), "invalide conditions");
+
+ Compile* C = phase->C;
+ intptr_t ignore = 0;
+ Node* base = AddPNode::Ideal_base_and_offset(address, phase, ignore);
+ bool base_is_phi = (base != NULL) && base->is_Phi();
+ bool load_boxed_values = t_oop->is_ptr_to_boxed_value() && C->aggressive_unboxing() &&
+ (base != NULL) && (base == address->in(AddPNode::Base)) &&
+ phase->type(base)->higher_equal(TypePtr::NOTNULL);
+
+ if (!((mem->is_Phi() || base_is_phi) &&
+ (load_boxed_values || t_oop->is_known_instance_field()))) {
+ return NULL; // memory is not Phi
+ }
+
+ if (mem->is_Phi()) {
+ if (!stable_phi(mem->as_Phi(), phase)) {
return NULL; // Wait stable graph
}
- }
- // Check for loop invariant.
- if (cnt == 3) {
- for (uint i = 1; i < cnt; i++) {
- Node *in = mem->in(i);
- Node* m = MemNode::optimize_memory_chain(in, addr_t, phase);
- if (m == mem) {
- set_req(MemNode::Memory, mem->in(cnt - i)); // Skip this phi.
- return this;
+ uint cnt = mem->req();
+ // Check for loop invariant memory.
+ if (cnt == 3) {
+ for (uint i = 1; i < cnt; i++) {
+ Node* in = mem->in(i);
+ Node* m = optimize_memory_chain(in, t_oop, this, phase);
+ if (m == mem) {
+ set_req(Memory, mem->in(cnt - i));
+ return this; // made change
+ }
}
}
}
+ if (base_is_phi) {
+ if (!stable_phi(base->as_Phi(), phase)) {
+ return NULL; // Wait stable graph
+ }
+ uint cnt = base->req();
+ // Check for loop invariant memory.
+ if (cnt == 3) {
+ for (uint i = 1; i < cnt; i++) {
+ if (base->in(i) == base) {
+ return NULL; // Wait stable graph
+ }
+ }
+ }
+ }
+
+ bool load_boxed_phi = load_boxed_values && base_is_phi && (base->in(0) == mem->in(0));
+
// Split through Phi (see original code in loopopts.cpp).
- assert(phase->C->have_alias_type(addr_t), "instance should have alias type");
+ assert(C->have_alias_type(t_oop), "instance should have alias type");
// Do nothing here if Identity will find a value
// (to avoid infinite chain of value phis generation).
if (!phase->eqv(this, this->Identity(phase)))
return NULL;
- // Skip the split if the region dominates some control edge of the address.
- if (!MemNode::all_controls_dominate(address, region))
- return NULL;
+ // Select Region to split through.
+ Node* region;
+ if (!base_is_phi) {
+ assert(mem->is_Phi(), "sanity");
+ region = mem->in(0);
+ // Skip if the region dominates some control edge of the address.
+ if (!MemNode::all_controls_dominate(address, region))
+ return NULL;
+ } else if (!mem->is_Phi()) {
+ assert(base_is_phi, "sanity");
+ region = base->in(0);
+ // Skip if the region dominates some control edge of the memory.
+ if (!MemNode::all_controls_dominate(mem, region))
+ return NULL;
+ } else if (base->in(0) != mem->in(0)) {
+ assert(base_is_phi && mem->is_Phi(), "sanity");
+ if (MemNode::all_controls_dominate(mem, base->in(0))) {
+ region = base->in(0);
+ } else if (MemNode::all_controls_dominate(address, mem->in(0))) {
+ region = mem->in(0);
+ } else {
+ return NULL; // complex graph
+ }
+ } else {
+ assert(base->in(0) == mem->in(0), "sanity");
+ region = mem->in(0);
+ }
const Type* this_type = this->bottom_type();
- int this_index = phase->C->get_alias_index(addr_t);
- int this_offset = addr_t->offset();
- int this_iid = addr_t->is_oopptr()->instance_id();
- PhaseIterGVN *igvn = phase->is_IterGVN();
- Node *phi = new (igvn->C) PhiNode(region, this_type, NULL, this_iid, this_index, this_offset);
+ int this_index = C->get_alias_index(t_oop);
+ int this_offset = t_oop->offset();
+ int this_iid = t_oop->instance_id();
+ if (!t_oop->is_known_instance() && load_boxed_values) {
+ // Use _idx of address base for boxed values.
+ this_iid = base->_idx;
+ }
+ PhaseIterGVN* igvn = phase->is_IterGVN();
+ Node* phi = new (C) PhiNode(region, this_type, NULL, this_iid, this_index, this_offset);
for (uint i = 1; i < region->req(); i++) {
- Node *x;
+ Node* x;
Node* the_clone = NULL;
- if (region->in(i) == phase->C->top()) {
- x = phase->C->top(); // Dead path? Use a dead data op
+ if (region->in(i) == C->top()) {
+ x = C->top(); // Dead path? Use a dead data op
} else {
x = this->clone(); // Else clone up the data op
the_clone = x; // Remember for possible deletion.
@@ -1361,10 +1397,16 @@
} else {
x->set_req(0, NULL);
}
- for (uint j = 1; j < this->req(); j++) {
- Node *in = this->in(j);
- if (in->is_Phi() && in->in(0) == region)
- x->set_req(j, in->in(i)); // Use pre-Phi input for the clone
+ if (mem->is_Phi() && (mem->in(0) == region)) {
+ x->set_req(Memory, mem->in(i)); // Use pre-Phi input for the clone.
+ }
+ if (address->is_Phi() && address->in(0) == region) {
+ x->set_req(Address, address->in(i)); // Use pre-Phi input for the clone
+ }
+ if (base_is_phi && (base->in(0) == region)) {
+ Node* base_x = base->in(i); // Clone address for loads from boxed objects.
+ Node* adr_x = phase->transform(new (C) AddPNode(base_x,base_x,address->in(AddPNode::Offset)));
+ x->set_req(Address, adr_x);
}
}
// Check for a 'win' on some paths
@@ -1394,7 +1436,7 @@
if (y != x) {
x = y;
} else {
- y = igvn->hash_find(x);
+ y = igvn->hash_find_insert(x);
if (y) {
x = y;
} else {
@@ -1405,8 +1447,9 @@
}
}
}
- if (x != the_clone && the_clone != NULL)
+ if (x != the_clone && the_clone != NULL) {
igvn->remove_dead_node(the_clone);
+ }
phi->set_req(i, x);
}
// Record Phi
@@ -1445,31 +1488,23 @@
// A method-invariant, non-null address (constant or 'this' argument).
set_req(MemNode::Control, NULL);
}
-
- if (EliminateAutoBox && can_reshape) {
- assert(!phase->type(base)->higher_equal(TypePtr::NULL_PTR), "the autobox pointer should be non-null");
- Compile::AliasType* atp = phase->C->alias_type(adr_type());
- if (is_autobox_object(atp)) {
- Node* result = eliminate_autobox(phase);
- if (result != NULL) return result;
- }
- }
}
Node* mem = in(MemNode::Memory);
const TypePtr *addr_t = phase->type(address)->isa_ptr();
- if (addr_t != NULL) {
+ if (can_reshape && (addr_t != NULL)) {
// try to optimize our memory input
- Node* opt_mem = MemNode::optimize_memory_chain(mem, addr_t, phase);
+ Node* opt_mem = MemNode::optimize_memory_chain(mem, addr_t, this, phase);
if (opt_mem != mem) {
set_req(MemNode::Memory, opt_mem);
if (phase->type( opt_mem ) == Type::TOP) return NULL;
return this;
}
const TypeOopPtr *t_oop = addr_t->isa_oopptr();
- if (can_reshape && opt_mem->is_Phi() &&
- (t_oop != NULL) && t_oop->is_known_instance_field()) {
+ if ((t_oop != NULL) &&
+ (t_oop->is_known_instance_field() ||
+ t_oop->is_ptr_to_boxed_value())) {
PhaseIterGVN *igvn = phase->is_IterGVN();
if (igvn != NULL && igvn->_worklist.member(opt_mem)) {
// Delay this transformation until memory Phi is processed.
@@ -1479,6 +1514,11 @@
// Split instance field load through Phi.
Node* result = split_through_phi(phase);
if (result != NULL) return result;
+
+ if (t_oop->is_ptr_to_boxed_value()) {
+ Node* result = eliminate_autobox(phase);
+ if (result != NULL) return result;
+ }
}
}
@@ -1587,18 +1627,23 @@
// This can happen if a interface-typed array narrows to a class type.
jt = _type;
}
-
- if (EliminateAutoBox && adr->is_AddP()) {
+#ifdef ASSERT
+ if (phase->C->eliminate_boxing() && adr->is_AddP()) {
// The pointers in the autobox arrays are always non-null
Node* base = adr->in(AddPNode::Base);
- if (base != NULL &&
- !phase->type(base)->higher_equal(TypePtr::NULL_PTR)) {
- Compile::AliasType* atp = C->alias_type(base->adr_type());
- if (is_autobox_cache(atp)) {
- return jt->join(TypePtr::NOTNULL)->is_ptr();
+ if ((base != NULL) && base->is_DecodeN()) {
+ // Get LoadN node which loads IntegerCache.cache field
+ base = base->in(1);
+ }
+ if ((base != NULL) && base->is_Con()) {
+ const TypeAryPtr* base_type = base->bottom_type()->isa_aryptr();
+ if ((base_type != NULL) && base_type->is_autobox_cache()) {
+ // It could be narrow oop
+ assert(jt->make_ptr()->ptr() == TypePtr::NotNull,"sanity");
}
}
}
+#endif
return jt;
}
}
@@ -1638,6 +1683,10 @@
// Optimizations for constant objects
ciObject* const_oop = tinst->const_oop();
if (const_oop != NULL) {
+ // For constant Boxed value treat the target field as a compile time constant.
+ if (tinst->is_ptr_to_boxed_value()) {
+ return tinst->get_const_boxed_value();
+ } else
// For constant CallSites treat the target field as a compile time constant.
if (const_oop->is_call_site()) {
ciCallSite* call_site = const_oop->as_call_site();
@@ -1759,7 +1808,8 @@
// (Also allow a variable load from a fresh array to produce zero.)
const TypeOopPtr *tinst = tp->isa_oopptr();
bool is_instance = (tinst != NULL) && tinst->is_known_instance_field();
- if (ReduceFieldZeroing || is_instance) {
+ bool is_boxed_value = (tinst != NULL) && tinst->is_ptr_to_boxed_value();
+ if (ReduceFieldZeroing || is_instance || is_boxed_value) {
Node* value = can_see_stored_value(mem,phase);
if (value != NULL && value->is_Con()) {
assert(value->bottom_type()->higher_equal(_type),"sanity");
@@ -2883,24 +2933,38 @@
if (in(0) && in(0)->is_top()) return NULL;
// Eliminate volatile MemBars for scalar replaced objects.
- if (can_reshape && req() == (Precedent+1) &&
- (Opcode() == Op_MemBarAcquire || Opcode() == Op_MemBarVolatile)) {
- // Volatile field loads and stores.
- Node* my_mem = in(MemBarNode::Precedent);
- if (my_mem != NULL && my_mem->is_Mem()) {
- const TypeOopPtr* t_oop = my_mem->in(MemNode::Address)->bottom_type()->isa_oopptr();
- // Check for scalar replaced object reference.
- if( t_oop != NULL && t_oop->is_known_instance_field() &&
- t_oop->offset() != Type::OffsetBot &&
- t_oop->offset() != Type::OffsetTop) {
- // Replace MemBar projections by its inputs.
- PhaseIterGVN* igvn = phase->is_IterGVN();
- igvn->replace_node(proj_out(TypeFunc::Memory), in(TypeFunc::Memory));
- igvn->replace_node(proj_out(TypeFunc::Control), in(TypeFunc::Control));
- // Must return either the original node (now dead) or a new node
- // (Do not return a top here, since that would break the uniqueness of top.)
- return new (phase->C) ConINode(TypeInt::ZERO);
+ if (can_reshape && req() == (Precedent+1)) {
+ bool eliminate = false;
+ int opc = Opcode();
+ if ((opc == Op_MemBarAcquire || opc == Op_MemBarVolatile)) {
+ // Volatile field loads and stores.
+ Node* my_mem = in(MemBarNode::Precedent);
+ if (my_mem != NULL && my_mem->is_Mem()) {
+ const TypeOopPtr* t_oop = my_mem->in(MemNode::Address)->bottom_type()->isa_oopptr();
+ // Check for scalar replaced object reference.
+ if( t_oop != NULL && t_oop->is_known_instance_field() &&
+ t_oop->offset() != Type::OffsetBot &&
+ t_oop->offset() != Type::OffsetTop) {
+ eliminate = true;
+ }
}
+ } else if (opc == Op_MemBarRelease) {
+ // Final field stores.
+ Node* alloc = AllocateNode::Ideal_allocation(in(MemBarNode::Precedent), phase);
+ if ((alloc != NULL) && alloc->is_Allocate() &&
+ alloc->as_Allocate()->_is_non_escaping) {
+ // The allocated object does not escape.
+ eliminate = true;
+ }
+ }
+ if (eliminate) {
+ // Replace MemBar projections by its inputs.
+ PhaseIterGVN* igvn = phase->is_IterGVN();
+ igvn->replace_node(proj_out(TypeFunc::Memory), in(TypeFunc::Memory));
+ igvn->replace_node(proj_out(TypeFunc::Control), in(TypeFunc::Control));
+ // Must return either the original node (now dead) or a new node
+ // (Do not return a top here, since that would break the uniqueness of top.)
+ return new (phase->C) ConINode(TypeInt::ZERO);
}
}
return NULL;
@@ -3113,9 +3177,7 @@
// within the initialization without creating a vicious cycle, such as:
// { Foo p = new Foo(); p.next = p; }
// True for constants and parameters and small combinations thereof.
-bool InitializeNode::detect_init_independence(Node* n,
- bool st_is_pinned,
- int& count) {
+bool InitializeNode::detect_init_independence(Node* n, int& count) {
if (n == NULL) return true; // (can this really happen?)
if (n->is_Proj()) n = n->in(0);
if (n == this) return false; // found a cycle
@@ -3135,7 +3197,6 @@
// a store is never pinned *before* the availability of its inputs.
if (!MemNode::all_controls_dominate(n, this))
return false; // failed to prove a good control
-
}
// Check data edges for possible dependencies on 'this'.
@@ -3145,7 +3206,7 @@
if (m == NULL || m == n || m->is_top()) continue;
uint first_i = n->find_edge(m);
if (i != first_i) continue; // process duplicate edge just once
- if (!detect_init_independence(m, st_is_pinned, count)) {
+ if (!detect_init_independence(m, count)) {
return false;
}
}
@@ -3176,7 +3237,7 @@
return FAIL; // wrong allocation! (store needs to float up)
Node* val = st->in(MemNode::ValueIn);
int complexity_count = 0;
- if (!detect_init_independence(val, true, complexity_count))
+ if (!detect_init_independence(val, complexity_count))
return FAIL; // stored value must be 'simple enough'
// The Store can be captured only if nothing after the allocation
--- a/hotspot/src/share/vm/opto/memnode.hpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/memnode.hpp Thu May 16 13:47:55 2013 -0700
@@ -75,8 +75,8 @@
PhaseTransform* phase);
static bool adr_phi_is_loop_invariant(Node* adr_phi, Node* cast);
- static Node *optimize_simple_memory_chain(Node *mchain, const TypePtr *t_adr, PhaseGVN *phase);
- static Node *optimize_memory_chain(Node *mchain, const TypePtr *t_adr, PhaseGVN *phase);
+ static Node *optimize_simple_memory_chain(Node *mchain, const TypeOopPtr *t_oop, Node *load, PhaseGVN *phase);
+ static Node *optimize_memory_chain(Node *mchain, const TypePtr *t_adr, Node *load, PhaseGVN *phase);
// This one should probably be a phase-specific function:
static bool all_controls_dominate(Node* dom, Node* sub);
@@ -1099,7 +1099,7 @@
Node* make_raw_address(intptr_t offset, PhaseTransform* phase);
- bool detect_init_independence(Node* n, bool st_is_pinned, int& count);
+ bool detect_init_independence(Node* n, int& count);
void coalesce_subword_stores(intptr_t header_size, Node* size_in_bytes,
PhaseGVN* phase);
--- a/hotspot/src/share/vm/opto/multnode.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/multnode.cpp Thu May 16 13:47:55 2013 -0700
@@ -23,6 +23,7 @@
*/
#include "precompiled.hpp"
+#include "opto/callnode.hpp"
#include "opto/matcher.hpp"
#include "opto/multnode.hpp"
#include "opto/opcodes.hpp"
@@ -73,13 +74,26 @@
return (_con == TypeFunc::Control && def->is_CFG());
}
+const Type* ProjNode::proj_type(const Type* t) const {
+ if (t == Type::TOP) {
+ return Type::TOP;
+ }
+ if (t == Type::BOTTOM) {
+ return Type::BOTTOM;
+ }
+ t = t->is_tuple()->field_at(_con);
+ Node* n = in(0);
+ if ((_con == TypeFunc::Parms) &&
+ n->is_CallStaticJava() && n->as_CallStaticJava()->is_boxing_method()) {
+ // The result of autoboxing is always non-null on normal path.
+ t = t->join(TypePtr::NOTNULL);
+ }
+ return t;
+}
+
const Type *ProjNode::bottom_type() const {
- if (in(0) == NULL) return Type::TOP;
- const Type *tb = in(0)->bottom_type();
- if( tb == Type::TOP ) return Type::TOP;
- if( tb == Type::BOTTOM ) return Type::BOTTOM;
- const TypeTuple *t = tb->is_tuple();
- return t->field_at(_con);
+ if (in(0) == NULL) return Type::TOP;
+ return proj_type(in(0)->bottom_type());
}
const TypePtr *ProjNode::adr_type() const {
@@ -115,11 +129,8 @@
//------------------------------Value------------------------------------------
const Type *ProjNode::Value( PhaseTransform *phase ) const {
- if( !in(0) ) return Type::TOP;
- const Type *t = phase->type(in(0));
- if( t == Type::TOP ) return t;
- if( t == Type::BOTTOM ) return t;
- return t->is_tuple()->field_at(_con);
+ if (in(0) == NULL) return Type::TOP;
+ return proj_type(phase->type(in(0)));
}
//------------------------------out_RegMask------------------------------------
--- a/hotspot/src/share/vm/opto/multnode.hpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/multnode.hpp Thu May 16 13:47:55 2013 -0700
@@ -60,6 +60,7 @@
virtual uint cmp( const Node &n ) const;
virtual uint size_of() const;
void check_con() const; // Called from constructor.
+ const Type* proj_type(const Type* t) const;
public:
ProjNode( Node *src, uint con, bool io_use = false )
@@ -83,6 +84,7 @@
virtual const Type *Value( PhaseTransform *phase ) const;
virtual uint ideal_reg() const;
virtual const RegMask &out_RegMask() const;
+
#ifndef PRODUCT
virtual void dump_spec(outputStream *st) const;
#endif
--- a/hotspot/src/share/vm/opto/node.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/node.cpp Thu May 16 13:47:55 2013 -0700
@@ -67,7 +67,8 @@
}
Compile::set_debug_idx(new_debug_idx);
set_debug_idx( new_debug_idx );
- assert(Compile::current()->unique() < (UINT_MAX - 1), "Node limit exceeded UINT_MAX");
+ assert(Compile::current()->unique() < (INT_MAX - 1), "Node limit exceeded INT_MAX");
+ assert(Compile::current()->live_nodes() < (uint)MaxNodeLimit, "Live Node limit exceeded limit");
if (BreakAtNode != 0 && (_debug_idx == BreakAtNode || (int)_idx == BreakAtNode)) {
tty->print_cr("BreakAtNode: _idx=%d _debug_idx=%d", _idx, _debug_idx);
BREAKPOINT;
@@ -471,9 +472,9 @@
//------------------------------clone------------------------------------------
// Clone a Node.
Node *Node::clone() const {
- Compile *compile = Compile::current();
+ Compile* C = Compile::current();
uint s = size_of(); // Size of inherited Node
- Node *n = (Node*)compile->node_arena()->Amalloc_D(size_of() + _max*sizeof(Node*));
+ Node *n = (Node*)C->node_arena()->Amalloc_D(size_of() + _max*sizeof(Node*));
Copy::conjoint_words_to_lower((HeapWord*)this, (HeapWord*)n, s);
// Set the new input pointer array
n->_in = (Node**)(((char*)n)+s);
@@ -492,18 +493,18 @@
if (x != NULL) x->add_out(n);
}
if (is_macro())
- compile->add_macro_node(n);
+ C->add_macro_node(n);
if (is_expensive())
- compile->add_expensive_node(n);
+ C->add_expensive_node(n);
- n->set_idx(compile->next_unique()); // Get new unique index as well
+ n->set_idx(C->next_unique()); // Get new unique index as well
debug_only( n->verify_construction() );
NOT_PRODUCT(nodes_created++);
// Do not patch over the debug_idx of a clone, because it makes it
// impossible to break on the clone's moment of creation.
//debug_only( n->set_debug_idx( debug_idx() ) );
- compile->copy_node_notes_to(n, (Node*) this);
+ C->copy_node_notes_to(n, (Node*) this);
// MachNode clone
uint nopnds;
@@ -518,13 +519,12 @@
(const void*)(&mthis->_opnds), 1));
mach->_opnds = to;
for ( uint i = 0; i < nopnds; ++i ) {
- to[i] = from[i]->clone(compile);
+ to[i] = from[i]->clone(C);
}
}
// cloning CallNode may need to clone JVMState
if (n->is_Call()) {
- CallNode *call = n->as_Call();
- call->clone_jvms();
+ n->as_Call()->clone_jvms(C);
}
return n; // Return the clone
}
@@ -811,6 +811,21 @@
return nrep;
}
+/**
+ * Replace input edges in the range pointing to 'old' node.
+ */
+int Node::replace_edges_in_range(Node* old, Node* neww, int start, int end) {
+ if (old == neww) return 0; // nothing to do
+ uint nrep = 0;
+ for (int i = start; i < end; i++) {
+ if (in(i) == old) {
+ set_req(i, neww);
+ nrep++;
+ }
+ }
+ return nrep;
+}
+
//-------------------------disconnect_inputs-----------------------------------
// NULL out all inputs to eliminate incoming Def-Use edges.
// Return the number of edges between 'n' and 'this'
@@ -1383,6 +1398,21 @@
return NULL;
}
+
+/**
+ * Return a ptr type for nodes which should have it.
+ */
+const TypePtr* Node::get_ptr_type() const {
+ const TypePtr* tp = this->bottom_type()->make_ptr();
+#ifdef ASSERT
+ if (tp == NULL) {
+ this->dump(1);
+ assert((tp != NULL), "unexpected node type");
+ }
+#endif
+ return tp;
+}
+
// Get a double constant from a ConstNode.
// Returns the constant if it is a double ConstNode
jdouble Node::getd() const {
--- a/hotspot/src/share/vm/opto/node.hpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/node.hpp Thu May 16 13:47:55 2013 -0700
@@ -410,6 +410,7 @@
// Find first occurrence of n among my edges:
int find_edge(Node* n);
int replace_edge(Node* old, Node* neww);
+ int replace_edges_in_range(Node* old, Node* neww, int start, int end);
// NULL out all inputs to eliminate incoming Def-Use edges.
// Return the number of edges between 'n' and 'this'
int disconnect_inputs(Node *n, Compile *c);
@@ -964,6 +965,8 @@
}
const TypeLong* find_long_type() const;
+ const TypePtr* get_ptr_type() const;
+
// These guys are called by code generated by ADLC:
intptr_t get_ptr() const;
intptr_t get_narrowcon() const;
--- a/hotspot/src/share/vm/opto/output.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/output.cpp Thu May 16 13:47:55 2013 -0700
@@ -929,7 +929,7 @@
scval = new_loc_value( _regalloc, obj_reg, Location::oop );
}
} else {
- const TypePtr *tp = obj_node->bottom_type()->make_ptr();
+ const TypePtr *tp = obj_node->get_ptr_type();
scval = new ConstantOopWriteValue(tp->is_oopptr()->const_oop()->constant_encoding());
}
--- a/hotspot/src/share/vm/opto/parse.hpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/parse.hpp Thu May 16 13:47:55 2013 -0700
@@ -330,6 +330,7 @@
bool _wrote_final; // Did we write a final field?
bool _count_invocations; // update and test invocation counter
bool _method_data_update; // update method data oop
+ Node* _alloc_with_final; // An allocation node with final field
// Variables which track Java semantics during bytecode parsing:
@@ -370,6 +371,11 @@
void set_wrote_final(bool z) { _wrote_final = z; }
bool count_invocations() const { return _count_invocations; }
bool method_data_update() const { return _method_data_update; }
+ Node* alloc_with_final() const { return _alloc_with_final; }
+ void set_alloc_with_final(Node* n) {
+ assert((_alloc_with_final == NULL) || (_alloc_with_final == n), "different init objects?");
+ _alloc_with_final = n;
+ }
Block* block() const { return _block; }
ciBytecodeStream& iter() { return _iter; }
@@ -512,7 +518,7 @@
// loading from a constant field or the constant pool
// returns false if push failed (non-perm field constants only, not ldcs)
- bool push_constant(ciConstant con, bool require_constant = false);
+ bool push_constant(ciConstant con, bool require_constant = false, bool is_autobox_cache = false);
// implementation of object creation bytecodes
void emit_guard_for_new(ciInstanceKlass* klass);
--- a/hotspot/src/share/vm/opto/parse1.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/parse1.cpp Thu May 16 13:47:55 2013 -0700
@@ -390,6 +390,7 @@
_expected_uses = expected_uses;
_depth = 1 + (caller->has_method() ? caller->depth() : 0);
_wrote_final = false;
+ _alloc_with_final = NULL;
_entry_bci = InvocationEntryBci;
_tf = NULL;
_block = NULL;
@@ -723,6 +724,8 @@
// Note: iophi and memphi are not transformed until do_exits.
Node* iophi = new (C) PhiNode(region, Type::ABIO);
Node* memphi = new (C) PhiNode(region, Type::MEMORY, TypePtr::BOTTOM);
+ gvn().set_type_bottom(iophi);
+ gvn().set_type_bottom(memphi);
_exits.set_i_o(iophi);
_exits.set_all_memory(memphi);
@@ -738,6 +741,7 @@
}
int ret_size = type2size[ret_type->basic_type()];
Node* ret_phi = new (C) PhiNode(region, ret_type);
+ gvn().set_type_bottom(ret_phi);
_exits.ensure_stack(ret_size);
assert((int)(tf()->range()->cnt() - TypeFunc::Parms) == ret_size, "good tf range");
assert(method()->return_type()->size() == ret_size, "tf agrees w/ method");
@@ -917,7 +921,7 @@
// such unusual early publications. But no barrier is needed on
// exceptional returns, since they cannot publish normally.
//
- _exits.insert_mem_bar(Op_MemBarRelease);
+ _exits.insert_mem_bar(Op_MemBarRelease, alloc_with_final());
#ifndef PRODUCT
if (PrintOpto && (Verbose || WizardMode)) {
method()->print_name();
--- a/hotspot/src/share/vm/opto/parse2.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/parse2.cpp Thu May 16 13:47:55 2013 -0700
@@ -987,7 +987,7 @@
uncommon_trap(Deoptimization::Reason_unreached,
Deoptimization::Action_reinterpret,
NULL, "cold");
- if (EliminateAutoBox) {
+ if (C->eliminate_boxing()) {
// Mark the successor blocks as parsed
branch_block->next_path_num();
next_block->next_path_num();
@@ -1012,7 +1012,7 @@
if (stopped()) { // Path is dead?
explicit_null_checks_elided++;
- if (EliminateAutoBox) {
+ if (C->eliminate_boxing()) {
// Mark the successor block as parsed
branch_block->next_path_num();
}
@@ -1032,7 +1032,7 @@
if (stopped()) { // Path is dead?
explicit_null_checks_elided++;
- if (EliminateAutoBox) {
+ if (C->eliminate_boxing()) {
// Mark the successor block as parsed
next_block->next_path_num();
}
@@ -1069,7 +1069,7 @@
uncommon_trap(Deoptimization::Reason_unreached,
Deoptimization::Action_reinterpret,
NULL, "cold");
- if (EliminateAutoBox) {
+ if (C->eliminate_boxing()) {
// Mark the successor blocks as parsed
branch_block->next_path_num();
next_block->next_path_num();
@@ -1135,7 +1135,7 @@
set_control(taken_branch);
if (stopped()) {
- if (EliminateAutoBox) {
+ if (C->eliminate_boxing()) {
// Mark the successor block as parsed
branch_block->next_path_num();
}
@@ -1154,7 +1154,7 @@
// Branch not taken.
if (stopped()) {
- if (EliminateAutoBox) {
+ if (C->eliminate_boxing()) {
// Mark the successor block as parsed
next_block->next_path_num();
}
--- a/hotspot/src/share/vm/opto/parse3.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/parse3.cpp Thu May 16 13:47:55 2013 -0700
@@ -150,6 +150,23 @@
// final field
if (field->is_static()) {
// final static field
+ if (C->eliminate_boxing()) {
+ // The pointers in the autobox arrays are always non-null.
+ ciSymbol* klass_name = field->holder()->name();
+ if (field->name() == ciSymbol::cache_field_name() &&
+ field->holder()->uses_default_loader() &&
+ (klass_name == ciSymbol::java_lang_Character_CharacterCache() ||
+ klass_name == ciSymbol::java_lang_Byte_ByteCache() ||
+ klass_name == ciSymbol::java_lang_Short_ShortCache() ||
+ klass_name == ciSymbol::java_lang_Integer_IntegerCache() ||
+ klass_name == ciSymbol::java_lang_Long_LongCache())) {
+ bool require_const = true;
+ bool autobox_cache = true;
+ if (push_constant(field->constant_value(), require_const, autobox_cache)) {
+ return;
+ }
+ }
+ }
if (push_constant(field->constant_value()))
return;
}
@@ -304,11 +321,18 @@
// out of the constructor.
if (is_field && field->is_final()) {
set_wrote_final(true);
+ // Preserve allocation ptr to create precedent edge to it in membar
+ // generated on exit from constructor.
+ if (C->eliminate_boxing() &&
+ adr_type->isa_oopptr() && adr_type->is_oopptr()->is_ptr_to_boxed_value() &&
+ AllocateNode::Ideal_allocation(obj, &_gvn) != NULL) {
+ set_alloc_with_final(obj);
+ }
}
}
-bool Parse::push_constant(ciConstant constant, bool require_constant) {
+bool Parse::push_constant(ciConstant constant, bool require_constant, bool is_autobox_cache) {
switch (constant.basic_type()) {
case T_BOOLEAN: push( intcon(constant.as_boolean()) ); break;
case T_INT: push( intcon(constant.as_int()) ); break;
@@ -329,7 +353,7 @@
push( zerocon(T_OBJECT) );
break;
} else if (require_constant || oop_constant->should_be_constant()) {
- push( makecon(TypeOopPtr::make_from_constant(oop_constant, require_constant)) );
+ push( makecon(TypeOopPtr::make_from_constant(oop_constant, require_constant, is_autobox_cache)) );
break;
} else {
// we cannot inline the oop, but we can use it later to narrow a type
--- a/hotspot/src/share/vm/opto/parseHelper.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/parseHelper.cpp Thu May 16 13:47:55 2013 -0700
@@ -284,6 +284,11 @@
klass == C->env()->StringBuffer_klass())) {
C->set_has_stringbuilder(true);
}
+
+ // Keep track of boxed values for EliminateAutoBox optimizations.
+ if (C->eliminate_boxing() && klass->is_box_klass()) {
+ C->set_has_boxed_value(true);
+ }
}
#ifndef PRODUCT
--- a/hotspot/src/share/vm/opto/phase.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/phase.cpp Thu May 16 13:47:55 2013 -0700
@@ -64,6 +64,7 @@
// Subtimers for _t_optimizer
elapsedTimer Phase::_t_iterGVN;
elapsedTimer Phase::_t_iterGVN2;
+elapsedTimer Phase::_t_incrInline;
// Subtimers for _t_registerAllocation
elapsedTimer Phase::_t_ctorChaitin;
@@ -110,6 +111,7 @@
tty->print_cr (" macroEliminate : %3.3f sec", Phase::_t_macroEliminate.seconds());
}
tty->print_cr (" iterGVN : %3.3f sec", Phase::_t_iterGVN.seconds());
+ tty->print_cr (" incrInline : %3.3f sec", Phase::_t_incrInline.seconds());
tty->print_cr (" idealLoop : %3.3f sec", Phase::_t_idealLoop.seconds());
tty->print_cr (" idealLoopVerify: %3.3f sec", Phase::_t_idealLoopVerify.seconds());
tty->print_cr (" ccp : %3.3f sec", Phase::_t_ccp.seconds());
--- a/hotspot/src/share/vm/opto/phase.hpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/phase.hpp Thu May 16 13:47:55 2013 -0700
@@ -100,6 +100,7 @@
// Subtimers for _t_optimizer
static elapsedTimer _t_iterGVN;
static elapsedTimer _t_iterGVN2;
+ static elapsedTimer _t_incrInline;
// Subtimers for _t_registerAllocation
static elapsedTimer _t_ctorChaitin;
--- a/hotspot/src/share/vm/opto/phaseX.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/phaseX.cpp Thu May 16 13:47:55 2013 -0700
@@ -882,7 +882,7 @@
return;
}
Node *n = _worklist.pop();
- if (++loop_count >= K * C->unique()) {
+ if (++loop_count >= K * C->live_nodes()) {
debug_only(n->dump(4);)
assert(false, "infinite loop in PhaseIterGVN::optimize");
C->record_method_not_compilable("infinite loop in PhaseIterGVN::optimize");
--- a/hotspot/src/share/vm/opto/runtime.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/runtime.cpp Thu May 16 13:47:55 2013 -0700
@@ -126,17 +126,15 @@
// This should be called in an assertion at the start of OptoRuntime routines
// which are entered from compiled code (all of them)
-#ifndef PRODUCT
+#ifdef ASSERT
static bool check_compiled_frame(JavaThread* thread) {
assert(thread->last_frame().is_runtime_frame(), "cannot call runtime directly from compiled code");
-#ifdef ASSERT
RegisterMap map(thread, false);
frame caller = thread->last_frame().sender(&map);
assert(caller.is_compiled_frame(), "not being called from compiled like code");
-#endif /* ASSERT */
return true;
}
-#endif
+#endif // ASSERT
#define gen(env, var, type_func_gen, c_func, fancy_jump, pass_tls, save_arg_regs, return_pc) \
--- a/hotspot/src/share/vm/opto/subnode.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/subnode.cpp Thu May 16 13:47:55 2013 -0700
@@ -863,10 +863,11 @@
const TypePtr *r1 = t2->make_ptr();
// Undefined inputs makes for an undefined result
- if( TypePtr::above_centerline(r0->_ptr) ||
- TypePtr::above_centerline(r1->_ptr) )
+ if ((r0 == NULL) || (r1 == NULL) ||
+ TypePtr::above_centerline(r0->_ptr) ||
+ TypePtr::above_centerline(r1->_ptr)) {
return Type::TOP;
-
+ }
if (r0 == r1 && r0->singleton()) {
// Equal pointer constants (klasses, nulls, etc.)
return TypeInt::CC_EQ;
--- a/hotspot/src/share/vm/opto/type.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/type.cpp Thu May 16 13:47:55 2013 -0700
@@ -2372,7 +2372,12 @@
_klass_is_exact(xk),
_is_ptr_to_narrowoop(false),
_is_ptr_to_narrowklass(false),
+ _is_ptr_to_boxed_value(false),
_instance_id(instance_id) {
+ if (Compile::current()->eliminate_boxing() && (t == InstPtr) &&
+ (offset > 0) && xk && (k != 0) && k->is_instance_klass()) {
+ _is_ptr_to_boxed_value = k->as_instance_klass()->is_boxed_value_offset(offset);
+ }
#ifdef _LP64
if (_offset != 0) {
if (_offset == oopDesc::klass_offset_in_bytes()) {
@@ -2613,44 +2618,50 @@
//------------------------------make_from_constant-----------------------------
// Make a java pointer from an oop constant
-const TypeOopPtr* TypeOopPtr::make_from_constant(ciObject* o, bool require_constant) {
- assert(!o->is_null_object(), "null object not yet handled here.");
- ciKlass* klass = o->klass();
- if (klass->is_instance_klass()) {
- // Element is an instance
- if (require_constant) {
- if (!o->can_be_constant()) return NULL;
- } else if (!o->should_be_constant()) {
- return TypeInstPtr::make(TypePtr::NotNull, klass, true, NULL, 0);
- }
- return TypeInstPtr::make(o);
- } else if (klass->is_obj_array_klass()) {
- // Element is an object array. Recursively call ourself.
- const Type *etype =
+const TypeOopPtr* TypeOopPtr::make_from_constant(ciObject* o,
+ bool require_constant,
+ bool is_autobox_cache) {
+ assert(!o->is_null_object(), "null object not yet handled here.");
+ ciKlass* klass = o->klass();
+ if (klass->is_instance_klass()) {
+ // Element is an instance
+ if (require_constant) {
+ if (!o->can_be_constant()) return NULL;
+ } else if (!o->should_be_constant()) {
+ return TypeInstPtr::make(TypePtr::NotNull, klass, true, NULL, 0);
+ }
+ return TypeInstPtr::make(o);
+ } else if (klass->is_obj_array_klass()) {
+ // Element is an object array. Recursively call ourself.
+ const TypeOopPtr *etype =
TypeOopPtr::make_from_klass_raw(klass->as_obj_array_klass()->element_klass());
- const TypeAry* arr0 = TypeAry::make(etype, TypeInt::make(o->as_array()->length()));
- // We used to pass NotNull in here, asserting that the sub-arrays
- // are all not-null. This is not true in generally, as code can
- // slam NULLs down in the subarrays.
- if (require_constant) {
- if (!o->can_be_constant()) return NULL;
- } else if (!o->should_be_constant()) {
- return TypeAryPtr::make(TypePtr::NotNull, arr0, klass, true, 0);
- }
- const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0);
+ if (is_autobox_cache) {
+ // The pointers in the autobox arrays are always non-null.
+ etype = etype->cast_to_ptr_type(TypePtr::NotNull)->is_oopptr();
+ }
+ const TypeAry* arr0 = TypeAry::make(etype, TypeInt::make(o->as_array()->length()));
+ // We used to pass NotNull in here, asserting that the sub-arrays
+ // are all not-null. This is not true in generally, as code can
+ // slam NULLs down in the subarrays.
+ if (require_constant) {
+ if (!o->can_be_constant()) return NULL;
+ } else if (!o->should_be_constant()) {
+ return TypeAryPtr::make(TypePtr::NotNull, arr0, klass, true, 0);
+ }
+ const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0, InstanceBot, is_autobox_cache);
return arr;
- } else if (klass->is_type_array_klass()) {
- // Element is an typeArray
+ } else if (klass->is_type_array_klass()) {
+ // Element is an typeArray
const Type* etype =
(Type*)get_const_basic_type(klass->as_type_array_klass()->element_type());
- const TypeAry* arr0 = TypeAry::make(etype, TypeInt::make(o->as_array()->length()));
- // We used to pass NotNull in here, asserting that the array pointer
- // is not-null. That was not true in general.
- if (require_constant) {
- if (!o->can_be_constant()) return NULL;
- } else if (!o->should_be_constant()) {
- return TypeAryPtr::make(TypePtr::NotNull, arr0, klass, true, 0);
- }
+ const TypeAry* arr0 = TypeAry::make(etype, TypeInt::make(o->as_array()->length()));
+ // We used to pass NotNull in here, asserting that the array pointer
+ // is not-null. That was not true in general.
+ if (require_constant) {
+ if (!o->can_be_constant()) return NULL;
+ } else if (!o->should_be_constant()) {
+ return TypeAryPtr::make(TypePtr::NotNull, arr0, klass, true, 0);
+ }
const TypeAryPtr* arr = TypeAryPtr::make(TypePtr::Constant, o, arr0, klass, true, 0);
return arr;
}
@@ -2856,6 +2867,28 @@
return result;
}
+/**
+ * Create constant type for a constant boxed value
+ */
+const Type* TypeInstPtr::get_const_boxed_value() const {
+ assert(is_ptr_to_boxed_value(), "should be called only for boxed value");
+ assert((const_oop() != NULL), "should be called only for constant object");
+ ciConstant constant = const_oop()->as_instance()->field_value_by_offset(offset());
+ BasicType bt = constant.basic_type();
+ switch (bt) {
+ case T_BOOLEAN: return TypeInt::make(constant.as_boolean());
+ case T_INT: return TypeInt::make(constant.as_int());
+ case T_CHAR: return TypeInt::make(constant.as_char());
+ case T_BYTE: return TypeInt::make(constant.as_byte());
+ case T_SHORT: return TypeInt::make(constant.as_short());
+ case T_FLOAT: return TypeF::make(constant.as_float());
+ case T_DOUBLE: return TypeD::make(constant.as_double());
+ case T_LONG: return TypeLong::make(constant.as_long());
+ default: break;
+ }
+ fatal(err_msg_res("Invalid boxed value type '%s'", type2name(bt)));
+ return NULL;
+}
//------------------------------cast_to_ptr_type-------------------------------
const Type *TypeInstPtr::cast_to_ptr_type(PTR ptr) const {
@@ -3330,18 +3363,18 @@
if (!xk) xk = ary->ary_must_be_exact();
assert(instance_id <= 0 || xk || !UseExactTypes, "instances are always exactly typed");
if (!UseExactTypes) xk = (ptr == Constant);
- return (TypeAryPtr*)(new TypeAryPtr(ptr, NULL, ary, k, xk, offset, instance_id))->hashcons();
+ return (TypeAryPtr*)(new TypeAryPtr(ptr, NULL, ary, k, xk, offset, instance_id, false))->hashcons();
}
//------------------------------make-------------------------------------------
-const TypeAryPtr *TypeAryPtr::make( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id ) {
+const TypeAryPtr *TypeAryPtr::make( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id, bool is_autobox_cache) {
assert(!(k == NULL && ary->_elem->isa_int()),
"integral arrays must be pre-equipped with a class");
assert( (ptr==Constant && o) || (ptr!=Constant && !o), "" );
if (!xk) xk = (o != NULL) || ary->ary_must_be_exact();
assert(instance_id <= 0 || xk || !UseExactTypes, "instances are always exactly typed");
if (!UseExactTypes) xk = (ptr == Constant);
- return (TypeAryPtr*)(new TypeAryPtr(ptr, o, ary, k, xk, offset, instance_id))->hashcons();
+ return (TypeAryPtr*)(new TypeAryPtr(ptr, o, ary, k, xk, offset, instance_id, is_autobox_cache))->hashcons();
}
//------------------------------cast_to_ptr_type-------------------------------
@@ -3397,8 +3430,20 @@
jint max_hi = max_array_length(elem()->basic_type());
//if (index_not_size) --max_hi; // type of a valid array index, FTR
bool chg = false;
- if (lo < min_lo) { lo = min_lo; chg = true; }
- if (hi > max_hi) { hi = max_hi; chg = true; }
+ if (lo < min_lo) {
+ lo = min_lo;
+ if (size->is_con()) {
+ hi = lo;
+ }
+ chg = true;
+ }
+ if (hi > max_hi) {
+ hi = max_hi;
+ if (size->is_con()) {
+ lo = hi;
+ }
+ chg = true;
+ }
// Negative length arrays will produce weird intermediate dead fast-path code
if (lo > hi)
return TypeInt::ZERO;
@@ -3630,7 +3675,7 @@
//------------------------------xdual------------------------------------------
// Dual: compute field-by-field dual
const Type *TypeAryPtr::xdual() const {
- return new TypeAryPtr( dual_ptr(), _const_oop, _ary->dual()->is_ary(),_klass, _klass_is_exact, dual_offset(), dual_instance_id() );
+ return new TypeAryPtr( dual_ptr(), _const_oop, _ary->dual()->is_ary(),_klass, _klass_is_exact, dual_offset(), dual_instance_id(), is_autobox_cache() );
}
//----------------------interface_vs_oop---------------------------------------
--- a/hotspot/src/share/vm/opto/type.hpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/opto/type.hpp Thu May 16 13:47:55 2013 -0700
@@ -234,6 +234,9 @@
bool is_ptr_to_narrowoop() const;
bool is_ptr_to_narrowklass() const;
+ bool is_ptr_to_boxing_obj() const;
+
+
// Convenience access
float getf() const;
double getd() const;
@@ -794,6 +797,7 @@
bool _klass_is_exact;
bool _is_ptr_to_narrowoop;
bool _is_ptr_to_narrowklass;
+ bool _is_ptr_to_boxed_value;
// If not InstanceTop or InstanceBot, indicates that this is
// a particular instance of this type which is distinct.
@@ -826,7 +830,9 @@
// If the object cannot be rendered as a constant,
// may return a non-singleton type.
// If require_constant, produce a NULL if a singleton is not possible.
- static const TypeOopPtr* make_from_constant(ciObject* o, bool require_constant = false);
+ static const TypeOopPtr* make_from_constant(ciObject* o,
+ bool require_constant = false,
+ bool not_null_elements = false);
// Make a generic (unclassed) pointer to an oop.
static const TypeOopPtr* make(PTR ptr, int offset, int instance_id);
@@ -839,7 +845,7 @@
// compressed oop references.
bool is_ptr_to_narrowoop_nv() const { return _is_ptr_to_narrowoop; }
bool is_ptr_to_narrowklass_nv() const { return _is_ptr_to_narrowklass; }
-
+ bool is_ptr_to_boxed_value() const { return _is_ptr_to_boxed_value; }
bool is_known_instance() const { return _instance_id > 0; }
int instance_id() const { return _instance_id; }
bool is_known_instance_field() const { return is_known_instance() && _offset >= 0; }
@@ -912,6 +918,9 @@
// Make a pointer to an oop.
static const TypeInstPtr *make(PTR ptr, ciKlass* k, bool xk, ciObject* o, int offset, int instance_id = InstanceBot );
+ /** Create constant type for a constant boxed value */
+ const Type* get_const_boxed_value() const;
+
// If this is a java.lang.Class constant, return the type for it or NULL.
// Pass to Type::get_const_type to turn it to a type, which will usually
// be a TypeInstPtr, but may also be a TypeInt::INT for int.class, etc.
@@ -943,7 +952,12 @@
//------------------------------TypeAryPtr-------------------------------------
// Class of Java array pointers
class TypeAryPtr : public TypeOopPtr {
- TypeAryPtr( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id ) : TypeOopPtr(AryPtr,ptr,k,xk,o,offset, instance_id), _ary(ary) {
+ TypeAryPtr( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk,
+ int offset, int instance_id, bool is_autobox_cache )
+ : TypeOopPtr(AryPtr,ptr,k,xk,o,offset, instance_id),
+ _ary(ary),
+ _is_autobox_cache(is_autobox_cache)
+ {
#ifdef ASSERT
if (k != NULL) {
// Verify that specified klass and TypeAryPtr::klass() follow the same rules.
@@ -964,6 +978,7 @@
virtual bool eq( const Type *t ) const;
virtual int hash() const; // Type specific hashing
const TypeAry *_ary; // Array we point into
+ const bool _is_autobox_cache;
ciKlass* compute_klass(DEBUG_ONLY(bool verify = false)) const;
@@ -974,9 +989,11 @@
const Type* elem() const { return _ary->_elem; }
const TypeInt* size() const { return _ary->_size; }
+ bool is_autobox_cache() const { return _is_autobox_cache; }
+
static const TypeAryPtr *make( PTR ptr, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id = InstanceBot);
// Constant pointer to array
- static const TypeAryPtr *make( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id = InstanceBot);
+ static const TypeAryPtr *make( PTR ptr, ciObject* o, const TypeAry *ary, ciKlass* k, bool xk, int offset, int instance_id = InstanceBot, bool is_autobox_cache = false);
// Return a 'ptr' version of this type
virtual const Type *cast_to_ptr_type(PTR ptr) const;
@@ -1504,6 +1521,13 @@
return false;
}
+inline bool Type::is_ptr_to_boxing_obj() const {
+ const TypeInstPtr* tp = isa_instptr();
+ return (tp != NULL) && (tp->offset() == 0) &&
+ tp->klass()->is_instance_klass() &&
+ tp->klass()->as_instance_klass()->is_box_klass();
+}
+
// ===============================================================
// Things that need to be 64-bits in the 64-bit build but
--- a/hotspot/src/share/vm/prims/methodHandles.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/prims/methodHandles.cpp Thu May 16 13:47:55 2013 -0700
@@ -1306,6 +1306,28 @@
}
JVM_END
+/**
+ * Throws a java/lang/UnsupportedOperationException unconditionally.
+ * This is required by the specification of MethodHandle.invoke if
+ * invoked directly.
+ */
+JVM_ENTRY(jobject, MH_invoke_UOE(JNIEnv* env, jobject mh, jobjectArray args)) {
+ THROW_MSG_NULL(vmSymbols::java_lang_UnsupportedOperationException(), "MethodHandle.invoke cannot be invoked reflectively");
+ return NULL;
+}
+JVM_END
+
+/**
+ * Throws a java/lang/UnsupportedOperationException unconditionally.
+ * This is required by the specification of MethodHandle.invokeExact if
+ * invoked directly.
+ */
+JVM_ENTRY(jobject, MH_invokeExact_UOE(JNIEnv* env, jobject mh, jobjectArray args)) {
+ THROW_MSG_NULL(vmSymbols::java_lang_UnsupportedOperationException(), "MethodHandle.invokeExact cannot be invoked reflectively");
+ return NULL;
+}
+JVM_END
+
/// JVM_RegisterMethodHandleMethods
#undef CS // Solaris builds complain
@@ -1325,7 +1347,7 @@
#define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
// These are the native methods on java.lang.invoke.MethodHandleNatives.
-static JNINativeMethod required_methods_JDK8[] = {
+static JNINativeMethod MHN_methods[] = {
{CC"init", CC"("MEM""OBJ")V", FN_PTR(MHN_init_Mem)},
{CC"expand", CC"("MEM")V", FN_PTR(MHN_expand_Mem)},
{CC"resolve", CC"("MEM""CLS")"MEM, FN_PTR(MHN_resolve_Mem)},
@@ -1343,8 +1365,28 @@
{CC"getMemberVMInfo", CC"("MEM")"OBJ, FN_PTR(MHN_getMemberVMInfo)}
};
-// This one function is exported, used by NativeLookup.
+static JNINativeMethod MH_methods[] = {
+ // UnsupportedOperationException throwers
+ {CC"invoke", CC"(["OBJ")"OBJ, FN_PTR(MH_invoke_UOE)},
+ {CC"invokeExact", CC"(["OBJ")"OBJ, FN_PTR(MH_invokeExact_UOE)}
+};
+/**
+ * Helper method to register native methods.
+ */
+static bool register_natives(JNIEnv* env, jclass clazz, const JNINativeMethod* methods, jint nMethods) {
+ int status = env->RegisterNatives(clazz, methods, nMethods);
+ if (status != JNI_OK || env->ExceptionOccurred()) {
+ warning("JSR 292 method handle code is mismatched to this JVM. Disabling support.");
+ env->ExceptionClear();
+ return false;
+ }
+ return true;
+}
+
+/**
+ * This one function is exported, used by NativeLookup.
+ */
JVM_ENTRY(void, JVM_RegisterMethodHandleMethods(JNIEnv *env, jclass MHN_class)) {
if (!EnableInvokeDynamic) {
warning("JSR 292 is disabled in this JVM. Use -XX:+UnlockDiagnosticVMOptions -XX:+EnableInvokeDynamic to enable.");
@@ -1362,16 +1404,14 @@
MH_class = (jclass) JNIHandles::make_local(env, mirror);
}
- int status;
-
if (enable_MH) {
ThreadToNativeFromVM ttnfv(thread);
- status = env->RegisterNatives(MHN_class, required_methods_JDK8, sizeof(required_methods_JDK8)/sizeof(JNINativeMethod));
- if (status != JNI_OK || env->ExceptionOccurred()) {
- warning("JSR 292 method handle code is mismatched to this JVM. Disabling support.");
- enable_MH = false;
- env->ExceptionClear();
+ if (enable_MH) {
+ enable_MH = register_natives(env, MHN_class, MHN_methods, sizeof(MHN_methods)/sizeof(JNINativeMethod));
+ }
+ if (enable_MH) {
+ enable_MH = register_natives(env, MH_class, MH_methods, sizeof(MH_methods)/sizeof(JNINativeMethod));
}
}
--- a/hotspot/src/share/vm/prims/nativeLookup.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/prims/nativeLookup.cpp Thu May 16 13:47:55 2013 -0700
@@ -383,10 +383,7 @@
address NativeLookup::lookup(methodHandle method, bool& in_base_library, TRAPS) {
if (!method->has_native_function()) {
- address entry =
- method->intrinsic_id() == vmIntrinsics::_invokeGeneric ?
- SharedRuntime::native_method_throw_unsupported_operation_exception_entry() :
- lookup_base(method, in_base_library, CHECK_NULL);
+ address entry = lookup_base(method, in_base_library, CHECK_NULL);
method->set_native_function(entry,
Method::native_bind_event_is_interesting);
// -verbose:jni printing
--- a/hotspot/src/share/vm/runtime/arguments.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/runtime/arguments.cpp Thu May 16 13:47:55 2013 -0700
@@ -1089,6 +1089,10 @@
if (FLAG_IS_DEFAULT(ReservedCodeCacheSize)) {
FLAG_SET_DEFAULT(ReservedCodeCacheSize, ReservedCodeCacheSize * 5);
}
+ if (!UseInterpreter) { // -Xcomp
+ Tier3InvokeNotifyFreqLog = 0;
+ Tier4InvocationThreshold = 0;
+ }
}
#if INCLUDE_ALL_GCS
@@ -1669,6 +1673,20 @@
// Aggressive optimization flags -XX:+AggressiveOpts
void Arguments::set_aggressive_opts_flags() {
#ifdef COMPILER2
+ if (AggressiveUnboxing) {
+ if (FLAG_IS_DEFAULT(EliminateAutoBox)) {
+ FLAG_SET_DEFAULT(EliminateAutoBox, true);
+ } else if (!EliminateAutoBox) {
+ // warning("AggressiveUnboxing is disabled because EliminateAutoBox is disabled");
+ AggressiveUnboxing = false;
+ }
+ if (FLAG_IS_DEFAULT(DoEscapeAnalysis)) {
+ FLAG_SET_DEFAULT(DoEscapeAnalysis, true);
+ } else if (!DoEscapeAnalysis) {
+ // warning("AggressiveUnboxing is disabled because DoEscapeAnalysis is disabled");
+ AggressiveUnboxing = false;
+ }
+ }
if (AggressiveOpts || !FLAG_IS_DEFAULT(AutoBoxCacheMax)) {
if (FLAG_IS_DEFAULT(EliminateAutoBox)) {
FLAG_SET_DEFAULT(EliminateAutoBox, true);
--- a/hotspot/src/share/vm/runtime/sharedRuntime.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/runtime/sharedRuntime.cpp Thu May 16 13:47:55 2013 -0700
@@ -883,15 +883,23 @@
}
-JNI_ENTRY(void, throw_unsatisfied_link_error(JNIEnv* env, ...))
+/**
+ * Throws an java/lang/UnsatisfiedLinkError. The address of this method is
+ * installed in the native function entry of all native Java methods before
+ * they get linked to their actual native methods.
+ *
+ * \note
+ * This method actually never gets called! The reason is because
+ * the interpreter's native entries call NativeLookup::lookup() which
+ * throws the exception when the lookup fails. The exception is then
+ * caught and forwarded on the return from NativeLookup::lookup() call
+ * before the call to the native function. This might change in the future.
+ */
+JNI_ENTRY(void*, throw_unsatisfied_link_error(JNIEnv* env, ...))
{
- THROW(vmSymbols::java_lang_UnsatisfiedLinkError());
-}
-JNI_END
-
-JNI_ENTRY(void, throw_unsupported_operation_exception(JNIEnv* env, ...))
-{
- THROW(vmSymbols::java_lang_UnsupportedOperationException());
+ // We return a bad value here to make sure that the exception is
+ // forwarded before we look at the return value.
+ THROW_(vmSymbols::java_lang_UnsatisfiedLinkError(), (void*)badJNIHandle);
}
JNI_END
@@ -899,10 +907,6 @@
return CAST_FROM_FN_PTR(address, &throw_unsatisfied_link_error);
}
-address SharedRuntime::native_method_throw_unsupported_operation_exception_entry() {
- return CAST_FROM_FN_PTR(address, &throw_unsupported_operation_exception);
-}
-
#ifndef PRODUCT
JRT_ENTRY(intptr_t, SharedRuntime::trace_bytecode(JavaThread* thread, intptr_t preserve_this_value, intptr_t tos, intptr_t tos2))
--- a/hotspot/src/share/vm/runtime/vmStructs.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/runtime/vmStructs.cpp Thu May 16 13:47:55 2013 -0700
@@ -1057,6 +1057,7 @@
c2_nonstatic_field(Compile, _save_argument_registers, const bool) \
c2_nonstatic_field(Compile, _subsume_loads, const bool) \
c2_nonstatic_field(Compile, _do_escape_analysis, const bool) \
+ c2_nonstatic_field(Compile, _eliminate_boxing, const bool) \
c2_nonstatic_field(Compile, _ilt, InlineTree*) \
\
c2_nonstatic_field(InlineTree, _caller_jvms, JVMState*) \
--- a/hotspot/src/share/vm/utilities/quickSort.cpp Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/src/share/vm/utilities/quickSort.cpp Thu May 16 13:47:55 2013 -0700
@@ -34,6 +34,7 @@
#include "memory/allocation.inline.hpp"
#include <stdlib.h>
+#ifdef ASSERT
static int test_comparator(int a, int b) {
if (a == b) {
return 0;
@@ -43,6 +44,7 @@
}
return 1;
}
+#endif // ASSERT
static int test_even_odd_comparator(int a, int b) {
bool a_is_odd = (a % 2) == 1;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/6934604/TestByteBoxing.java Thu May 16 13:47:55 2013 -0700
@@ -0,0 +1,777 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 6934604
+ * @summary enable parts of EliminateAutoBox by default
+ * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox TestByteBoxing
+ * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox
+ * -XX:CompileCommand=exclude,TestByteBoxing.dummy -XX:CompileCommand=exclude,TestByteBoxing.foo -XX:CompileCommand=exclude,TestByteBoxing.foob TestByteBoxing
+ * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-EliminateAutoBox
+ * -XX:CompileCommand=exclude,TestByteBoxing.dummy -XX:CompileCommand=exclude,TestByteBoxing.foo -XX:CompileCommand=exclude,TestByteBoxing.foob TestByteBoxing
+ *
+ */
+
+public class TestByteBoxing {
+
+ static final Byte ibc = new Byte((byte)1);
+
+ //===============================================
+ // Non-inlined methods to test deoptimization info
+ static void dummy() { }
+ static byte foo(byte i) { return i; }
+ static Byte foob(byte i) { return Byte.valueOf(i); }
+
+
+ static byte simple(byte i) {
+ Byte ib = new Byte(i);
+ return ib;
+ }
+
+ static byte simpleb(byte i) {
+ Byte ib = Byte.valueOf(i);
+ return ib;
+ }
+
+ static byte simplec() {
+ Byte ib = ibc;
+ return ib;
+ }
+
+ static byte simplef(byte i) {
+ Byte ib = foob(i);
+ return ib;
+ }
+
+ static byte simplep(Byte ib) {
+ return ib;
+ }
+
+ static byte simple2(byte i) {
+ Byte ib1 = new Byte(i);
+ Byte ib2 = new Byte((byte)(i+1));
+ return (byte)(ib1 + ib2);
+ }
+
+ static byte simpleb2(byte i) {
+ Byte ib1 = Byte.valueOf(i);
+ Byte ib2 = Byte.valueOf((byte)(i+1));
+ return (byte)(ib1 + ib2);
+ }
+
+ static byte simplem2(byte i) {
+ Byte ib1 = new Byte(i);
+ Byte ib2 = Byte.valueOf((byte)(i+1));
+ return (byte)(ib1 + ib2);
+ }
+
+ static byte simplep2(byte i, Byte ib1) {
+ Byte ib2 = Byte.valueOf((byte)(i+1));
+ return (byte)(ib1 + ib2);
+ }
+
+ static byte simplec2(byte i) {
+ Byte ib1 = ibc;
+ Byte ib2 = Byte.valueOf((byte)(i+1));
+ return (byte)(ib1 + ib2);
+ }
+
+ //===============================================
+ static byte test(byte i) {
+ Byte ib = new Byte(i);
+ if ((i&1) == 0)
+ ib = (byte)(i+1);
+ return ib;
+ }
+
+ static byte testb(byte i) {
+ Byte ib = i;
+ if ((i&1) == 0)
+ ib = (byte)(i+1);
+ return ib;
+ }
+
+ static byte testm(byte i) {
+ Byte ib = i;
+ if ((i&1) == 0)
+ ib = new Byte((byte)(i+1));
+ return ib;
+ }
+
+ static byte testp(byte i, Byte ib) {
+ if ((i&1) == 0)
+ ib = new Byte((byte)(i+1));
+ return ib;
+ }
+
+ static byte testc(byte i) {
+ Byte ib = ibc;
+ if ((i&1) == 0)
+ ib = new Byte((byte)(i+1));
+ return ib;
+ }
+
+ static byte test2(byte i) {
+ Byte ib1 = new Byte(i);
+ Byte ib2 = new Byte((byte)(i+1));
+ if ((i&1) == 0) {
+ ib1 = new Byte((byte)(i+1));
+ ib2 = new Byte((byte)(i+2));
+ }
+ return (byte)(ib1+ib2);
+ }
+
+ static byte testb2(byte i) {
+ Byte ib1 = i;
+ Byte ib2 = (byte)(i+1);
+ if ((i&1) == 0) {
+ ib1 = (byte)(i+1);
+ ib2 = (byte)(i+2);
+ }
+ return (byte)(ib1 + ib2);
+ }
+
+ static byte testm2(byte i) {
+ Byte ib1 = new Byte(i);
+ Byte ib2 = (byte)(i+1);
+ if ((i&1) == 0) {
+ ib1 = new Byte((byte)(i+1));
+ ib2 = (byte)(i+2);
+ }
+ return (byte)(ib1 + ib2);
+ }
+
+ static byte testp2(byte i, Byte ib1) {
+ Byte ib2 = (byte)(i+1);
+ if ((i&1) == 0) {
+ ib1 = new Byte((byte)(i+1));
+ ib2 = (byte)(i+2);
+ }
+ return (byte)(ib1 + ib2);
+ }
+
+ static byte testc2(byte i) {
+ Byte ib1 = ibc;
+ Byte ib2 = (byte)(i+1);
+ if ((i&1) == 0) {
+ ib1 = (byte)(ibc+1);
+ ib2 = (byte)(i+2);
+ }
+ return (byte)(ib1 + ib2);
+ }
+
+ //===============================================
+ static byte sum(byte[] a) {
+ byte result = 1;
+ for (Byte i : a)
+ result += i;
+ return result;
+ }
+
+ static byte sumb(byte[] a) {
+ Byte result = 1;
+ for (Byte i : a)
+ result = (byte)(result + i);
+ return result;
+ }
+
+ static byte sumc(byte[] a) {
+ Byte result = ibc;
+ for (Byte i : a)
+ result = (byte)(result + i);
+ return result;
+ }
+
+ static byte sumf(byte[] a) {
+ Byte result = foob((byte)1);
+ for (Byte i : a)
+ result = (byte)(result + i);
+ return result;
+ }
+
+ static byte sump(byte[] a, Byte result) {
+ for (Byte i : a)
+ result = (byte)(result + i);
+ return result;
+ }
+
+ static byte sum2(byte[] a) {
+ byte result1 = 1;
+ byte result2 = 1;
+ for (Byte i : a) {
+ result1 += i;
+ result2 += i + 1;
+ }
+ return (byte)(result1 + result2);
+ }
+
+ static byte sumb2(byte[] a) {
+ Byte result1 = 1;
+ Byte result2 = 1;
+ for (Byte i : a) {
+ result1 = (byte)(result1 + i);
+ result2 = (byte)(result2 + i + 1);
+ }
+ return (byte)(result1 + result2);
+ }
+
+ static byte summ2(byte[] a) {
+ Byte result1 = 1;
+ Byte result2 = new Byte((byte)1);
+ for (Byte i : a) {
+ result1 = (byte)(result1 + i);
+ result2 = (byte)(result2 + new Byte((byte)(i + 1)));
+ }
+ return (byte)(result1 + result2);
+ }
+
+ static byte sump2(byte[] a, Byte result2) {
+ Byte result1 = 1;
+ for (Byte i : a) {
+ result1 = (byte)(result1 + i);
+ result2 = (byte)(result2 + i + 1);
+ }
+ return (byte)(result1 + result2);
+ }
+
+ static byte sumc2(byte[] a) {
+ Byte result1 = 1;
+ Byte result2 = ibc;
+ for (Byte i : a) {
+ result1 = (byte)(result1 + i);
+ result2 = (byte)(result2 + i + ibc);
+ }
+ return (byte)(result1 + result2);
+ }
+
+ //===============================================
+ static byte remi_sum() {
+ Byte j = new Byte((byte)1);
+ for (int i = 0; i< 1000; i++) {
+ j = new Byte((byte)(j + 1));
+ }
+ return j;
+ }
+
+ static byte remi_sumb() {
+ Byte j = Byte.valueOf((byte)1);
+ for (int i = 0; i< 1000; i++) {
+ j = (byte)(j + 1);
+ }
+ return j;
+ }
+
+ static byte remi_sumf() {
+ Byte j = foob((byte)1);
+ for (int i = 0; i< 1000; i++) {
+ j = (byte)(j + 1);
+ }
+ return j;
+ }
+
+ static byte remi_sump(Byte j) {
+ for (int i = 0; i< 1000; i++) {
+ j = new Byte((byte)(j + 1));
+ }
+ return j;
+ }
+
+ static byte remi_sumc() {
+ Byte j = ibc;
+ for (int i = 0; i< 1000; i++) {
+ j = (byte)(j + ibc);
+ }
+ return j;
+ }
+
+ static byte remi_sum2() {
+ Byte j1 = new Byte((byte)1);
+ Byte j2 = new Byte((byte)1);
+ for (int i = 0; i< 1000; i++) {
+ j1 = new Byte((byte)(j1 + 1));
+ j2 = new Byte((byte)(j2 + 2));
+ }
+ return (byte)(j1 + j2);
+ }
+
+ static byte remi_sumb2() {
+ Byte j1 = Byte.valueOf((byte)1);
+ Byte j2 = Byte.valueOf((byte)1);
+ for (int i = 0; i< 1000; i++) {
+ j1 = (byte)(j1 + 1);
+ j2 = (byte)(j2 + 2);
+ }
+ return (byte)(j1 + j2);
+ }
+
+ static byte remi_summ2() {
+ Byte j1 = new Byte((byte)1);
+ Byte j2 = Byte.valueOf((byte)1);
+ for (int i = 0; i< 1000; i++) {
+ j1 = new Byte((byte)(j1 + 1));
+ j2 = (byte)(j2 + 2);
+ }
+ return (byte)(j1 + j2);
+ }
+
+ static byte remi_sump2(Byte j1) {
+ Byte j2 = Byte.valueOf((byte)1);
+ for (int i = 0; i< 1000; i++) {
+ j1 = new Byte((byte)(j1 + 1));
+ j2 = (byte)(j2 + 2);
+ }
+ return (byte)(j1 + j2);
+ }
+
+ static byte remi_sumc2() {
+ Byte j1 = ibc;
+ Byte j2 = Byte.valueOf((byte)1);
+ for (int i = 0; i< 1000; i++) {
+ j1 = (byte)(j1 + ibc);
+ j2 = (byte)(j2 + 2);
+ }
+ return (byte)(j1 + j2);
+ }
+
+
+ //===============================================
+ // Safepointa and debug info for deoptimization
+ static byte simple_deop(byte i) {
+ Byte ib = new Byte(foo(i));
+ dummy();
+ return ib;
+ }
+
+ static byte simpleb_deop(byte i) {
+ Byte ib = Byte.valueOf(foo(i));
+ dummy();
+ return ib;
+ }
+
+ static byte simplef_deop(byte i) {
+ Byte ib = foob(i);
+ dummy();
+ return ib;
+ }
+
+ static byte simplep_deop(Byte ib) {
+ dummy();
+ return ib;
+ }
+
+ static byte simplec_deop(byte i) {
+ Byte ib = ibc;
+ dummy();
+ return ib;
+ }
+
+ static byte test_deop(byte i) {
+ Byte ib = new Byte(foo(i));
+ if ((i&1) == 0)
+ ib = foo((byte)(i+1));
+ dummy();
+ return ib;
+ }
+
+ static byte testb_deop(byte i) {
+ Byte ib = foo(i);
+ if ((i&1) == 0)
+ ib = foo((byte)(i+1));
+ dummy();
+ return ib;
+ }
+
+ static byte testf_deop(byte i) {
+ Byte ib = foob(i);
+ if ((i&1) == 0)
+ ib = foo((byte)(i+1));
+ dummy();
+ return ib;
+ }
+
+ static byte testp_deop(byte i, Byte ib) {
+ if ((i&1) == 0)
+ ib = foo((byte)(i+1));
+ dummy();
+ return ib;
+ }
+
+ static byte testc_deop(byte i) {
+ Byte ib = ibc;
+ if ((i&1) == 0)
+ ib = foo((byte)(i+1));
+ dummy();
+ return ib;
+ }
+
+ static byte sum_deop(byte[] a) {
+ byte result = 1;
+ for (Byte i : a)
+ result += foo(i);
+ dummy();
+ return result;
+ }
+
+ static byte sumb_deop(byte[] a) {
+ Byte result = 1;
+ for (Byte i : a)
+ result = (byte)(result + foo(i));
+ dummy();
+ return result;
+ }
+
+ static byte sumf_deop(byte[] a) {
+ Byte result = 1;
+ for (Byte i : a)
+ result = (byte)(result + foob(i));
+ dummy();
+ return result;
+ }
+
+ static byte sump_deop(byte[] a, Byte result) {
+ for (Byte i : a)
+ result = (byte)(result + foob(i));
+ dummy();
+ return result;
+ }
+
+ static byte sumc_deop(byte[] a) {
+ Byte result = ibc;
+ for (Byte i : a)
+ result = (byte)(result + foo(i));
+ dummy();
+ return result;
+ }
+
+ static byte remi_sum_deop() {
+ Byte j = new Byte(foo((byte)1));
+ for (int i = 0; i< 1000; i++) {
+ j = new Byte(foo((byte)(j + 1)));
+ }
+ dummy();
+ return j;
+ }
+
+ static byte remi_sumb_deop() {
+ Byte j = Byte.valueOf(foo((byte)1));
+ for (int i = 0; i< 1000; i++) {
+ j = foo((byte)(j + 1));
+ }
+ dummy();
+ return j;
+ }
+
+ static byte remi_sumf_deop() {
+ Byte j = foob((byte)1);
+ for (int i = 0; i< 1000; i++) {
+ j = foo((byte)(j + 1));
+ }
+ dummy();
+ return j;
+ }
+
+ static byte remi_sump_deop(Byte j) {
+ for (int i = 0; i< 1000; i++) {
+ j = foo((byte)(j + 1));
+ }
+ dummy();
+ return j;
+ }
+
+ static byte remi_sumc_deop() {
+ Byte j = ibc;
+ for (int i = 0; i< 1000; i++) {
+ j = foo((byte)(j + 1));
+ }
+ dummy();
+ return j;
+ }
+
+ //===============================================
+ // Conditional increment
+ static byte remi_sum_cond() {
+ Byte j = new Byte((byte)1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = new Byte((byte)(j + 1));
+ }
+ }
+ return j;
+ }
+
+ static byte remi_sumb_cond() {
+ Byte j = Byte.valueOf((byte)1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = (byte)(j + 1);
+ }
+ }
+ return j;
+ }
+
+ static byte remi_sumf_cond() {
+ Byte j = foob((byte)1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = (byte)(j + 1);
+ }
+ }
+ return j;
+ }
+
+ static byte remi_sump_cond(Byte j) {
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = (byte)(j + 1);
+ }
+ }
+ return j;
+ }
+
+ static byte remi_sumc_cond() {
+ Byte j = ibc;
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = (byte)(j + ibc);
+ }
+ }
+ return j;
+ }
+
+ static byte remi_sum2_cond() {
+ Byte j1 = new Byte((byte)1);
+ Byte j2 = new Byte((byte)1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = new Byte((byte)(j1 + 1));
+ } else {
+ j2 = new Byte((byte)(j2 + 2));
+ }
+ }
+ return (byte)(j1 + j2);
+ }
+
+ static byte remi_sumb2_cond() {
+ Byte j1 = Byte.valueOf((byte)1);
+ Byte j2 = Byte.valueOf((byte)1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = (byte)(j1 + 1);
+ } else {
+ j2 = (byte)(j2 + 2);
+ }
+ }
+ return (byte)(j1 + j2);
+ }
+
+ static byte remi_summ2_cond() {
+ Byte j1 = new Byte((byte)1);
+ Byte j2 = Byte.valueOf((byte)1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = new Byte((byte)(j1 + 1));
+ } else {
+ j2 = (byte)(j2 + 2);
+ }
+ }
+ return (byte)(j1 + j2);
+ }
+
+ static byte remi_sump2_cond(Byte j1) {
+ Byte j2 = Byte.valueOf((byte)1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = new Byte((byte)(j1 + 1));
+ } else {
+ j2 = (byte)(j2 + 2);
+ }
+ }
+ return (byte)(j1 + j2);
+ }
+
+ static byte remi_sumc2_cond() {
+ Byte j1 = ibc;
+ Byte j2 = Byte.valueOf((byte)1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = (byte)(j1 + ibc);
+ } else {
+ j2 = (byte)(j2 + 2);
+ }
+ }
+ return (byte)(j1 + j2);
+ }
+
+
+ public static void main(String[] args) {
+ final int ntests = 70;
+
+ String[] test_name = new String[] {
+ "simple", "simpleb", "simplec", "simplef", "simplep",
+ "simple2", "simpleb2", "simplec2", "simplem2", "simplep2",
+ "simple_deop", "simpleb_deop", "simplec_deop", "simplef_deop", "simplep_deop",
+ "test", "testb", "testc", "testm", "testp",
+ "test2", "testb2", "testc2", "testm2", "testp2",
+ "test_deop", "testb_deop", "testc_deop", "testf_deop", "testp_deop",
+ "sum", "sumb", "sumc", "sumf", "sump",
+ "sum2", "sumb2", "sumc2", "summ2", "sump2",
+ "sum_deop", "sumb_deop", "sumc_deop", "sumf_deop", "sump_deop",
+ "remi_sum", "remi_sumb", "remi_sumc", "remi_sumf", "remi_sump",
+ "remi_sum2", "remi_sumb2", "remi_sumc2", "remi_summ2", "remi_sump2",
+ "remi_sum_deop", "remi_sumb_deop", "remi_sumc_deop", "remi_sumf_deop", "remi_sump_deop",
+ "remi_sum_cond", "remi_sumb_cond", "remi_sumc_cond", "remi_sumf_cond", "remi_sump_cond",
+ "remi_sum2_cond", "remi_sumb2_cond", "remi_sumc2_cond", "remi_summ2_cond", "remi_sump2_cond"
+ };
+
+ final int[] val = new int[] {
+ -5488, -5488, 12000, -5488, -5488,
+ 1024, 1024, -5552, 1024, 1024,
+ -5488, -5488, 12000, -5488, -5488,
+ 512, 512, 6256, 512, 512,
+ 13024, 13024, -5584, 13024, 13024,
+ 512, 512, 6256, 512, 512,
+ 45, 45, 45, 45, 45,
+ 66, 66, 66, 66, 66,
+ 45, 45, 45, 45, 45,
+ -23, -23, -23, -23, -23,
+ -70, -70, -70, -70, -70,
+ -23, -23, -23, -23, -23,
+ -11, -11, -11, -11, -11,
+ -34, -34, -34, -34, -34
+ };
+
+ int[] res = new int[ntests];
+ for (int i = 0; i < ntests; i++) {
+ res[i] = 0;
+ }
+
+
+ for (int i = 0; i < 12000; i++) {
+ res[0] += simple((byte)i);
+ res[1] += simpleb((byte)i);
+ res[2] += simplec();
+ res[3] += simplef((byte)i);
+ res[4] += simplep((byte)i);
+
+ res[5] += simple2((byte)i);
+ res[6] += simpleb2((byte)i);
+ res[7] += simplec2((byte)i);
+ res[8] += simplem2((byte)i);
+ res[9] += simplep2((byte)i, (byte)i);
+
+ res[10] += simple_deop((byte)i);
+ res[11] += simpleb_deop((byte)i);
+ res[12] += simplec_deop((byte)i);
+ res[13] += simplef_deop((byte)i);
+ res[14] += simplep_deop((byte)i);
+
+ res[15] += test((byte)i);
+ res[16] += testb((byte)i);
+ res[17] += testc((byte)i);
+ res[18] += testm((byte)i);
+ res[19] += testp((byte)i, (byte)i);
+
+ res[20] += test2((byte)i);
+ res[21] += testb2((byte)i);
+ res[22] += testc2((byte)i);
+ res[23] += testm2((byte)i);
+ res[24] += testp2((byte)i, (byte)i);
+
+ res[25] += test_deop((byte)i);
+ res[26] += testb_deop((byte)i);
+ res[27] += testc_deop((byte)i);
+ res[28] += testf_deop((byte)i);
+ res[29] += testp_deop((byte)i, (byte)i);
+ }
+
+ byte[] ia = new byte[1000];
+ for (int i = 0; i < 1000; i++) {
+ ia[i] = (byte)i;
+ }
+
+ for (int i = 0; i < 100; i++) {
+ res[30] = sum(ia);
+ res[31] = sumb(ia);
+ res[32] = sumc(ia);
+ res[33] = sumf(ia);
+ res[34] = sump(ia, (byte)1);
+
+ res[35] = sum2(ia);
+ res[36] = sumb2(ia);
+ res[37] = sumc2(ia);
+ res[38] = summ2(ia);
+ res[39] = sump2(ia, (byte)1);
+
+ res[40] = sum_deop(ia);
+ res[41] = sumb_deop(ia);
+ res[42] = sumc_deop(ia);
+ res[43] = sumf_deop(ia);
+ res[44] = sump_deop(ia, (byte)1);
+
+ res[45] = remi_sum();
+ res[46] = remi_sumb();
+ res[47] = remi_sumc();
+ res[48] = remi_sumf();
+ res[49] = remi_sump((byte)1);
+
+ res[50] = remi_sum2();
+ res[51] = remi_sumb2();
+ res[52] = remi_sumc2();
+ res[53] = remi_summ2();
+ res[54] = remi_sump2((byte)1);
+
+ res[55] = remi_sum_deop();
+ res[56] = remi_sumb_deop();
+ res[57] = remi_sumc_deop();
+ res[58] = remi_sumf_deop();
+ res[59] = remi_sump_deop((byte)1);
+
+ res[60] = remi_sum_cond();
+ res[61] = remi_sumb_cond();
+ res[62] = remi_sumc_cond();
+ res[63] = remi_sumf_cond();
+ res[64] = remi_sump_cond((byte)1);
+
+ res[65] = remi_sum2_cond();
+ res[66] = remi_sumb2_cond();
+ res[67] = remi_sumc2_cond();
+ res[68] = remi_summ2_cond();
+ res[69] = remi_sump2_cond((byte)1);
+ }
+
+ int failed = 0;
+ for (int i = 0; i < ntests; i++) {
+ if (res[i] != val[i]) {
+ System.err.println(test_name[i] + ": " + res[i] + " != " + val[i]);
+ failed++;
+ }
+ }
+ if (failed > 0) {
+ System.err.println("Failed " + failed + " tests.");
+ throw new InternalError();
+ } else {
+ System.out.println("Passed.");
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/6934604/TestDoubleBoxing.java Thu May 16 13:47:55 2013 -0700
@@ -0,0 +1,777 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 6934604
+ * @summary enable parts of EliminateAutoBox by default
+ * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox TestDoubleBoxing
+ * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox
+ * -XX:CompileCommand=exclude,TestDoubleBoxing.dummy -XX:CompileCommand=exclude,TestDoubleBoxing.foo -XX:CompileCommand=exclude,TestDoubleBoxing.foob TestDoubleBoxing
+ * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-EliminateAutoBox
+ * -XX:CompileCommand=exclude,TestDoubleBoxing.dummy -XX:CompileCommand=exclude,TestDoubleBoxing.foo -XX:CompileCommand=exclude,TestDoubleBoxing.foob TestDoubleBoxing
+ *
+ */
+
+public class TestDoubleBoxing {
+
+ static final Double ibc = new Double(1.);
+
+ //===============================================
+ // Non-inlined methods to test deoptimization info
+ static void dummy() { }
+ static double foo(double i) { return i; }
+ static Double foob(double i) { return Double.valueOf(i); }
+
+
+ static double simple(double i) {
+ Double ib = new Double(i);
+ return ib;
+ }
+
+ static double simpleb(double i) {
+ Double ib = Double.valueOf(i);
+ return ib;
+ }
+
+ static double simplec() {
+ Double ib = ibc;
+ return ib;
+ }
+
+ static double simplef(double i) {
+ Double ib = foob(i);
+ return ib;
+ }
+
+ static double simplep(Double ib) {
+ return ib;
+ }
+
+ static double simple2(double i) {
+ Double ib1 = new Double(i);
+ Double ib2 = new Double(i+1.);
+ return ib1 + ib2;
+ }
+
+ static double simpleb2(double i) {
+ Double ib1 = Double.valueOf(i);
+ Double ib2 = Double.valueOf(i+1.);
+ return ib1 + ib2;
+ }
+
+ static double simplem2(double i) {
+ Double ib1 = new Double(i);
+ Double ib2 = Double.valueOf(i+1.);
+ return ib1 + ib2;
+ }
+
+ static double simplep2(double i, Double ib1) {
+ Double ib2 = Double.valueOf(i+1.);
+ return ib1 + ib2;
+ }
+
+ static double simplec2(double i) {
+ Double ib1 = ibc;
+ Double ib2 = Double.valueOf(i+1.);
+ return ib1 + ib2;
+ }
+
+ //===============================================
+ static double test(double f, int i) {
+ Double ib = new Double(f);
+ if ((i&1) == 0)
+ ib = f+1.;
+ return ib;
+ }
+
+ static double testb(double f, int i) {
+ Double ib = f;
+ if ((i&1) == 0)
+ ib = (f+1.);
+ return ib;
+ }
+
+ static double testm(double f, int i) {
+ Double ib = f;
+ if ((i&1) == 0)
+ ib = new Double(f+1.);
+ return ib;
+ }
+
+ static double testp(double f, int i, Double ib) {
+ if ((i&1) == 0)
+ ib = new Double(f+1.);
+ return ib;
+ }
+
+ static double testc(double f, int i) {
+ Double ib = ibc;
+ if ((i&1) == 0)
+ ib = new Double(f+1.);
+ return ib;
+ }
+
+ static double test2(double f, int i) {
+ Double ib1 = new Double(f);
+ Double ib2 = new Double(f+1.);
+ if ((i&1) == 0) {
+ ib1 = new Double(f+1.);
+ ib2 = new Double(f+2.);
+ }
+ return ib1+ib2;
+ }
+
+ static double testb2(double f, int i) {
+ Double ib1 = f;
+ Double ib2 = f+1.;
+ if ((i&1) == 0) {
+ ib1 = (f+1.);
+ ib2 = (f+2.);
+ }
+ return ib1+ib2;
+ }
+
+ static double testm2(double f, int i) {
+ Double ib1 = new Double(f);
+ Double ib2 = f+1.;
+ if ((i&1) == 0) {
+ ib1 = new Double(f+1.);
+ ib2 = (f+2.);
+ }
+ return ib1+ib2;
+ }
+
+ static double testp2(double f, int i, Double ib1) {
+ Double ib2 = f+1.;
+ if ((i&1) == 0) {
+ ib1 = new Double(f+1.);
+ ib2 = (f+2.);
+ }
+ return ib1+ib2;
+ }
+
+ static double testc2(double f, int i) {
+ Double ib1 = ibc;
+ Double ib2 = f+1.;
+ if ((i&1) == 0) {
+ ib1 = (ibc+1.);
+ ib2 = (f+2.);
+ }
+ return ib1+ib2;
+ }
+
+ //===============================================
+ static double sum(double[] a) {
+ double result = 1.;
+ for (Double i : a)
+ result += i;
+ return result;
+ }
+
+ static double sumb(double[] a) {
+ Double result = 1.;
+ for (Double i : a)
+ result += i;
+ return result;
+ }
+
+ static double sumc(double[] a) {
+ Double result = ibc;
+ for (Double i : a)
+ result += i;
+ return result;
+ }
+
+ static double sumf(double[] a) {
+ Double result = foob(1.);
+ for (Double i : a)
+ result += i;
+ return result;
+ }
+
+ static double sump(double[] a, Double result) {
+ for (Double i : a)
+ result += i;
+ return result;
+ }
+
+ static double sum2(double[] a) {
+ double result1 = 1.;
+ double result2 = 1.;
+ for (Double i : a) {
+ result1 += i;
+ result2 += i + 1.;
+ }
+ return result1 + result2;
+ }
+
+ static double sumb2(double[] a) {
+ Double result1 = 1.;
+ Double result2 = 1.;
+ for (Double i : a) {
+ result1 += i;
+ result2 += i + 1.;
+ }
+ return result1 + result2;
+ }
+
+ static double summ2(double[] a) {
+ Double result1 = 1.;
+ Double result2 = new Double(1.);
+ for (Double i : a) {
+ result1 += i;
+ result2 += new Double(i + 1.);
+ }
+ return result1 + result2;
+ }
+
+ static double sump2(double[] a, Double result2) {
+ Double result1 = 1.;
+ for (Double i : a) {
+ result1 += i;
+ result2 += i + 1.;
+ }
+ return result1 + result2;
+ }
+
+ static double sumc2(double[] a) {
+ Double result1 = 1.;
+ Double result2 = ibc;
+ for (Double i : a) {
+ result1 += i;
+ result2 += i + ibc;
+ }
+ return result1 + result2;
+ }
+
+ //===============================================
+ static double remi_sum() {
+ Double j = new Double(1.);
+ for (int i = 0; i< 1000; i++) {
+ j = new Double(j + 1.);
+ }
+ return j;
+ }
+
+ static double remi_sumb() {
+ Double j = Double.valueOf(1.);
+ for (int i = 0; i< 1000; i++) {
+ j = j + 1.;
+ }
+ return j;
+ }
+
+ static double remi_sumf() {
+ Double j = foob(1.);
+ for (int i = 0; i< 1000; i++) {
+ j = j + 1.;
+ }
+ return j;
+ }
+
+ static double remi_sump(Double j) {
+ for (int i = 0; i< 1000; i++) {
+ j = new Double(j + 1.);
+ }
+ return j;
+ }
+
+ static double remi_sumc() {
+ Double j = ibc;
+ for (int i = 0; i< 1000; i++) {
+ j = j + ibc;
+ }
+ return j;
+ }
+
+ static double remi_sum2() {
+ Double j1 = new Double(1.);
+ Double j2 = new Double(1.);
+ for (int i = 0; i< 1000; i++) {
+ j1 = new Double(j1 + 1.);
+ j2 = new Double(j2 + 2.);
+ }
+ return j1 + j2;
+ }
+
+ static double remi_sumb2() {
+ Double j1 = Double.valueOf(1.);
+ Double j2 = Double.valueOf(1.);
+ for (int i = 0; i< 1000; i++) {
+ j1 = j1 + 1.;
+ j2 = j2 + 2.;
+ }
+ return j1 + j2;
+ }
+
+ static double remi_summ2() {
+ Double j1 = new Double(1.);
+ Double j2 = Double.valueOf(1.);
+ for (int i = 0; i< 1000; i++) {
+ j1 = new Double(j1 + 1.);
+ j2 = j2 + 2.;
+ }
+ return j1 + j2;
+ }
+
+ static double remi_sump2(Double j1) {
+ Double j2 = Double.valueOf(1.);
+ for (int i = 0; i< 1000; i++) {
+ j1 = new Double(j1 + 1.);
+ j2 = j2 + 2.;
+ }
+ return j1 + j2;
+ }
+
+ static double remi_sumc2() {
+ Double j1 = ibc;
+ Double j2 = Double.valueOf(1.);
+ for (int i = 0; i< 1000; i++) {
+ j1 = j1 + ibc;
+ j2 = j2 + 2.;
+ }
+ return j1 + j2;
+ }
+
+
+ //===============================================
+ // Safepointa and debug info for deoptimization
+ static double simple_deop(double i) {
+ Double ib = new Double(foo(i));
+ dummy();
+ return ib;
+ }
+
+ static double simpleb_deop(double i) {
+ Double ib = Double.valueOf(foo(i));
+ dummy();
+ return ib;
+ }
+
+ static double simplef_deop(double i) {
+ Double ib = foob(i);
+ dummy();
+ return ib;
+ }
+
+ static double simplep_deop(Double ib) {
+ dummy();
+ return ib;
+ }
+
+ static double simplec_deop(double i) {
+ Double ib = ibc;
+ dummy();
+ return ib;
+ }
+
+ static double test_deop(double f, int i) {
+ Double ib = new Double(foo(f));
+ if ((i&1) == 0)
+ ib = foo(f+1.);
+ dummy();
+ return ib;
+ }
+
+ static double testb_deop(double f, int i) {
+ Double ib = foo(f);
+ if ((i&1) == 0)
+ ib = foo(f+1.);
+ dummy();
+ return ib;
+ }
+
+ static double testf_deop(double f, int i) {
+ Double ib = foob(f);
+ if ((i&1) == 0)
+ ib = foo(f+1.);
+ dummy();
+ return ib;
+ }
+
+ static double testp_deop(double f, int i, Double ib) {
+ if ((i&1) == 0)
+ ib = foo(f+1.);
+ dummy();
+ return ib;
+ }
+
+ static double testc_deop(double f, int i) {
+ Double ib = ibc;
+ if ((i&1) == 0)
+ ib = foo(f+1.);
+ dummy();
+ return ib;
+ }
+
+ static double sum_deop(double[] a) {
+ double result = 1.;
+ for (Double i : a)
+ result += foo(i);
+ dummy();
+ return result;
+ }
+
+ static double sumb_deop(double[] a) {
+ Double result = 1.;
+ for (Double i : a)
+ result += foo(i);
+ dummy();
+ return result;
+ }
+
+ static double sumf_deop(double[] a) {
+ Double result = 1.;
+ for (Double i : a)
+ result += foob(i);
+ dummy();
+ return result;
+ }
+
+ static double sump_deop(double[] a, Double result) {
+ for (Double i : a)
+ result += foob(i);
+ dummy();
+ return result;
+ }
+
+ static double sumc_deop(double[] a) {
+ Double result = ibc;
+ for (Double i : a)
+ result += foo(i);
+ dummy();
+ return result;
+ }
+
+ static double remi_sum_deop() {
+ Double j = new Double(foo(1.));
+ for (int i = 0; i< 1000; i++) {
+ j = new Double(foo(j + 1.));
+ }
+ dummy();
+ return j;
+ }
+
+ static double remi_sumb_deop() {
+ Double j = Double.valueOf(foo(1.));
+ for (int i = 0; i< 1000; i++) {
+ j = foo(j + 1.);
+ }
+ dummy();
+ return j;
+ }
+
+ static double remi_sumf_deop() {
+ Double j = foob(1.);
+ for (int i = 0; i< 1000; i++) {
+ j = foo(j + 1.);
+ }
+ dummy();
+ return j;
+ }
+
+ static double remi_sump_deop(Double j) {
+ for (int i = 0; i< 1000; i++) {
+ j = foo(j + 1.);
+ }
+ dummy();
+ return j;
+ }
+
+ static double remi_sumc_deop() {
+ Double j = ibc;
+ for (int i = 0; i< 1000; i++) {
+ j = foo(j + 1.);
+ }
+ dummy();
+ return j;
+ }
+
+ //===============================================
+ // Conditional increment
+ static double remi_sum_cond() {
+ Double j = new Double(1.);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = new Double(j + 1.);
+ }
+ }
+ return j;
+ }
+
+ static double remi_sumb_cond() {
+ Double j = Double.valueOf(1.);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = j + 1.;
+ }
+ }
+ return j;
+ }
+
+ static double remi_sumf_cond() {
+ Double j = foob(1.);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = j + 1.;
+ }
+ }
+ return j;
+ }
+
+ static double remi_sump_cond(Double j) {
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = j + 1.;
+ }
+ }
+ return j;
+ }
+
+ static double remi_sumc_cond() {
+ Double j = ibc;
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = j + ibc;
+ }
+ }
+ return j;
+ }
+
+ static double remi_sum2_cond() {
+ Double j1 = new Double(1.);
+ Double j2 = new Double(1.);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = new Double(j1 + 1.);
+ } else {
+ j2 = new Double(j2 + 2.);
+ }
+ }
+ return j1 + j2;
+ }
+
+ static double remi_sumb2_cond() {
+ Double j1 = Double.valueOf(1.);
+ Double j2 = Double.valueOf(1.);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = j1 + 1.;
+ } else {
+ j2 = j2 + 2.;
+ }
+ }
+ return j1 + j2;
+ }
+
+ static double remi_summ2_cond() {
+ Double j1 = new Double(1.);
+ Double j2 = Double.valueOf(1.);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = new Double(j1 + 1.);
+ } else {
+ j2 = j2 + 2.;
+ }
+ }
+ return j1 + j2;
+ }
+
+ static double remi_sump2_cond(Double j1) {
+ Double j2 = Double.valueOf(1.);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = new Double(j1 + 1.);
+ } else {
+ j2 = j2 + 2.;
+ }
+ }
+ return j1 + j2;
+ }
+
+ static double remi_sumc2_cond() {
+ Double j1 = ibc;
+ Double j2 = Double.valueOf(1.);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = j1 + ibc;
+ } else {
+ j2 = j2 + 2;
+ }
+ }
+ return j1 + j2;
+ }
+
+
+ public static void main(String[] args) {
+ final int ntests = 70;
+
+ String[] test_name = new String[] {
+ "simple", "simpleb", "simplec", "simplef", "simplep",
+ "simple2", "simpleb2", "simplec2", "simplem2", "simplep2",
+ "simple_deop", "simpleb_deop", "simplec_deop", "simplef_deop", "simplep_deop",
+ "test", "testb", "testc", "testm", "testp",
+ "test2", "testb2", "testc2", "testm2", "testp2",
+ "test_deop", "testb_deop", "testc_deop", "testf_deop", "testp_deop",
+ "sum", "sumb", "sumc", "sumf", "sump",
+ "sum2", "sumb2", "sumc2", "summ2", "sump2",
+ "sum_deop", "sumb_deop", "sumc_deop", "sumf_deop", "sump_deop",
+ "remi_sum", "remi_sumb", "remi_sumc", "remi_sumf", "remi_sump",
+ "remi_sum2", "remi_sumb2", "remi_sumc2", "remi_summ2", "remi_sump2",
+ "remi_sum_deop", "remi_sumb_deop", "remi_sumc_deop", "remi_sumf_deop", "remi_sump_deop",
+ "remi_sum_cond", "remi_sumb_cond", "remi_sumc_cond", "remi_sumf_cond", "remi_sump_cond",
+ "remi_sum2_cond", "remi_sumb2_cond", "remi_sumc2_cond", "remi_summ2_cond", "remi_sump2_cond"
+ };
+
+ final double[] val = new double[] {
+ 71994000., 71994000., 12000., 71994000., 71994000.,
+ 144000000., 144000000., 72018000., 144000000., 144000000.,
+ 71994000., 71994000., 12000., 71994000., 71994000.,
+ 72000000., 72000000., 36006000., 72000000., 72000000.,
+ 144012000., 144012000., 72030000., 144012000., 144012000.,
+ 72000000., 72000000., 36006000., 72000000., 72000000.,
+ 499501., 499501., 499501., 499501., 499501.,
+ 1000002., 1000002., 1000002., 1000002., 1000002.,
+ 499501., 499501., 499501., 499501., 499501.,
+ 1001., 1001., 1001., 1001., 1001.,
+ 3002., 3002., 3002., 3002., 3002.,
+ 1001., 1001., 1001., 1001., 1001.,
+ 501., 501., 501., 501., 501.,
+ 1502., 1502., 1502., 1502., 1502.
+ };
+
+ double[] res = new double[ntests];
+ for (int i = 0; i < ntests; i++) {
+ res[i] = 0.;
+ }
+
+
+ for (int i = 0; i < 12000; i++) {
+ res[0] += simple(i);
+ res[1] += simpleb(i);
+ res[2] += simplec();
+ res[3] += simplef(i);
+ res[4] += simplep((double)i);
+
+ res[5] += simple2((double)i);
+ res[6] += simpleb2((double)i);
+ res[7] += simplec2((double)i);
+ res[8] += simplem2((double)i);
+ res[9] += simplep2((double)i, (double)i);
+
+ res[10] += simple_deop((double)i);
+ res[11] += simpleb_deop((double)i);
+ res[12] += simplec_deop((double)i);
+ res[13] += simplef_deop((double)i);
+ res[14] += simplep_deop((double)i);
+
+ res[15] += test((double)i, i);
+ res[16] += testb((double)i, i);
+ res[17] += testc((double)i, i);
+ res[18] += testm((double)i, i);
+ res[19] += testp((double)i, i, (double)i);
+
+ res[20] += test2((double)i, i);
+ res[21] += testb2((double)i, i);
+ res[22] += testc2((double)i, i);
+ res[23] += testm2((double)i, i);
+ res[24] += testp2((double)i, i, (double)i);
+
+ res[25] += test_deop((double)i, i);
+ res[26] += testb_deop((double)i, i);
+ res[27] += testc_deop((double)i, i);
+ res[28] += testf_deop((double)i, i);
+ res[29] += testp_deop((double)i, i, (double)i);
+ }
+
+ double[] ia = new double[1000];
+ for (int i = 0; i < 1000; i++) {
+ ia[i] = i;
+ }
+
+ for (int i = 0; i < 100; i++) {
+ res[30] = sum(ia);
+ res[31] = sumb(ia);
+ res[32] = sumc(ia);
+ res[33] = sumf(ia);
+ res[34] = sump(ia, 1.);
+
+ res[35] = sum2(ia);
+ res[36] = sumb2(ia);
+ res[37] = sumc2(ia);
+ res[38] = summ2(ia);
+ res[39] = sump2(ia, 1.);
+
+ res[40] = sum_deop(ia);
+ res[41] = sumb_deop(ia);
+ res[42] = sumc_deop(ia);
+ res[43] = sumf_deop(ia);
+ res[44] = sump_deop(ia, 1.);
+
+ res[45] = remi_sum();
+ res[46] = remi_sumb();
+ res[47] = remi_sumc();
+ res[48] = remi_sumf();
+ res[49] = remi_sump(1.);
+
+ res[50] = remi_sum2();
+ res[51] = remi_sumb2();
+ res[52] = remi_sumc2();
+ res[53] = remi_summ2();
+ res[54] = remi_sump2(1.);
+
+ res[55] = remi_sum_deop();
+ res[56] = remi_sumb_deop();
+ res[57] = remi_sumc_deop();
+ res[58] = remi_sumf_deop();
+ res[59] = remi_sump_deop(1.);
+
+ res[60] = remi_sum_cond();
+ res[61] = remi_sumb_cond();
+ res[62] = remi_sumc_cond();
+ res[63] = remi_sumf_cond();
+ res[64] = remi_sump_cond(1.);
+
+ res[65] = remi_sum2_cond();
+ res[66] = remi_sumb2_cond();
+ res[67] = remi_sumc2_cond();
+ res[68] = remi_summ2_cond();
+ res[69] = remi_sump2_cond(1.);
+ }
+
+ int failed = 0;
+ for (int i = 0; i < ntests; i++) {
+ if (res[i] != val[i]) {
+ System.err.println(test_name[i] + ": " + res[i] + " != " + val[i]);
+ failed++;
+ }
+ }
+ if (failed > 0) {
+ System.err.println("Failed " + failed + " tests.");
+ throw new InternalError();
+ } else {
+ System.out.println("Passed.");
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/6934604/TestFloatBoxing.java Thu May 16 13:47:55 2013 -0700
@@ -0,0 +1,777 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 6934604
+ * @summary enable parts of EliminateAutoBox by default
+ * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox TestFloatBoxing
+ * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox
+ * -XX:CompileCommand=exclude,TestFloatBoxing.dummy -XX:CompileCommand=exclude,TestFloatBoxing.foo -XX:CompileCommand=exclude,TestFloatBoxing.foob TestFloatBoxing
+ * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-EliminateAutoBox
+ * -XX:CompileCommand=exclude,TestFloatBoxing.dummy -XX:CompileCommand=exclude,TestFloatBoxing.foo -XX:CompileCommand=exclude,TestFloatBoxing.foob TestFloatBoxing
+ *
+ */
+
+public class TestFloatBoxing {
+
+ static final Float ibc = new Float(1.f);
+
+ //===============================================
+ // Non-inlined methods to test deoptimization info
+ static void dummy() { }
+ static float foo(float i) { return i; }
+ static Float foob(float i) { return Float.valueOf(i); }
+
+
+ static float simple(float i) {
+ Float ib = new Float(i);
+ return ib;
+ }
+
+ static float simpleb(float i) {
+ Float ib = Float.valueOf(i);
+ return ib;
+ }
+
+ static float simplec() {
+ Float ib = ibc;
+ return ib;
+ }
+
+ static float simplef(float i) {
+ Float ib = foob(i);
+ return ib;
+ }
+
+ static float simplep(Float ib) {
+ return ib;
+ }
+
+ static float simple2(float i) {
+ Float ib1 = new Float(i);
+ Float ib2 = new Float(i+1.f);
+ return ib1 + ib2;
+ }
+
+ static float simpleb2(float i) {
+ Float ib1 = Float.valueOf(i);
+ Float ib2 = Float.valueOf(i+1.f);
+ return ib1 + ib2;
+ }
+
+ static float simplem2(float i) {
+ Float ib1 = new Float(i);
+ Float ib2 = Float.valueOf(i+1.f);
+ return ib1 + ib2;
+ }
+
+ static float simplep2(float i, Float ib1) {
+ Float ib2 = Float.valueOf(i+1.f);
+ return ib1 + ib2;
+ }
+
+ static float simplec2(float i) {
+ Float ib1 = ibc;
+ Float ib2 = Float.valueOf(i+1.f);
+ return ib1 + ib2;
+ }
+
+ //===============================================
+ static float test(float f, int i) {
+ Float ib = new Float(f);
+ if ((i&1) == 0)
+ ib = f+1.f;
+ return ib;
+ }
+
+ static float testb(float f, int i) {
+ Float ib = f;
+ if ((i&1) == 0)
+ ib = (f+1.f);
+ return ib;
+ }
+
+ static float testm(float f, int i) {
+ Float ib = f;
+ if ((i&1) == 0)
+ ib = new Float(f+1.f);
+ return ib;
+ }
+
+ static float testp(float f, int i, Float ib) {
+ if ((i&1) == 0)
+ ib = new Float(f+1.f);
+ return ib;
+ }
+
+ static float testc(float f, int i) {
+ Float ib = ibc;
+ if ((i&1) == 0)
+ ib = new Float(f+1.f);
+ return ib;
+ }
+
+ static float test2(float f, int i) {
+ Float ib1 = new Float(f);
+ Float ib2 = new Float(f+1.f);
+ if ((i&1) == 0) {
+ ib1 = new Float(f+1.f);
+ ib2 = new Float(f+2.f);
+ }
+ return ib1+ib2;
+ }
+
+ static float testb2(float f, int i) {
+ Float ib1 = f;
+ Float ib2 = f+1.f;
+ if ((i&1) == 0) {
+ ib1 = (f+1.f);
+ ib2 = (f+2.f);
+ }
+ return ib1+ib2;
+ }
+
+ static float testm2(float f, int i) {
+ Float ib1 = new Float(f);
+ Float ib2 = f+1.f;
+ if ((i&1) == 0) {
+ ib1 = new Float(f+1.f);
+ ib2 = (f+2.f);
+ }
+ return ib1+ib2;
+ }
+
+ static float testp2(float f, int i, Float ib1) {
+ Float ib2 = f+1.f;
+ if ((i&1) == 0) {
+ ib1 = new Float(f+1.f);
+ ib2 = (f+2.f);
+ }
+ return ib1+ib2;
+ }
+
+ static float testc2(float f, int i) {
+ Float ib1 = ibc;
+ Float ib2 = f+1.f;
+ if ((i&1) == 0) {
+ ib1 = (ibc+1.f);
+ ib2 = (f+2.f);
+ }
+ return ib1+ib2;
+ }
+
+ //===============================================
+ static float sum(float[] a) {
+ float result = 1.f;
+ for (Float i : a)
+ result += i;
+ return result;
+ }
+
+ static float sumb(float[] a) {
+ Float result = 1.f;
+ for (Float i : a)
+ result += i;
+ return result;
+ }
+
+ static float sumc(float[] a) {
+ Float result = ibc;
+ for (Float i : a)
+ result += i;
+ return result;
+ }
+
+ static float sumf(float[] a) {
+ Float result = foob(1.f);
+ for (Float i : a)
+ result += i;
+ return result;
+ }
+
+ static float sump(float[] a, Float result) {
+ for (Float i : a)
+ result += i;
+ return result;
+ }
+
+ static float sum2(float[] a) {
+ float result1 = 1.f;
+ float result2 = 1.f;
+ for (Float i : a) {
+ result1 += i;
+ result2 += i + 1.f;
+ }
+ return result1 + result2;
+ }
+
+ static float sumb2(float[] a) {
+ Float result1 = 1.f;
+ Float result2 = 1.f;
+ for (Float i : a) {
+ result1 += i;
+ result2 += i + 1.f;
+ }
+ return result1 + result2;
+ }
+
+ static float summ2(float[] a) {
+ Float result1 = 1.f;
+ Float result2 = new Float(1.f);
+ for (Float i : a) {
+ result1 += i;
+ result2 += new Float(i + 1.f);
+ }
+ return result1 + result2;
+ }
+
+ static float sump2(float[] a, Float result2) {
+ Float result1 = 1.f;
+ for (Float i : a) {
+ result1 += i;
+ result2 += i + 1.f;
+ }
+ return result1 + result2;
+ }
+
+ static float sumc2(float[] a) {
+ Float result1 = 1.f;
+ Float result2 = ibc;
+ for (Float i : a) {
+ result1 += i;
+ result2 += i + ibc;
+ }
+ return result1 + result2;
+ }
+
+ //===============================================
+ static float remi_sum() {
+ Float j = new Float(1.f);
+ for (int i = 0; i< 1000; i++) {
+ j = new Float(j + 1.f);
+ }
+ return j;
+ }
+
+ static float remi_sumb() {
+ Float j = Float.valueOf(1.f);
+ for (int i = 0; i< 1000; i++) {
+ j = j + 1.f;
+ }
+ return j;
+ }
+
+ static float remi_sumf() {
+ Float j = foob(1.f);
+ for (int i = 0; i< 1000; i++) {
+ j = j + 1.f;
+ }
+ return j;
+ }
+
+ static float remi_sump(Float j) {
+ for (int i = 0; i< 1000; i++) {
+ j = new Float(j + 1.f);
+ }
+ return j;
+ }
+
+ static float remi_sumc() {
+ Float j = ibc;
+ for (int i = 0; i< 1000; i++) {
+ j = j + ibc;
+ }
+ return j;
+ }
+
+ static float remi_sum2() {
+ Float j1 = new Float(1.f);
+ Float j2 = new Float(1.f);
+ for (int i = 0; i< 1000; i++) {
+ j1 = new Float(j1 + 1.f);
+ j2 = new Float(j2 + 2.f);
+ }
+ return j1 + j2;
+ }
+
+ static float remi_sumb2() {
+ Float j1 = Float.valueOf(1.f);
+ Float j2 = Float.valueOf(1.f);
+ for (int i = 0; i< 1000; i++) {
+ j1 = j1 + 1.f;
+ j2 = j2 + 2.f;
+ }
+ return j1 + j2;
+ }
+
+ static float remi_summ2() {
+ Float j1 = new Float(1.f);
+ Float j2 = Float.valueOf(1.f);
+ for (int i = 0; i< 1000; i++) {
+ j1 = new Float(j1 + 1.f);
+ j2 = j2 + 2.f;
+ }
+ return j1 + j2;
+ }
+
+ static float remi_sump2(Float j1) {
+ Float j2 = Float.valueOf(1.f);
+ for (int i = 0; i< 1000; i++) {
+ j1 = new Float(j1 + 1.f);
+ j2 = j2 + 2.f;
+ }
+ return j1 + j2;
+ }
+
+ static float remi_sumc2() {
+ Float j1 = ibc;
+ Float j2 = Float.valueOf(1.f);
+ for (int i = 0; i< 1000; i++) {
+ j1 = j1 + ibc;
+ j2 = j2 + 2.f;
+ }
+ return j1 + j2;
+ }
+
+
+ //===============================================
+ // Safepointa and debug info for deoptimization
+ static float simple_deop(float i) {
+ Float ib = new Float(foo(i));
+ dummy();
+ return ib;
+ }
+
+ static float simpleb_deop(float i) {
+ Float ib = Float.valueOf(foo(i));
+ dummy();
+ return ib;
+ }
+
+ static float simplef_deop(float i) {
+ Float ib = foob(i);
+ dummy();
+ return ib;
+ }
+
+ static float simplep_deop(Float ib) {
+ dummy();
+ return ib;
+ }
+
+ static float simplec_deop(float i) {
+ Float ib = ibc;
+ dummy();
+ return ib;
+ }
+
+ static float test_deop(float f, int i) {
+ Float ib = new Float(foo(f));
+ if ((i&1) == 0)
+ ib = foo(f+1.f);
+ dummy();
+ return ib;
+ }
+
+ static float testb_deop(float f, int i) {
+ Float ib = foo(f);
+ if ((i&1) == 0)
+ ib = foo(f+1.f);
+ dummy();
+ return ib;
+ }
+
+ static float testf_deop(float f, int i) {
+ Float ib = foob(f);
+ if ((i&1) == 0)
+ ib = foo(f+1.f);
+ dummy();
+ return ib;
+ }
+
+ static float testp_deop(float f, int i, Float ib) {
+ if ((i&1) == 0)
+ ib = foo(f+1.f);
+ dummy();
+ return ib;
+ }
+
+ static float testc_deop(float f, int i) {
+ Float ib = ibc;
+ if ((i&1) == 0)
+ ib = foo(f+1.f);
+ dummy();
+ return ib;
+ }
+
+ static float sum_deop(float[] a) {
+ float result = 1.f;
+ for (Float i : a)
+ result += foo(i);
+ dummy();
+ return result;
+ }
+
+ static float sumb_deop(float[] a) {
+ Float result = 1.f;
+ for (Float i : a)
+ result += foo(i);
+ dummy();
+ return result;
+ }
+
+ static float sumf_deop(float[] a) {
+ Float result = 1.f;
+ for (Float i : a)
+ result += foob(i);
+ dummy();
+ return result;
+ }
+
+ static float sump_deop(float[] a, Float result) {
+ for (Float i : a)
+ result += foob(i);
+ dummy();
+ return result;
+ }
+
+ static float sumc_deop(float[] a) {
+ Float result = ibc;
+ for (Float i : a)
+ result += foo(i);
+ dummy();
+ return result;
+ }
+
+ static float remi_sum_deop() {
+ Float j = new Float(foo(1.f));
+ for (int i = 0; i< 1000; i++) {
+ j = new Float(foo(j + 1.f));
+ }
+ dummy();
+ return j;
+ }
+
+ static float remi_sumb_deop() {
+ Float j = Float.valueOf(foo(1.f));
+ for (int i = 0; i< 1000; i++) {
+ j = foo(j + 1.f);
+ }
+ dummy();
+ return j;
+ }
+
+ static float remi_sumf_deop() {
+ Float j = foob(1.f);
+ for (int i = 0; i< 1000; i++) {
+ j = foo(j + 1.f);
+ }
+ dummy();
+ return j;
+ }
+
+ static float remi_sump_deop(Float j) {
+ for (int i = 0; i< 1000; i++) {
+ j = foo(j + 1.f);
+ }
+ dummy();
+ return j;
+ }
+
+ static float remi_sumc_deop() {
+ Float j = ibc;
+ for (int i = 0; i< 1000; i++) {
+ j = foo(j + 1.f);
+ }
+ dummy();
+ return j;
+ }
+
+ //===============================================
+ // Conditional increment
+ static float remi_sum_cond() {
+ Float j = new Float(1.f);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = new Float(j + 1.f);
+ }
+ }
+ return j;
+ }
+
+ static float remi_sumb_cond() {
+ Float j = Float.valueOf(1.f);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = j + 1.f;
+ }
+ }
+ return j;
+ }
+
+ static float remi_sumf_cond() {
+ Float j = foob(1.f);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = j + 1.f;
+ }
+ }
+ return j;
+ }
+
+ static float remi_sump_cond(Float j) {
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = j + 1.f;
+ }
+ }
+ return j;
+ }
+
+ static float remi_sumc_cond() {
+ Float j = ibc;
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = j + ibc;
+ }
+ }
+ return j;
+ }
+
+ static float remi_sum2_cond() {
+ Float j1 = new Float(1.f);
+ Float j2 = new Float(1.f);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = new Float(j1 + 1.f);
+ } else {
+ j2 = new Float(j2 + 2.f);
+ }
+ }
+ return j1 + j2;
+ }
+
+ static float remi_sumb2_cond() {
+ Float j1 = Float.valueOf(1.f);
+ Float j2 = Float.valueOf(1.f);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = j1 + 1.f;
+ } else {
+ j2 = j2 + 2.f;
+ }
+ }
+ return j1 + j2;
+ }
+
+ static float remi_summ2_cond() {
+ Float j1 = new Float(1.f);
+ Float j2 = Float.valueOf(1.f);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = new Float(j1 + 1.f);
+ } else {
+ j2 = j2 + 2.f;
+ }
+ }
+ return j1 + j2;
+ }
+
+ static float remi_sump2_cond(Float j1) {
+ Float j2 = Float.valueOf(1.f);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = new Float(j1 + 1.f);
+ } else {
+ j2 = j2 + 2.f;
+ }
+ }
+ return j1 + j2;
+ }
+
+ static float remi_sumc2_cond() {
+ Float j1 = ibc;
+ Float j2 = Float.valueOf(1.f);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = j1 + ibc;
+ } else {
+ j2 = j2 + 2;
+ }
+ }
+ return j1 + j2;
+ }
+
+
+ public static void main(String[] args) {
+ final int ntests = 70;
+
+ String[] test_name = new String[] {
+ "simple", "simpleb", "simplec", "simplef", "simplep",
+ "simple2", "simpleb2", "simplec2", "simplem2", "simplep2",
+ "simple_deop", "simpleb_deop", "simplec_deop", "simplef_deop", "simplep_deop",
+ "test", "testb", "testc", "testm", "testp",
+ "test2", "testb2", "testc2", "testm2", "testp2",
+ "test_deop", "testb_deop", "testc_deop", "testf_deop", "testp_deop",
+ "sum", "sumb", "sumc", "sumf", "sump",
+ "sum2", "sumb2", "sumc2", "summ2", "sump2",
+ "sum_deop", "sumb_deop", "sumc_deop", "sumf_deop", "sump_deop",
+ "remi_sum", "remi_sumb", "remi_sumc", "remi_sumf", "remi_sump",
+ "remi_sum2", "remi_sumb2", "remi_sumc2", "remi_summ2", "remi_sump2",
+ "remi_sum_deop", "remi_sumb_deop", "remi_sumc_deop", "remi_sumf_deop", "remi_sump_deop",
+ "remi_sum_cond", "remi_sumb_cond", "remi_sumc_cond", "remi_sumf_cond", "remi_sump_cond",
+ "remi_sum2_cond", "remi_sumb2_cond", "remi_sumc2_cond", "remi_summ2_cond", "remi_sump2_cond"
+ };
+
+ final float[] val = new float[] {
+ 71990896.f, 71990896.f, 12000.f, 71990896.f, 71990896.f,
+ 144000000.f, 144000000.f, 72014896.f, 144000000.f, 144000000.f,
+ 71990896.f, 71990896.f, 12000.f, 71990896.f, 71990896.f,
+ 72000000.f, 72000000.f, 36004096.f, 72000000.f, 72000000.f,
+ 144012288.f, 144012288.f, 72033096.f, 144012288.f, 144012288.f,
+ 72000000.f, 72000000.f, 36004096.f, 72000000.f, 72000000.f,
+ 499501.f, 499501.f, 499501.f, 499501.f, 499501.f,
+ 1000002.f, 1000002.f, 1000002.f, 1000002.f, 1000002.f,
+ 499501.f, 499501.f, 499501.f, 499501.f, 499501.f,
+ 1001.f, 1001.f, 1001.f, 1001.f, 1001.f,
+ 3002.f, 3002.f, 3002.f, 3002.f, 3002.f,
+ 1001.f, 1001.f, 1001.f, 1001.f, 1001.f,
+ 501.f, 501.f, 501.f, 501.f, 501.f,
+ 1502.f, 1502.f, 1502.f, 1502.f, 1502.f
+ };
+
+ float[] res = new float[ntests];
+ for (int i = 0; i < ntests; i++) {
+ res[i] = 0.f;
+ }
+
+
+ for (int i = 0; i < 12000; i++) {
+ res[0] += simple(i);
+ res[1] += simpleb(i);
+ res[2] += simplec();
+ res[3] += simplef(i);
+ res[4] += simplep((float)i);
+
+ res[5] += simple2((float)i);
+ res[6] += simpleb2((float)i);
+ res[7] += simplec2((float)i);
+ res[8] += simplem2((float)i);
+ res[9] += simplep2((float)i, (float)i);
+
+ res[10] += simple_deop((float)i);
+ res[11] += simpleb_deop((float)i);
+ res[12] += simplec_deop((float)i);
+ res[13] += simplef_deop((float)i);
+ res[14] += simplep_deop((float)i);
+
+ res[15] += test((float)i, i);
+ res[16] += testb((float)i, i);
+ res[17] += testc((float)i, i);
+ res[18] += testm((float)i, i);
+ res[19] += testp((float)i, i, (float)i);
+
+ res[20] += test2((float)i, i);
+ res[21] += testb2((float)i, i);
+ res[22] += testc2((float)i, i);
+ res[23] += testm2((float)i, i);
+ res[24] += testp2((float)i, i, (float)i);
+
+ res[25] += test_deop((float)i, i);
+ res[26] += testb_deop((float)i, i);
+ res[27] += testc_deop((float)i, i);
+ res[28] += testf_deop((float)i, i);
+ res[29] += testp_deop((float)i, i, (float)i);
+ }
+
+ float[] ia = new float[1000];
+ for (int i = 0; i < 1000; i++) {
+ ia[i] = i;
+ }
+
+ for (int i = 0; i < 100; i++) {
+ res[30] = sum(ia);
+ res[31] = sumb(ia);
+ res[32] = sumc(ia);
+ res[33] = sumf(ia);
+ res[34] = sump(ia, 1.f);
+
+ res[35] = sum2(ia);
+ res[36] = sumb2(ia);
+ res[37] = sumc2(ia);
+ res[38] = summ2(ia);
+ res[39] = sump2(ia, 1.f);
+
+ res[40] = sum_deop(ia);
+ res[41] = sumb_deop(ia);
+ res[42] = sumc_deop(ia);
+ res[43] = sumf_deop(ia);
+ res[44] = sump_deop(ia, 1.f);
+
+ res[45] = remi_sum();
+ res[46] = remi_sumb();
+ res[47] = remi_sumc();
+ res[48] = remi_sumf();
+ res[49] = remi_sump(1.f);
+
+ res[50] = remi_sum2();
+ res[51] = remi_sumb2();
+ res[52] = remi_sumc2();
+ res[53] = remi_summ2();
+ res[54] = remi_sump2(1.f);
+
+ res[55] = remi_sum_deop();
+ res[56] = remi_sumb_deop();
+ res[57] = remi_sumc_deop();
+ res[58] = remi_sumf_deop();
+ res[59] = remi_sump_deop(1.f);
+
+ res[60] = remi_sum_cond();
+ res[61] = remi_sumb_cond();
+ res[62] = remi_sumc_cond();
+ res[63] = remi_sumf_cond();
+ res[64] = remi_sump_cond(1.f);
+
+ res[65] = remi_sum2_cond();
+ res[66] = remi_sumb2_cond();
+ res[67] = remi_sumc2_cond();
+ res[68] = remi_summ2_cond();
+ res[69] = remi_sump2_cond(1.f);
+ }
+
+ int failed = 0;
+ for (int i = 0; i < ntests; i++) {
+ if (res[i] != val[i]) {
+ System.err.println(test_name[i] + ": " + res[i] + " != " + val[i]);
+ failed++;
+ }
+ }
+ if (failed > 0) {
+ System.err.println("Failed " + failed + " tests.");
+ throw new InternalError();
+ } else {
+ System.out.println("Passed.");
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/6934604/TestIntBoxing.java Thu May 16 13:47:55 2013 -0700
@@ -0,0 +1,777 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 6934604
+ * @summary enable parts of EliminateAutoBox by default
+ * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox TestIntBoxing
+ * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox
+ * -XX:CompileCommand=exclude,TestIntBoxing.dummy -XX:CompileCommand=exclude,TestIntBoxing.foo -XX:CompileCommand=exclude,TestIntBoxing.foob TestIntBoxing
+ * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-EliminateAutoBox
+ * -XX:CompileCommand=exclude,TestIntBoxing.dummy -XX:CompileCommand=exclude,TestIntBoxing.foo -XX:CompileCommand=exclude,TestIntBoxing.foob TestIntBoxing
+ *
+ */
+
+public class TestIntBoxing {
+
+ static final Integer ibc = new Integer(1);
+
+ //===============================================
+ // Non-inlined methods to test deoptimization info
+ static void dummy() { }
+ static int foo(int i) { return i; }
+ static Integer foob(int i) { return Integer.valueOf(i); }
+
+
+ static int simple(int i) {
+ Integer ib = new Integer(i);
+ return ib;
+ }
+
+ static int simpleb(int i) {
+ Integer ib = Integer.valueOf(i);
+ return ib;
+ }
+
+ static int simplec() {
+ Integer ib = ibc;
+ return ib;
+ }
+
+ static int simplef(int i) {
+ Integer ib = foob(i);
+ return ib;
+ }
+
+ static int simplep(Integer ib) {
+ return ib;
+ }
+
+ static int simple2(int i) {
+ Integer ib1 = new Integer(i);
+ Integer ib2 = new Integer(i+1);
+ return ib1 + ib2;
+ }
+
+ static int simpleb2(int i) {
+ Integer ib1 = Integer.valueOf(i);
+ Integer ib2 = Integer.valueOf(i+1);
+ return ib1 + ib2;
+ }
+
+ static int simplem2(int i) {
+ Integer ib1 = new Integer(i);
+ Integer ib2 = Integer.valueOf(i+1);
+ return ib1 + ib2;
+ }
+
+ static int simplep2(int i, Integer ib1) {
+ Integer ib2 = Integer.valueOf(i+1);
+ return ib1 + ib2;
+ }
+
+ static int simplec2(int i) {
+ Integer ib1 = ibc;
+ Integer ib2 = Integer.valueOf(i+1);
+ return ib1 + ib2;
+ }
+
+ //===============================================
+ static int test(int i) {
+ Integer ib = new Integer(i);
+ if ((i&1) == 0)
+ ib = i+1;
+ return ib;
+ }
+
+ static int testb(int i) {
+ Integer ib = i;
+ if ((i&1) == 0)
+ ib = (i+1);
+ return ib;
+ }
+
+ static int testm(int i) {
+ Integer ib = i;
+ if ((i&1) == 0)
+ ib = new Integer(i+1);
+ return ib;
+ }
+
+ static int testp(int i, Integer ib) {
+ if ((i&1) == 0)
+ ib = new Integer(i+1);
+ return ib;
+ }
+
+ static int testc(int i) {
+ Integer ib = ibc;
+ if ((i&1) == 0)
+ ib = new Integer(i+1);
+ return ib;
+ }
+
+ static int test2(int i) {
+ Integer ib1 = new Integer(i);
+ Integer ib2 = new Integer(i+1);
+ if ((i&1) == 0) {
+ ib1 = new Integer(i+1);
+ ib2 = new Integer(i+2);
+ }
+ return ib1+ib2;
+ }
+
+ static int testb2(int i) {
+ Integer ib1 = i;
+ Integer ib2 = i+1;
+ if ((i&1) == 0) {
+ ib1 = (i+1);
+ ib2 = (i+2);
+ }
+ return ib1+ib2;
+ }
+
+ static int testm2(int i) {
+ Integer ib1 = new Integer(i);
+ Integer ib2 = i+1;
+ if ((i&1) == 0) {
+ ib1 = new Integer(i+1);
+ ib2 = (i+2);
+ }
+ return ib1+ib2;
+ }
+
+ static int testp2(int i, Integer ib1) {
+ Integer ib2 = i+1;
+ if ((i&1) == 0) {
+ ib1 = new Integer(i+1);
+ ib2 = (i+2);
+ }
+ return ib1+ib2;
+ }
+
+ static int testc2(int i) {
+ Integer ib1 = ibc;
+ Integer ib2 = i+1;
+ if ((i&1) == 0) {
+ ib1 = (ibc+1);
+ ib2 = (i+2);
+ }
+ return ib1+ib2;
+ }
+
+ //===============================================
+ static int sum(int[] a) {
+ int result = 1;
+ for (Integer i : a)
+ result += i;
+ return result;
+ }
+
+ static int sumb(int[] a) {
+ Integer result = 1;
+ for (Integer i : a)
+ result += i;
+ return result;
+ }
+
+ static int sumc(int[] a) {
+ Integer result = ibc;
+ for (Integer i : a)
+ result += i;
+ return result;
+ }
+
+ static int sumf(int[] a) {
+ Integer result = foob(1);
+ for (Integer i : a)
+ result += i;
+ return result;
+ }
+
+ static int sump(int[] a, Integer result) {
+ for (Integer i : a)
+ result += i;
+ return result;
+ }
+
+ static int sum2(int[] a) {
+ int result1 = 1;
+ int result2 = 1;
+ for (Integer i : a) {
+ result1 += i;
+ result2 += i + 1;
+ }
+ return result1 + result2;
+ }
+
+ static int sumb2(int[] a) {
+ Integer result1 = 1;
+ Integer result2 = 1;
+ for (Integer i : a) {
+ result1 += i;
+ result2 += i + 1;
+ }
+ return result1 + result2;
+ }
+
+ static int summ2(int[] a) {
+ Integer result1 = 1;
+ Integer result2 = new Integer(1);
+ for (Integer i : a) {
+ result1 += i;
+ result2 += new Integer(i + 1);
+ }
+ return result1 + result2;
+ }
+
+ static int sump2(int[] a, Integer result2) {
+ Integer result1 = 1;
+ for (Integer i : a) {
+ result1 += i;
+ result2 += i + 1;
+ }
+ return result1 + result2;
+ }
+
+ static int sumc2(int[] a) {
+ Integer result1 = 1;
+ Integer result2 = ibc;
+ for (Integer i : a) {
+ result1 += i;
+ result2 += i + ibc;
+ }
+ return result1 + result2;
+ }
+
+ //===============================================
+ static int remi_sum() {
+ Integer j = new Integer(1);
+ for (int i = 0; i< 1000; i++) {
+ j = new Integer(j + 1);
+ }
+ return j;
+ }
+
+ static int remi_sumb() {
+ Integer j = Integer.valueOf(1);
+ for (int i = 0; i< 1000; i++) {
+ j = j + 1;
+ }
+ return j;
+ }
+
+ static int remi_sumf() {
+ Integer j = foob(1);
+ for (int i = 0; i< 1000; i++) {
+ j = j + 1;
+ }
+ return j;
+ }
+
+ static int remi_sump(Integer j) {
+ for (int i = 0; i< 1000; i++) {
+ j = new Integer(j + 1);
+ }
+ return j;
+ }
+
+ static int remi_sumc() {
+ Integer j = ibc;
+ for (int i = 0; i< 1000; i++) {
+ j = j + ibc;
+ }
+ return j;
+ }
+
+ static int remi_sum2() {
+ Integer j1 = new Integer(1);
+ Integer j2 = new Integer(1);
+ for (int i = 0; i< 1000; i++) {
+ j1 = new Integer(j1 + 1);
+ j2 = new Integer(j2 + 2);
+ }
+ return j1 + j2;
+ }
+
+ static int remi_sumb2() {
+ Integer j1 = Integer.valueOf(1);
+ Integer j2 = Integer.valueOf(1);
+ for (int i = 0; i< 1000; i++) {
+ j1 = j1 + 1;
+ j2 = j2 + 2;
+ }
+ return j1 + j2;
+ }
+
+ static int remi_summ2() {
+ Integer j1 = new Integer(1);
+ Integer j2 = Integer.valueOf(1);
+ for (int i = 0; i< 1000; i++) {
+ j1 = new Integer(j1 + 1);
+ j2 = j2 + 2;
+ }
+ return j1 + j2;
+ }
+
+ static int remi_sump2(Integer j1) {
+ Integer j2 = Integer.valueOf(1);
+ for (int i = 0; i< 1000; i++) {
+ j1 = new Integer(j1 + 1);
+ j2 = j2 + 2;
+ }
+ return j1 + j2;
+ }
+
+ static int remi_sumc2() {
+ Integer j1 = ibc;
+ Integer j2 = Integer.valueOf(1);
+ for (int i = 0; i< 1000; i++) {
+ j1 = j1 + ibc;
+ j2 = j2 + 2;
+ }
+ return j1 + j2;
+ }
+
+
+ //===============================================
+ // Safepointa and debug info for deoptimization
+ static int simple_deop(int i) {
+ Integer ib = new Integer(foo(i));
+ dummy();
+ return ib;
+ }
+
+ static int simpleb_deop(int i) {
+ Integer ib = Integer.valueOf(foo(i));
+ dummy();
+ return ib;
+ }
+
+ static int simplef_deop(int i) {
+ Integer ib = foob(i);
+ dummy();
+ return ib;
+ }
+
+ static int simplep_deop(Integer ib) {
+ dummy();
+ return ib;
+ }
+
+ static int simplec_deop(int i) {
+ Integer ib = ibc;
+ dummy();
+ return ib;
+ }
+
+ static int test_deop(int i) {
+ Integer ib = new Integer(foo(i));
+ if ((i&1) == 0)
+ ib = foo(i+1);
+ dummy();
+ return ib;
+ }
+
+ static int testb_deop(int i) {
+ Integer ib = foo(i);
+ if ((i&1) == 0)
+ ib = foo(i+1);
+ dummy();
+ return ib;
+ }
+
+ static int testf_deop(int i) {
+ Integer ib = foob(i);
+ if ((i&1) == 0)
+ ib = foo(i+1);
+ dummy();
+ return ib;
+ }
+
+ static int testp_deop(int i, Integer ib) {
+ if ((i&1) == 0)
+ ib = foo(i+1);
+ dummy();
+ return ib;
+ }
+
+ static int testc_deop(int i) {
+ Integer ib = ibc;
+ if ((i&1) == 0)
+ ib = foo(i+1);
+ dummy();
+ return ib;
+ }
+
+ static int sum_deop(int[] a) {
+ int result = 1;
+ for (Integer i : a)
+ result += foo(i);
+ dummy();
+ return result;
+ }
+
+ static int sumb_deop(int[] a) {
+ Integer result = 1;
+ for (Integer i : a)
+ result += foo(i);
+ dummy();
+ return result;
+ }
+
+ static int sumf_deop(int[] a) {
+ Integer result = 1;
+ for (Integer i : a)
+ result += foob(i);
+ dummy();
+ return result;
+ }
+
+ static int sump_deop(int[] a, Integer result) {
+ for (Integer i : a)
+ result += foob(i);
+ dummy();
+ return result;
+ }
+
+ static int sumc_deop(int[] a) {
+ Integer result = ibc;
+ for (Integer i : a)
+ result += foo(i);
+ dummy();
+ return result;
+ }
+
+ static int remi_sum_deop() {
+ Integer j = new Integer(foo(1));
+ for (int i = 0; i< 1000; i++) {
+ j = new Integer(foo(j + 1));
+ }
+ dummy();
+ return j;
+ }
+
+ static int remi_sumb_deop() {
+ Integer j = Integer.valueOf(foo(1));
+ for (int i = 0; i< 1000; i++) {
+ j = foo(j + 1);
+ }
+ dummy();
+ return j;
+ }
+
+ static int remi_sumf_deop() {
+ Integer j = foob(1);
+ for (int i = 0; i< 1000; i++) {
+ j = foo(j + 1);
+ }
+ dummy();
+ return j;
+ }
+
+ static int remi_sump_deop(Integer j) {
+ for (int i = 0; i< 1000; i++) {
+ j = foo(j + 1);
+ }
+ dummy();
+ return j;
+ }
+
+ static int remi_sumc_deop() {
+ Integer j = ibc;
+ for (int i = 0; i< 1000; i++) {
+ j = foo(j + 1);
+ }
+ dummy();
+ return j;
+ }
+
+ //===============================================
+ // Conditional increment
+ static int remi_sum_cond() {
+ Integer j = new Integer(1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = new Integer(j + 1);
+ }
+ }
+ return j;
+ }
+
+ static int remi_sumb_cond() {
+ Integer j = Integer.valueOf(1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = j + 1;
+ }
+ }
+ return j;
+ }
+
+ static int remi_sumf_cond() {
+ Integer j = foob(1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = j + 1;
+ }
+ }
+ return j;
+ }
+
+ static int remi_sump_cond(Integer j) {
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = j + 1;
+ }
+ }
+ return j;
+ }
+
+ static int remi_sumc_cond() {
+ Integer j = ibc;
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = j + ibc;
+ }
+ }
+ return j;
+ }
+
+ static int remi_sum2_cond() {
+ Integer j1 = new Integer(1);
+ Integer j2 = new Integer(1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = new Integer(j1 + 1);
+ } else {
+ j2 = new Integer(j2 + 2);
+ }
+ }
+ return j1 + j2;
+ }
+
+ static int remi_sumb2_cond() {
+ Integer j1 = Integer.valueOf(1);
+ Integer j2 = Integer.valueOf(1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = j1 + 1;
+ } else {
+ j2 = j2 + 2;
+ }
+ }
+ return j1 + j2;
+ }
+
+ static int remi_summ2_cond() {
+ Integer j1 = new Integer(1);
+ Integer j2 = Integer.valueOf(1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = new Integer(j1 + 1);
+ } else {
+ j2 = j2 + 2;
+ }
+ }
+ return j1 + j2;
+ }
+
+ static int remi_sump2_cond(Integer j1) {
+ Integer j2 = Integer.valueOf(1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = new Integer(j1 + 1);
+ } else {
+ j2 = j2 + 2;
+ }
+ }
+ return j1 + j2;
+ }
+
+ static int remi_sumc2_cond() {
+ Integer j1 = ibc;
+ Integer j2 = Integer.valueOf(1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = j1 + ibc;
+ } else {
+ j2 = j2 + 2;
+ }
+ }
+ return j1 + j2;
+ }
+
+
+ public static void main(String[] args) {
+ final int ntests = 70;
+
+ String[] test_name = new String[] {
+ "simple", "simpleb", "simplec", "simplef", "simplep",
+ "simple2", "simpleb2", "simplec2", "simplem2", "simplep2",
+ "simple_deop", "simpleb_deop", "simplec_deop", "simplef_deop", "simplep_deop",
+ "test", "testb", "testc", "testm", "testp",
+ "test2", "testb2", "testc2", "testm2", "testp2",
+ "test_deop", "testb_deop", "testc_deop", "testf_deop", "testp_deop",
+ "sum", "sumb", "sumc", "sumf", "sump",
+ "sum2", "sumb2", "sumc2", "summ2", "sump2",
+ "sum_deop", "sumb_deop", "sumc_deop", "sumf_deop", "sump_deop",
+ "remi_sum", "remi_sumb", "remi_sumc", "remi_sumf", "remi_sump",
+ "remi_sum2", "remi_sumb2", "remi_sumc2", "remi_summ2", "remi_sump2",
+ "remi_sum_deop", "remi_sumb_deop", "remi_sumc_deop", "remi_sumf_deop", "remi_sump_deop",
+ "remi_sum_cond", "remi_sumb_cond", "remi_sumc_cond", "remi_sumf_cond", "remi_sump_cond",
+ "remi_sum2_cond", "remi_sumb2_cond", "remi_sumc2_cond", "remi_summ2_cond", "remi_sump2_cond"
+ };
+
+ final int[] val = new int[] {
+ 71994000, 71994000, 12000, 71994000, 71994000,
+ 144000000, 144000000, 72018000, 144000000, 144000000,
+ 71994000, 71994000, 12000, 71994000, 71994000,
+ 72000000, 72000000, 36006000, 72000000, 72000000,
+ 144012000, 144012000, 72030000, 144012000, 144012000,
+ 72000000, 72000000, 36006000, 72000000, 72000000,
+ 499501, 499501, 499501, 499501, 499501,
+ 1000002, 1000002, 1000002, 1000002, 1000002,
+ 499501, 499501, 499501, 499501, 499501,
+ 1001, 1001, 1001, 1001, 1001,
+ 3002, 3002, 3002, 3002, 3002,
+ 1001, 1001, 1001, 1001, 1001,
+ 501, 501, 501, 501, 501,
+ 1502, 1502, 1502, 1502, 1502
+ };
+
+ int[] res = new int[ntests];
+ for (int i = 0; i < ntests; i++) {
+ res[i] = 0;
+ }
+
+
+ for (int i = 0; i < 12000; i++) {
+ res[0] += simple(i);
+ res[1] += simpleb(i);
+ res[2] += simplec();
+ res[3] += simplef(i);
+ res[4] += simplep(i);
+
+ res[5] += simple2(i);
+ res[6] += simpleb2(i);
+ res[7] += simplec2(i);
+ res[8] += simplem2(i);
+ res[9] += simplep2(i, i);
+
+ res[10] += simple_deop(i);
+ res[11] += simpleb_deop(i);
+ res[12] += simplec_deop(i);
+ res[13] += simplef_deop(i);
+ res[14] += simplep_deop(i);
+
+ res[15] += test(i);
+ res[16] += testb(i);
+ res[17] += testc(i);
+ res[18] += testm(i);
+ res[19] += testp(i, i);
+
+ res[20] += test2(i);
+ res[21] += testb2(i);
+ res[22] += testc2(i);
+ res[23] += testm2(i);
+ res[24] += testp2(i, i);
+
+ res[25] += test_deop(i);
+ res[26] += testb_deop(i);
+ res[27] += testc_deop(i);
+ res[28] += testf_deop(i);
+ res[29] += testp_deop(i, i);
+ }
+
+ int[] ia = new int[1000];
+ for (int i = 0; i < 1000; i++) {
+ ia[i] = i;
+ }
+
+ for (int i = 0; i < 100; i++) {
+ res[30] = sum(ia);
+ res[31] = sumb(ia);
+ res[32] = sumc(ia);
+ res[33] = sumf(ia);
+ res[34] = sump(ia, 1);
+
+ res[35] = sum2(ia);
+ res[36] = sumb2(ia);
+ res[37] = sumc2(ia);
+ res[38] = summ2(ia);
+ res[39] = sump2(ia, 1);
+
+ res[40] = sum_deop(ia);
+ res[41] = sumb_deop(ia);
+ res[42] = sumc_deop(ia);
+ res[43] = sumf_deop(ia);
+ res[44] = sump_deop(ia, 1);
+
+ res[45] = remi_sum();
+ res[46] = remi_sumb();
+ res[47] = remi_sumc();
+ res[48] = remi_sumf();
+ res[49] = remi_sump(1);
+
+ res[50] = remi_sum2();
+ res[51] = remi_sumb2();
+ res[52] = remi_sumc2();
+ res[53] = remi_summ2();
+ res[54] = remi_sump2(1);
+
+ res[55] = remi_sum_deop();
+ res[56] = remi_sumb_deop();
+ res[57] = remi_sumc_deop();
+ res[58] = remi_sumf_deop();
+ res[59] = remi_sump_deop(1);
+
+ res[60] = remi_sum_cond();
+ res[61] = remi_sumb_cond();
+ res[62] = remi_sumc_cond();
+ res[63] = remi_sumf_cond();
+ res[64] = remi_sump_cond(1);
+
+ res[65] = remi_sum2_cond();
+ res[66] = remi_sumb2_cond();
+ res[67] = remi_sumc2_cond();
+ res[68] = remi_summ2_cond();
+ res[69] = remi_sump2_cond(1);
+ }
+
+ int failed = 0;
+ for (int i = 0; i < ntests; i++) {
+ if (res[i] != val[i]) {
+ System.err.println(test_name[i] + ": " + res[i] + " != " + val[i]);
+ failed++;
+ }
+ }
+ if (failed > 0) {
+ System.err.println("Failed " + failed + " tests.");
+ throw new InternalError();
+ } else {
+ System.out.println("Passed.");
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/6934604/TestLongBoxing.java Thu May 16 13:47:55 2013 -0700
@@ -0,0 +1,777 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 6934604
+ * @summary enable parts of EliminateAutoBox by default
+ * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox TestLongBoxing
+ * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox
+ * -XX:CompileCommand=exclude,TestLongBoxing.dummy -XX:CompileCommand=exclude,TestLongBoxing.foo -XX:CompileCommand=exclude,TestLongBoxing.foob TestLongBoxing
+ * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-EliminateAutoBox
+ * -XX:CompileCommand=exclude,TestLongBoxing.dummy -XX:CompileCommand=exclude,TestLongBoxing.foo -XX:CompileCommand=exclude,TestLongBoxing.foob TestLongBoxing
+ *
+ */
+
+public class TestLongBoxing {
+
+ static final Long ibc = new Long(1);
+
+ //===============================================
+ // Non-inlined methods to test deoptimization info
+ static void dummy() { }
+ static long foo(long i) { return i; }
+ static Long foob(long i) { return Long.valueOf(i); }
+
+
+ static long simple(long i) {
+ Long ib = new Long(i);
+ return ib;
+ }
+
+ static long simpleb(long i) {
+ Long ib = Long.valueOf(i);
+ return ib;
+ }
+
+ static long simplec() {
+ Long ib = ibc;
+ return ib;
+ }
+
+ static long simplef(long i) {
+ Long ib = foob(i);
+ return ib;
+ }
+
+ static long simplep(Long ib) {
+ return ib;
+ }
+
+ static long simple2(long i) {
+ Long ib1 = new Long(i);
+ Long ib2 = new Long(i+1);
+ return ib1 + ib2;
+ }
+
+ static long simpleb2(long i) {
+ Long ib1 = Long.valueOf(i);
+ Long ib2 = Long.valueOf(i+1);
+ return ib1 + ib2;
+ }
+
+ static long simplem2(long i) {
+ Long ib1 = new Long(i);
+ Long ib2 = Long.valueOf(i+1);
+ return ib1 + ib2;
+ }
+
+ static long simplep2(long i, Long ib1) {
+ Long ib2 = Long.valueOf(i+1);
+ return ib1 + ib2;
+ }
+
+ static long simplec2(long i) {
+ Long ib1 = ibc;
+ Long ib2 = Long.valueOf(i+1);
+ return ib1 + ib2;
+ }
+
+ //===============================================
+ static long test(long i) {
+ Long ib = new Long(i);
+ if ((i&1) == 0)
+ ib = i+1;
+ return ib;
+ }
+
+ static long testb(long i) {
+ Long ib = i;
+ if ((i&1) == 0)
+ ib = (i+1);
+ return ib;
+ }
+
+ static long testm(long i) {
+ Long ib = i;
+ if ((i&1) == 0)
+ ib = new Long(i+1);
+ return ib;
+ }
+
+ static long testp(long i, Long ib) {
+ if ((i&1) == 0)
+ ib = new Long(i+1);
+ return ib;
+ }
+
+ static long testc(long i) {
+ Long ib = ibc;
+ if ((i&1) == 0)
+ ib = new Long(i+1);
+ return ib;
+ }
+
+ static long test2(long i) {
+ Long ib1 = new Long(i);
+ Long ib2 = new Long(i+1);
+ if ((i&1) == 0) {
+ ib1 = new Long(i+1);
+ ib2 = new Long(i+2);
+ }
+ return ib1+ib2;
+ }
+
+ static long testb2(long i) {
+ Long ib1 = i;
+ Long ib2 = i+1;
+ if ((i&1) == 0) {
+ ib1 = (i+1);
+ ib2 = (i+2);
+ }
+ return ib1+ib2;
+ }
+
+ static long testm2(long i) {
+ Long ib1 = new Long(i);
+ Long ib2 = i+1;
+ if ((i&1) == 0) {
+ ib1 = new Long(i+1);
+ ib2 = (i+2);
+ }
+ return ib1+ib2;
+ }
+
+ static long testp2(long i, Long ib1) {
+ Long ib2 = i+1;
+ if ((i&1) == 0) {
+ ib1 = new Long(i+1);
+ ib2 = (i+2);
+ }
+ return ib1+ib2;
+ }
+
+ static long testc2(long i) {
+ Long ib1 = ibc;
+ Long ib2 = i+1;
+ if ((i&1) == 0) {
+ ib1 = (ibc+1);
+ ib2 = (i+2);
+ }
+ return ib1+ib2;
+ }
+
+ //===============================================
+ static long sum(long[] a) {
+ long result = 1;
+ for (Long i : a)
+ result += i;
+ return result;
+ }
+
+ static long sumb(long[] a) {
+ Long result = 1l;
+ for (Long i : a)
+ result += i;
+ return result;
+ }
+
+ static long sumc(long[] a) {
+ Long result = ibc;
+ for (Long i : a)
+ result += i;
+ return result;
+ }
+
+ static long sumf(long[] a) {
+ Long result = foob(1);
+ for (Long i : a)
+ result += i;
+ return result;
+ }
+
+ static long sump(long[] a, Long result) {
+ for (Long i : a)
+ result += i;
+ return result;
+ }
+
+ static long sum2(long[] a) {
+ long result1 = 1;
+ long result2 = 1;
+ for (Long i : a) {
+ result1 += i;
+ result2 += i + 1;
+ }
+ return result1 + result2;
+ }
+
+ static long sumb2(long[] a) {
+ Long result1 = 1l;
+ Long result2 = 1l;
+ for (Long i : a) {
+ result1 += i;
+ result2 += i + 1;
+ }
+ return result1 + result2;
+ }
+
+ static long summ2(long[] a) {
+ Long result1 = 1l;
+ Long result2 = new Long(1);
+ for (Long i : a) {
+ result1 += i;
+ result2 += new Long(i + 1);
+ }
+ return result1 + result2;
+ }
+
+ static long sump2(long[] a, Long result2) {
+ Long result1 = 1l;
+ for (Long i : a) {
+ result1 += i;
+ result2 += i + 1;
+ }
+ return result1 + result2;
+ }
+
+ static long sumc2(long[] a) {
+ Long result1 = 1l;
+ Long result2 = ibc;
+ for (Long i : a) {
+ result1 += i;
+ result2 += i + ibc;
+ }
+ return result1 + result2;
+ }
+
+ //===============================================
+ static long remi_sum() {
+ Long j = new Long(1);
+ for (int i = 0; i< 1000; i++) {
+ j = new Long(j + 1);
+ }
+ return j;
+ }
+
+ static long remi_sumb() {
+ Long j = Long.valueOf(1);
+ for (int i = 0; i< 1000; i++) {
+ j = j + 1;
+ }
+ return j;
+ }
+
+ static long remi_sumf() {
+ Long j = foob(1);
+ for (int i = 0; i< 1000; i++) {
+ j = j + 1;
+ }
+ return j;
+ }
+
+ static long remi_sump(Long j) {
+ for (int i = 0; i< 1000; i++) {
+ j = new Long(j + 1);
+ }
+ return j;
+ }
+
+ static long remi_sumc() {
+ Long j = ibc;
+ for (int i = 0; i< 1000; i++) {
+ j = j + ibc;
+ }
+ return j;
+ }
+
+ static long remi_sum2() {
+ Long j1 = new Long(1);
+ Long j2 = new Long(1);
+ for (int i = 0; i< 1000; i++) {
+ j1 = new Long(j1 + 1);
+ j2 = new Long(j2 + 2);
+ }
+ return j1 + j2;
+ }
+
+ static long remi_sumb2() {
+ Long j1 = Long.valueOf(1);
+ Long j2 = Long.valueOf(1);
+ for (int i = 0; i< 1000; i++) {
+ j1 = j1 + 1;
+ j2 = j2 + 2;
+ }
+ return j1 + j2;
+ }
+
+ static long remi_summ2() {
+ Long j1 = new Long(1);
+ Long j2 = Long.valueOf(1);
+ for (int i = 0; i< 1000; i++) {
+ j1 = new Long(j1 + 1);
+ j2 = j2 + 2;
+ }
+ return j1 + j2;
+ }
+
+ static long remi_sump2(Long j1) {
+ Long j2 = Long.valueOf(1);
+ for (int i = 0; i< 1000; i++) {
+ j1 = new Long(j1 + 1);
+ j2 = j2 + 2;
+ }
+ return j1 + j2;
+ }
+
+ static long remi_sumc2() {
+ Long j1 = ibc;
+ Long j2 = Long.valueOf(1);
+ for (int i = 0; i< 1000; i++) {
+ j1 = j1 + ibc;
+ j2 = j2 + 2;
+ }
+ return j1 + j2;
+ }
+
+
+ //===============================================
+ // Safepointa and debug info for deoptimization
+ static long simple_deop(long i) {
+ Long ib = new Long(foo(i));
+ dummy();
+ return ib;
+ }
+
+ static long simpleb_deop(long i) {
+ Long ib = Long.valueOf(foo(i));
+ dummy();
+ return ib;
+ }
+
+ static long simplef_deop(long i) {
+ Long ib = foob(i);
+ dummy();
+ return ib;
+ }
+
+ static long simplep_deop(Long ib) {
+ dummy();
+ return ib;
+ }
+
+ static long simplec_deop(long i) {
+ Long ib = ibc;
+ dummy();
+ return ib;
+ }
+
+ static long test_deop(long i) {
+ Long ib = new Long(foo(i));
+ if ((i&1) == 0)
+ ib = foo(i+1);
+ dummy();
+ return ib;
+ }
+
+ static long testb_deop(long i) {
+ Long ib = foo(i);
+ if ((i&1) == 0)
+ ib = foo(i+1);
+ dummy();
+ return ib;
+ }
+
+ static long testf_deop(long i) {
+ Long ib = foob(i);
+ if ((i&1) == 0)
+ ib = foo(i+1);
+ dummy();
+ return ib;
+ }
+
+ static long testp_deop(long i, Long ib) {
+ if ((i&1) == 0)
+ ib = foo(i+1);
+ dummy();
+ return ib;
+ }
+
+ static long testc_deop(long i) {
+ Long ib = ibc;
+ if ((i&1) == 0)
+ ib = foo(i+1);
+ dummy();
+ return ib;
+ }
+
+ static long sum_deop(long[] a) {
+ long result = 1;
+ for (Long i : a)
+ result += foo(i);
+ dummy();
+ return result;
+ }
+
+ static long sumb_deop(long[] a) {
+ Long result = 1l;
+ for (Long i : a)
+ result += foo(i);
+ dummy();
+ return result;
+ }
+
+ static long sumf_deop(long[] a) {
+ Long result = 1l;
+ for (Long i : a)
+ result += foob(i);
+ dummy();
+ return result;
+ }
+
+ static long sump_deop(long[] a, Long result) {
+ for (Long i : a)
+ result += foob(i);
+ dummy();
+ return result;
+ }
+
+ static long sumc_deop(long[] a) {
+ Long result = ibc;
+ for (Long i : a)
+ result += foo(i);
+ dummy();
+ return result;
+ }
+
+ static long remi_sum_deop() {
+ Long j = new Long(foo(1));
+ for (int i = 0; i< 1000; i++) {
+ j = new Long(foo(j + 1));
+ }
+ dummy();
+ return j;
+ }
+
+ static long remi_sumb_deop() {
+ Long j = Long.valueOf(foo(1));
+ for (int i = 0; i< 1000; i++) {
+ j = foo(j + 1);
+ }
+ dummy();
+ return j;
+ }
+
+ static long remi_sumf_deop() {
+ Long j = foob(1);
+ for (int i = 0; i< 1000; i++) {
+ j = foo(j + 1);
+ }
+ dummy();
+ return j;
+ }
+
+ static long remi_sump_deop(Long j) {
+ for (int i = 0; i< 1000; i++) {
+ j = foo(j + 1);
+ }
+ dummy();
+ return j;
+ }
+
+ static long remi_sumc_deop() {
+ Long j = ibc;
+ for (int i = 0; i< 1000; i++) {
+ j = foo(j + 1);
+ }
+ dummy();
+ return j;
+ }
+
+ //===============================================
+ // Conditional increment
+ static long remi_sum_cond() {
+ Long j = new Long(1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = new Long(j + 1);
+ }
+ }
+ return j;
+ }
+
+ static long remi_sumb_cond() {
+ Long j = Long.valueOf(1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = j + 1;
+ }
+ }
+ return j;
+ }
+
+ static long remi_sumf_cond() {
+ Long j = foob(1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = j + 1;
+ }
+ }
+ return j;
+ }
+
+ static long remi_sump_cond(Long j) {
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = j + 1;
+ }
+ }
+ return j;
+ }
+
+ static long remi_sumc_cond() {
+ Long j = ibc;
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = j + ibc;
+ }
+ }
+ return j;
+ }
+
+ static long remi_sum2_cond() {
+ Long j1 = new Long(1);
+ Long j2 = new Long(1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = new Long(j1 + 1);
+ } else {
+ j2 = new Long(j2 + 2);
+ }
+ }
+ return j1 + j2;
+ }
+
+ static long remi_sumb2_cond() {
+ Long j1 = Long.valueOf(1);
+ Long j2 = Long.valueOf(1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = j1 + 1;
+ } else {
+ j2 = j2 + 2;
+ }
+ }
+ return j1 + j2;
+ }
+
+ static long remi_summ2_cond() {
+ Long j1 = new Long(1);
+ Long j2 = Long.valueOf(1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = new Long(j1 + 1);
+ } else {
+ j2 = j2 + 2;
+ }
+ }
+ return j1 + j2;
+ }
+
+ static long remi_sump2_cond(Long j1) {
+ Long j2 = Long.valueOf(1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = new Long(j1 + 1);
+ } else {
+ j2 = j2 + 2;
+ }
+ }
+ return j1 + j2;
+ }
+
+ static long remi_sumc2_cond() {
+ Long j1 = ibc;
+ Long j2 = Long.valueOf(1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = j1 + ibc;
+ } else {
+ j2 = j2 + 2;
+ }
+ }
+ return j1 + j2;
+ }
+
+
+ public static void main(String[] args) {
+ final int ntests = 70;
+
+ String[] test_name = new String[] {
+ "simple", "simpleb", "simplec", "simplef", "simplep",
+ "simple2", "simpleb2", "simplec2", "simplem2", "simplep2",
+ "simple_deop", "simpleb_deop", "simplec_deop", "simplef_deop", "simplep_deop",
+ "test", "testb", "testc", "testm", "testp",
+ "test2", "testb2", "testc2", "testm2", "testp2",
+ "test_deop", "testb_deop", "testc_deop", "testf_deop", "testp_deop",
+ "sum", "sumb", "sumc", "sumf", "sump",
+ "sum2", "sumb2", "sumc2", "summ2", "sump2",
+ "sum_deop", "sumb_deop", "sumc_deop", "sumf_deop", "sump_deop",
+ "remi_sum", "remi_sumb", "remi_sumc", "remi_sumf", "remi_sump",
+ "remi_sum2", "remi_sumb2", "remi_sumc2", "remi_summ2", "remi_sump2",
+ "remi_sum_deop", "remi_sumb_deop", "remi_sumc_deop", "remi_sumf_deop", "remi_sump_deop",
+ "remi_sum_cond", "remi_sumb_cond", "remi_sumc_cond", "remi_sumf_cond", "remi_sump_cond",
+ "remi_sum2_cond", "remi_sumb2_cond", "remi_sumc2_cond", "remi_summ2_cond", "remi_sump2_cond"
+ };
+
+ final long[] val = new long[] {
+ 71994000, 71994000, 12000, 71994000, 71994000,
+ 144000000, 144000000, 72018000, 144000000, 144000000,
+ 71994000, 71994000, 12000, 71994000, 71994000,
+ 72000000, 72000000, 36006000, 72000000, 72000000,
+ 144012000, 144012000, 72030000, 144012000, 144012000,
+ 72000000, 72000000, 36006000, 72000000, 72000000,
+ 499501, 499501, 499501, 499501, 499501,
+ 1000002, 1000002, 1000002, 1000002, 1000002,
+ 499501, 499501, 499501, 499501, 499501,
+ 1001, 1001, 1001, 1001, 1001,
+ 3002, 3002, 3002, 3002, 3002,
+ 1001, 1001, 1001, 1001, 1001,
+ 501, 501, 501, 501, 501,
+ 1502, 1502, 1502, 1502, 1502
+ };
+
+ long[] res = new long[ntests];
+ for (int i = 0; i < ntests; i++) {
+ res[i] = 0;
+ }
+
+
+ for (long i = 0; i < 12000; i++) {
+ res[0] += simple(i);
+ res[1] += simpleb(i);
+ res[2] += simplec();
+ res[3] += simplef(i);
+ res[4] += simplep(i);
+
+ res[5] += simple2(i);
+ res[6] += simpleb2(i);
+ res[7] += simplec2(i);
+ res[8] += simplem2(i);
+ res[9] += simplep2(i, i);
+
+ res[10] += simple_deop(i);
+ res[11] += simpleb_deop(i);
+ res[12] += simplec_deop(i);
+ res[13] += simplef_deop(i);
+ res[14] += simplep_deop(i);
+
+ res[15] += test(i);
+ res[16] += testb(i);
+ res[17] += testc(i);
+ res[18] += testm(i);
+ res[19] += testp(i, i);
+
+ res[20] += test2(i);
+ res[21] += testb2(i);
+ res[22] += testc2(i);
+ res[23] += testm2(i);
+ res[24] += testp2(i, i);
+
+ res[25] += test_deop(i);
+ res[26] += testb_deop(i);
+ res[27] += testc_deop(i);
+ res[28] += testf_deop(i);
+ res[29] += testp_deop(i, i);
+ }
+
+ long[] ia = new long[1000];
+ for (int i = 0; i < 1000; i++) {
+ ia[i] = i;
+ }
+
+ for (int i = 0; i < 100; i++) {
+ res[30] = sum(ia);
+ res[31] = sumb(ia);
+ res[32] = sumc(ia);
+ res[33] = sumf(ia);
+ res[34] = sump(ia, (long)1);
+
+ res[35] = sum2(ia);
+ res[36] = sumb2(ia);
+ res[37] = sumc2(ia);
+ res[38] = summ2(ia);
+ res[39] = sump2(ia, (long)1);
+
+ res[40] = sum_deop(ia);
+ res[41] = sumb_deop(ia);
+ res[42] = sumc_deop(ia);
+ res[43] = sumf_deop(ia);
+ res[44] = sump_deop(ia, (long)1);
+
+ res[45] = remi_sum();
+ res[46] = remi_sumb();
+ res[47] = remi_sumc();
+ res[48] = remi_sumf();
+ res[49] = remi_sump((long)1);
+
+ res[50] = remi_sum2();
+ res[51] = remi_sumb2();
+ res[52] = remi_sumc2();
+ res[53] = remi_summ2();
+ res[54] = remi_sump2((long)1);
+
+ res[55] = remi_sum_deop();
+ res[56] = remi_sumb_deop();
+ res[57] = remi_sumc_deop();
+ res[58] = remi_sumf_deop();
+ res[59] = remi_sump_deop((long)1);
+
+ res[60] = remi_sum_cond();
+ res[61] = remi_sumb_cond();
+ res[62] = remi_sumc_cond();
+ res[63] = remi_sumf_cond();
+ res[64] = remi_sump_cond((long)1);
+
+ res[65] = remi_sum2_cond();
+ res[66] = remi_sumb2_cond();
+ res[67] = remi_sumc2_cond();
+ res[68] = remi_summ2_cond();
+ res[69] = remi_sump2_cond((long)1);
+ }
+
+ int failed = 0;
+ for (int i = 0; i < ntests; i++) {
+ if (res[i] != val[i]) {
+ System.err.println(test_name[i] + ": " + res[i] + " != " + val[i]);
+ failed++;
+ }
+ }
+ if (failed > 0) {
+ System.err.println("Failed " + failed + " tests.");
+ throw new InternalError();
+ } else {
+ System.out.println("Passed.");
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/6934604/TestShortBoxing.java Thu May 16 13:47:55 2013 -0700
@@ -0,0 +1,777 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 6934604
+ * @summary enable parts of EliminateAutoBox by default
+ * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox TestShortBoxing
+ * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox
+ * -XX:CompileCommand=exclude,TestShortBoxing.dummy -XX:CompileCommand=exclude,TestShortBoxing.foo -XX:CompileCommand=exclude,TestShortBoxing.foob TestShortBoxing
+ * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-EliminateAutoBox
+ * -XX:CompileCommand=exclude,TestShortBoxing.dummy -XX:CompileCommand=exclude,TestShortBoxing.foo -XX:CompileCommand=exclude,TestShortBoxing.foob TestShortBoxing
+ *
+ */
+
+public class TestShortBoxing {
+
+ static final Short ibc = new Short((short)1);
+
+ //===============================================
+ // Non-inlined methods to test deoptimization info
+ static void dummy() { }
+ static short foo(short i) { return i; }
+ static Short foob(short i) { return Short.valueOf(i); }
+
+
+ static short simple(short i) {
+ Short ib = new Short(i);
+ return ib;
+ }
+
+ static short simpleb(short i) {
+ Short ib = Short.valueOf(i);
+ return ib;
+ }
+
+ static short simplec() {
+ Short ib = ibc;
+ return ib;
+ }
+
+ static short simplef(short i) {
+ Short ib = foob(i);
+ return ib;
+ }
+
+ static short simplep(Short ib) {
+ return ib;
+ }
+
+ static short simple2(short i) {
+ Short ib1 = new Short(i);
+ Short ib2 = new Short((short)(i+1));
+ return (short)(ib1 + ib2);
+ }
+
+ static short simpleb2(short i) {
+ Short ib1 = Short.valueOf(i);
+ Short ib2 = Short.valueOf((short)(i+1));
+ return (short)(ib1 + ib2);
+ }
+
+ static short simplem2(short i) {
+ Short ib1 = new Short(i);
+ Short ib2 = Short.valueOf((short)(i+1));
+ return (short)(ib1 + ib2);
+ }
+
+ static short simplep2(short i, Short ib1) {
+ Short ib2 = Short.valueOf((short)(i+1));
+ return (short)(ib1 + ib2);
+ }
+
+ static short simplec2(short i) {
+ Short ib1 = ibc;
+ Short ib2 = Short.valueOf((short)(i+1));
+ return (short)(ib1 + ib2);
+ }
+
+ //===============================================
+ static short test(short i) {
+ Short ib = new Short(i);
+ if ((i&1) == 0)
+ ib = (short)(i+1);
+ return ib;
+ }
+
+ static short testb(short i) {
+ Short ib = i;
+ if ((i&1) == 0)
+ ib = (short)(i+1);
+ return ib;
+ }
+
+ static short testm(short i) {
+ Short ib = i;
+ if ((i&1) == 0)
+ ib = new Short((short)(i+1));
+ return ib;
+ }
+
+ static short testp(short i, Short ib) {
+ if ((i&1) == 0)
+ ib = new Short((short)(i+1));
+ return ib;
+ }
+
+ static short testc(short i) {
+ Short ib = ibc;
+ if ((i&1) == 0)
+ ib = new Short((short)(i+1));
+ return ib;
+ }
+
+ static short test2(short i) {
+ Short ib1 = new Short(i);
+ Short ib2 = new Short((short)(i+1));
+ if ((i&1) == 0) {
+ ib1 = new Short((short)(i+1));
+ ib2 = new Short((short)(i+2));
+ }
+ return (short)(ib1+ib2);
+ }
+
+ static short testb2(short i) {
+ Short ib1 = i;
+ Short ib2 = (short)(i+1);
+ if ((i&1) == 0) {
+ ib1 = (short)(i+1);
+ ib2 = (short)(i+2);
+ }
+ return (short)(ib1 + ib2);
+ }
+
+ static short testm2(short i) {
+ Short ib1 = new Short(i);
+ Short ib2 = (short)(i+1);
+ if ((i&1) == 0) {
+ ib1 = new Short((short)(i+1));
+ ib2 = (short)(i+2);
+ }
+ return (short)(ib1 + ib2);
+ }
+
+ static short testp2(short i, Short ib1) {
+ Short ib2 = (short)(i+1);
+ if ((i&1) == 0) {
+ ib1 = new Short((short)(i+1));
+ ib2 = (short)(i+2);
+ }
+ return (short)(ib1 + ib2);
+ }
+
+ static short testc2(short i) {
+ Short ib1 = ibc;
+ Short ib2 = (short)(i+1);
+ if ((i&1) == 0) {
+ ib1 = (short)(ibc+1);
+ ib2 = (short)(i+2);
+ }
+ return (short)(ib1 + ib2);
+ }
+
+ //===============================================
+ static short sum(short[] a) {
+ short result = 1;
+ for (Short i : a)
+ result += i;
+ return result;
+ }
+
+ static short sumb(short[] a) {
+ Short result = 1;
+ for (Short i : a)
+ result = (short)(result + i);
+ return result;
+ }
+
+ static short sumc(short[] a) {
+ Short result = ibc;
+ for (Short i : a)
+ result = (short)(result + i);
+ return result;
+ }
+
+ static short sumf(short[] a) {
+ Short result = foob((short)1);
+ for (Short i : a)
+ result = (short)(result + i);
+ return result;
+ }
+
+ static short sump(short[] a, Short result) {
+ for (Short i : a)
+ result = (short)(result + i);
+ return result;
+ }
+
+ static short sum2(short[] a) {
+ short result1 = 1;
+ short result2 = 1;
+ for (Short i : a) {
+ result1 += i;
+ result2 += i + 1;
+ }
+ return (short)(result1 + result2);
+ }
+
+ static short sumb2(short[] a) {
+ Short result1 = 1;
+ Short result2 = 1;
+ for (Short i : a) {
+ result1 = (short)(result1 + i);
+ result2 = (short)(result2 + i + 1);
+ }
+ return (short)(result1 + result2);
+ }
+
+ static short summ2(short[] a) {
+ Short result1 = 1;
+ Short result2 = new Short((short)1);
+ for (Short i : a) {
+ result1 = (short)(result1 + i);
+ result2 = (short)(result2 + new Short((short)(i + 1)));
+ }
+ return (short)(result1 + result2);
+ }
+
+ static short sump2(short[] a, Short result2) {
+ Short result1 = 1;
+ for (Short i : a) {
+ result1 = (short)(result1 + i);
+ result2 = (short)(result2 + i + 1);
+ }
+ return (short)(result1 + result2);
+ }
+
+ static short sumc2(short[] a) {
+ Short result1 = 1;
+ Short result2 = ibc;
+ for (Short i : a) {
+ result1 = (short)(result1 + i);
+ result2 = (short)(result2 + i + ibc);
+ }
+ return (short)(result1 + result2);
+ }
+
+ //===============================================
+ static short remi_sum() {
+ Short j = new Short((short)1);
+ for (int i = 0; i< 1000; i++) {
+ j = new Short((short)(j + 1));
+ }
+ return j;
+ }
+
+ static short remi_sumb() {
+ Short j = Short.valueOf((short)1);
+ for (int i = 0; i< 1000; i++) {
+ j = (short)(j + 1);
+ }
+ return j;
+ }
+
+ static short remi_sumf() {
+ Short j = foob((short)1);
+ for (int i = 0; i< 1000; i++) {
+ j = (short)(j + 1);
+ }
+ return j;
+ }
+
+ static short remi_sump(Short j) {
+ for (int i = 0; i< 1000; i++) {
+ j = new Short((short)(j + 1));
+ }
+ return j;
+ }
+
+ static short remi_sumc() {
+ Short j = ibc;
+ for (int i = 0; i< 1000; i++) {
+ j = (short)(j + ibc);
+ }
+ return j;
+ }
+
+ static short remi_sum2() {
+ Short j1 = new Short((short)1);
+ Short j2 = new Short((short)1);
+ for (int i = 0; i< 1000; i++) {
+ j1 = new Short((short)(j1 + 1));
+ j2 = new Short((short)(j2 + 2));
+ }
+ return (short)(j1 + j2);
+ }
+
+ static short remi_sumb2() {
+ Short j1 = Short.valueOf((short)1);
+ Short j2 = Short.valueOf((short)1);
+ for (int i = 0; i< 1000; i++) {
+ j1 = (short)(j1 + 1);
+ j2 = (short)(j2 + 2);
+ }
+ return (short)(j1 + j2);
+ }
+
+ static short remi_summ2() {
+ Short j1 = new Short((short)1);
+ Short j2 = Short.valueOf((short)1);
+ for (int i = 0; i< 1000; i++) {
+ j1 = new Short((short)(j1 + 1));
+ j2 = (short)(j2 + 2);
+ }
+ return (short)(j1 + j2);
+ }
+
+ static short remi_sump2(Short j1) {
+ Short j2 = Short.valueOf((short)1);
+ for (int i = 0; i< 1000; i++) {
+ j1 = new Short((short)(j1 + 1));
+ j2 = (short)(j2 + 2);
+ }
+ return (short)(j1 + j2);
+ }
+
+ static short remi_sumc2() {
+ Short j1 = ibc;
+ Short j2 = Short.valueOf((short)1);
+ for (int i = 0; i< 1000; i++) {
+ j1 = (short)(j1 + ibc);
+ j2 = (short)(j2 + 2);
+ }
+ return (short)(j1 + j2);
+ }
+
+
+ //===============================================
+ // Safepointa and debug info for deoptimization
+ static short simple_deop(short i) {
+ Short ib = new Short(foo(i));
+ dummy();
+ return ib;
+ }
+
+ static short simpleb_deop(short i) {
+ Short ib = Short.valueOf(foo(i));
+ dummy();
+ return ib;
+ }
+
+ static short simplef_deop(short i) {
+ Short ib = foob(i);
+ dummy();
+ return ib;
+ }
+
+ static short simplep_deop(Short ib) {
+ dummy();
+ return ib;
+ }
+
+ static short simplec_deop(short i) {
+ Short ib = ibc;
+ dummy();
+ return ib;
+ }
+
+ static short test_deop(short i) {
+ Short ib = new Short(foo(i));
+ if ((i&1) == 0)
+ ib = foo((short)(i+1));
+ dummy();
+ return ib;
+ }
+
+ static short testb_deop(short i) {
+ Short ib = foo(i);
+ if ((i&1) == 0)
+ ib = foo((short)(i+1));
+ dummy();
+ return ib;
+ }
+
+ static short testf_deop(short i) {
+ Short ib = foob(i);
+ if ((i&1) == 0)
+ ib = foo((short)(i+1));
+ dummy();
+ return ib;
+ }
+
+ static short testp_deop(short i, Short ib) {
+ if ((i&1) == 0)
+ ib = foo((short)(i+1));
+ dummy();
+ return ib;
+ }
+
+ static short testc_deop(short i) {
+ Short ib = ibc;
+ if ((i&1) == 0)
+ ib = foo((short)(i+1));
+ dummy();
+ return ib;
+ }
+
+ static short sum_deop(short[] a) {
+ short result = 1;
+ for (Short i : a)
+ result += foo(i);
+ dummy();
+ return result;
+ }
+
+ static short sumb_deop(short[] a) {
+ Short result = 1;
+ for (Short i : a)
+ result = (short)(result + foo(i));
+ dummy();
+ return result;
+ }
+
+ static short sumf_deop(short[] a) {
+ Short result = 1;
+ for (Short i : a)
+ result = (short)(result + foob(i));
+ dummy();
+ return result;
+ }
+
+ static short sump_deop(short[] a, Short result) {
+ for (Short i : a)
+ result = (short)(result + foob(i));
+ dummy();
+ return result;
+ }
+
+ static short sumc_deop(short[] a) {
+ Short result = ibc;
+ for (Short i : a)
+ result = (short)(result + foo(i));
+ dummy();
+ return result;
+ }
+
+ static short remi_sum_deop() {
+ Short j = new Short(foo((short)1));
+ for (int i = 0; i< 1000; i++) {
+ j = new Short(foo((short)(j + 1)));
+ }
+ dummy();
+ return j;
+ }
+
+ static short remi_sumb_deop() {
+ Short j = Short.valueOf(foo((short)1));
+ for (int i = 0; i< 1000; i++) {
+ j = foo((short)(j + 1));
+ }
+ dummy();
+ return j;
+ }
+
+ static short remi_sumf_deop() {
+ Short j = foob((short)1);
+ for (int i = 0; i< 1000; i++) {
+ j = foo((short)(j + 1));
+ }
+ dummy();
+ return j;
+ }
+
+ static short remi_sump_deop(Short j) {
+ for (int i = 0; i< 1000; i++) {
+ j = foo((short)(j + 1));
+ }
+ dummy();
+ return j;
+ }
+
+ static short remi_sumc_deop() {
+ Short j = ibc;
+ for (int i = 0; i< 1000; i++) {
+ j = foo((short)(j + 1));
+ }
+ dummy();
+ return j;
+ }
+
+ //===============================================
+ // Conditional increment
+ static short remi_sum_cond() {
+ Short j = new Short((short)1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = new Short((short)(j + 1));
+ }
+ }
+ return j;
+ }
+
+ static short remi_sumb_cond() {
+ Short j = Short.valueOf((short)1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = (short)(j + 1);
+ }
+ }
+ return j;
+ }
+
+ static short remi_sumf_cond() {
+ Short j = foob((short)1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = (short)(j + 1);
+ }
+ }
+ return j;
+ }
+
+ static short remi_sump_cond(Short j) {
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = (short)(j + 1);
+ }
+ }
+ return j;
+ }
+
+ static short remi_sumc_cond() {
+ Short j = ibc;
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j = (short)(j + ibc);
+ }
+ }
+ return j;
+ }
+
+ static short remi_sum2_cond() {
+ Short j1 = new Short((short)1);
+ Short j2 = new Short((short)1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = new Short((short)(j1 + 1));
+ } else {
+ j2 = new Short((short)(j2 + 2));
+ }
+ }
+ return (short)(j1 + j2);
+ }
+
+ static short remi_sumb2_cond() {
+ Short j1 = Short.valueOf((short)1);
+ Short j2 = Short.valueOf((short)1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = (short)(j1 + 1);
+ } else {
+ j2 = (short)(j2 + 2);
+ }
+ }
+ return (short)(j1 + j2);
+ }
+
+ static short remi_summ2_cond() {
+ Short j1 = new Short((short)1);
+ Short j2 = Short.valueOf((short)1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = new Short((short)(j1 + 1));
+ } else {
+ j2 = (short)(j2 + 2);
+ }
+ }
+ return (short)(j1 + j2);
+ }
+
+ static short remi_sump2_cond(Short j1) {
+ Short j2 = Short.valueOf((short)1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = new Short((short)(j1 + 1));
+ } else {
+ j2 = (short)(j2 + 2);
+ }
+ }
+ return (short)(j1 + j2);
+ }
+
+ static short remi_sumc2_cond() {
+ Short j1 = ibc;
+ Short j2 = Short.valueOf((short)1);
+ for (int i = 0; i< 1000; i++) {
+ if ((i&1) == 0) {
+ j1 = (short)(j1 + ibc);
+ } else {
+ j2 = (short)(j2 + 2);
+ }
+ }
+ return (short)(j1 + j2);
+ }
+
+
+ public static void main(String[] args) {
+ final int ntests = 70;
+
+ String[] test_name = new String[] {
+ "simple", "simpleb", "simplec", "simplef", "simplep",
+ "simple2", "simpleb2", "simplec2", "simplem2", "simplep2",
+ "simple_deop", "simpleb_deop", "simplec_deop", "simplef_deop", "simplep_deop",
+ "test", "testb", "testc", "testm", "testp",
+ "test2", "testb2", "testc2", "testm2", "testp2",
+ "test_deop", "testb_deop", "testc_deop", "testf_deop", "testp_deop",
+ "sum", "sumb", "sumc", "sumf", "sump",
+ "sum2", "sumb2", "sumc2", "summ2", "sump2",
+ "sum_deop", "sumb_deop", "sumc_deop", "sumf_deop", "sump_deop",
+ "remi_sum", "remi_sumb", "remi_sumc", "remi_sumf", "remi_sump",
+ "remi_sum2", "remi_sumb2", "remi_sumc2", "remi_summ2", "remi_sump2",
+ "remi_sum_deop", "remi_sumb_deop", "remi_sumc_deop", "remi_sumf_deop", "remi_sump_deop",
+ "remi_sum_cond", "remi_sumb_cond", "remi_sumc_cond", "remi_sumf_cond", "remi_sump_cond",
+ "remi_sum2_cond", "remi_sumb2_cond", "remi_sumc2_cond", "remi_summ2_cond", "remi_sump2_cond"
+ };
+
+ final int[] val = new int[] {
+ 71994000, 71994000, 12000, 71994000, 71994000,
+ 144000000, 144000000, 72018000, 144000000, 144000000,
+ 71994000, 71994000, 12000, 71994000, 71994000,
+ 72000000, 72000000, 36006000, 72000000, 72000000,
+ 144012000, 144012000, 72030000, 144012000, 144012000,
+ 72000000, 72000000, 36006000, 72000000, 72000000,
+ -24787, -24787, -24787, -24787, -24787,
+ 16962, 16962, 16962, 16962, 16962,
+ -24787, -24787, -24787, -24787, -24787,
+ 1001, 1001, 1001, 1001, 1001,
+ 3002, 3002, 3002, 3002, 3002,
+ 1001, 1001, 1001, 1001, 1001,
+ 501, 501, 501, 501, 501,
+ 1502, 1502, 1502, 1502, 1502
+ };
+
+ int[] res = new int[ntests];
+ for (int i = 0; i < ntests; i++) {
+ res[i] = 0;
+ }
+
+
+ for (int i = 0; i < 12000; i++) {
+ res[0] += simple((short)i);
+ res[1] += simpleb((short)i);
+ res[2] += simplec();
+ res[3] += simplef((short)i);
+ res[4] += simplep((short)i);
+
+ res[5] += simple2((short)i);
+ res[6] += simpleb2((short)i);
+ res[7] += simplec2((short)i);
+ res[8] += simplem2((short)i);
+ res[9] += simplep2((short)i, (short)i);
+
+ res[10] += simple_deop((short)i);
+ res[11] += simpleb_deop((short)i);
+ res[12] += simplec_deop((short)i);
+ res[13] += simplef_deop((short)i);
+ res[14] += simplep_deop((short)i);
+
+ res[15] += test((short)i);
+ res[16] += testb((short)i);
+ res[17] += testc((short)i);
+ res[18] += testm((short)i);
+ res[19] += testp((short)i, (short)i);
+
+ res[20] += test2((short)i);
+ res[21] += testb2((short)i);
+ res[22] += testc2((short)i);
+ res[23] += testm2((short)i);
+ res[24] += testp2((short)i, (short)i);
+
+ res[25] += test_deop((short)i);
+ res[26] += testb_deop((short)i);
+ res[27] += testc_deop((short)i);
+ res[28] += testf_deop((short)i);
+ res[29] += testp_deop((short)i, (short)i);
+ }
+
+ short[] ia = new short[1000];
+ for (int i = 0; i < 1000; i++) {
+ ia[i] = (short)i;
+ }
+
+ for (int i = 0; i < 100; i++) {
+ res[30] = sum(ia);
+ res[31] = sumb(ia);
+ res[32] = sumc(ia);
+ res[33] = sumf(ia);
+ res[34] = sump(ia, (short)1);
+
+ res[35] = sum2(ia);
+ res[36] = sumb2(ia);
+ res[37] = sumc2(ia);
+ res[38] = summ2(ia);
+ res[39] = sump2(ia, (short)1);
+
+ res[40] = sum_deop(ia);
+ res[41] = sumb_deop(ia);
+ res[42] = sumc_deop(ia);
+ res[43] = sumf_deop(ia);
+ res[44] = sump_deop(ia, (short)1);
+
+ res[45] = remi_sum();
+ res[46] = remi_sumb();
+ res[47] = remi_sumc();
+ res[48] = remi_sumf();
+ res[49] = remi_sump((short)1);
+
+ res[50] = remi_sum2();
+ res[51] = remi_sumb2();
+ res[52] = remi_sumc2();
+ res[53] = remi_summ2();
+ res[54] = remi_sump2((short)1);
+
+ res[55] = remi_sum_deop();
+ res[56] = remi_sumb_deop();
+ res[57] = remi_sumc_deop();
+ res[58] = remi_sumf_deop();
+ res[59] = remi_sump_deop((short)1);
+
+ res[60] = remi_sum_cond();
+ res[61] = remi_sumb_cond();
+ res[62] = remi_sumc_cond();
+ res[63] = remi_sumf_cond();
+ res[64] = remi_sump_cond((short)1);
+
+ res[65] = remi_sum2_cond();
+ res[66] = remi_sumb2_cond();
+ res[67] = remi_sumc2_cond();
+ res[68] = remi_summ2_cond();
+ res[69] = remi_sump2_cond((short)1);
+ }
+
+ int failed = 0;
+ for (int i = 0; i < ntests; i++) {
+ if (res[i] != val[i]) {
+ System.err.println(test_name[i] + ": " + res[i] + " != " + val[i]);
+ failed++;
+ }
+ }
+ if (failed > 0) {
+ System.err.println("Failed " + failed + " tests.");
+ throw new InternalError();
+ } else {
+ System.out.println("Passed.");
+ }
+ }
+}
--- a/hotspot/test/compiler/8009761/Test8009761.java Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/test/compiler/8009761/Test8009761.java Thu May 16 13:47:55 2013 -0700
@@ -25,7 +25,7 @@
* @test
* @bug 8009761
* @summary Deoptimization on sparc doesn't set Llast_SP correctly in the interpreter frames it creates
- * @run main/othervm -Xmixed -XX:-UseOnStackReplacement -XX:-BackgroundCompilation Test8009761
+ * @run main/othervm -XX:CompileCommand=exclude,Test8009761::m2 -XX:-UseOnStackReplacement -XX:-BackgroundCompilation -Xss256K Test8009761
*
*/
@@ -249,7 +249,7 @@
System.out.println("Failed: init recursive calls: " + c1 + ". After deopt " + count);
System.exit(97);
} else {
- System.out.println("PASSED");
+ System.out.println("PASSED " + c1);
}
}
}
--- a/hotspot/test/compiler/ciReplay/TestSA.sh Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/test/compiler/ciReplay/TestSA.sh Thu May 16 13:47:55 2013 -0700
@@ -77,10 +77,11 @@
"replay data wasn't generated by SA"
fi
-diff --brief ${replay_data} replay_vm.txt
-if [ $? -ne 0 ]
+diff ${replay_data} replay_vm.txt > replay.diff 2>&1
+if [ -s replay.diff ]
then
- echo WARNING: replay.txt from SA != replay.txt from VM
+ echo WARNING: replay.txt from SA != replay.txt from VM:
+ cat replay.diff
fi
common_tests 10
--- a/hotspot/test/compiler/ciReplay/common.sh Tue May 14 17:33:07 2013 +0000
+++ b/hotspot/test/compiler/ciReplay/common.sh Thu May 16 13:47:55 2013 -0700
@@ -182,8 +182,11 @@
# crash vm in compiler thread with generation replay data and 'small' dump-file
# $@ - additional vm opts
generate_replay() {
- # enable core dump
- ulimit -c unlimited
+ if [ $VM_OS != "windows" ]
+ then
+ # enable core dump
+ ulimit -c unlimited
+ fi
cmd="${JAVA} ${TESTVMOPTS} $@ \
-Xms8m \
@@ -206,29 +209,24 @@
echo GENERATION OF REPLAY.TXT:
echo $cmd
- ${cmd} 2>&1 > crash.out
+ ${cmd} > crash.out 2>&1
core_locations=`grep -i core crash.out | grep "location:" | \
sed -e 's/.*location: //'`
rm crash.out
# processing core locations for *nix
- if [ $OS != "windows" ]
+ if [ $VM_OS != "windows" ]
then
# remove 'or' between '/core.<pid>' and 'core'
core_locations=`echo $core_locations | \
sed -e 's/\([^ ]*\) or \([^ ]*\)/\1 \2/'`
# add <core_path>/core.<pid> core.<pid>
- core=`echo $core_locations | awk '{print $1}'`
- dir=`dirname $core`
- core=`basename $core`
- if [ -n ${core} ]
+ core_with_dir=`echo $core_locations | awk '{print $1}'`
+ dir=`dirname $core_with_dir`
+ core_with_pid=`echo $core_locations | awk '{print $2}'`
+ if [ -n ${core_with_pid} ]
then
- core_locations="$core_locations $dir${FS}$core"
- fi
- core=`echo $core_locations | awk '{print $2}'`
- if [ -n ${core} ]
- then
- core_locations="$core_locations $dir${FS}$core"
+ core_locations="$core_locations $dir${FS}$core_with_pid $core_with_pid"
fi
fi