Mercurial > hg > truffle
changeset 10283:e484fe2abebd
Merge
| author | twisti |
|---|---|
| date | Thu, 16 May 2013 13:47:55 -0700 |
| parents | 513a5298c1dd (current diff) cd6f6fccd287 (diff) |
| children | 2f9ac66165e6 |
| files | make/bsd/makefiles/launcher.make make/bsd/makefiles/vm.make make/linux/makefiles/launcher.make make/solaris/makefiles/launcher.make make/windows/makefiles/launcher.make src/os/posix/launcher/java_md.c src/os/posix/launcher/java_md.h src/os/posix/launcher/launcher.script src/os/windows/launcher/java_md.c src/os/windows/launcher/java_md.h src/share/tools/launcher/java.c src/share/tools/launcher/java.h src/share/tools/launcher/jli_util.c src/share/tools/launcher/jli_util.h src/share/tools/launcher/wildcard.c src/share/tools/launcher/wildcard.h src/share/vm/classfile/classFileParser.cpp src/share/vm/oops/method.cpp src/share/vm/prims/methodHandles.cpp src/share/vm/runtime/arguments.cpp src/share/vm/runtime/vmStructs.cpp src/share/vm/utilities/quickSort.cpp |
| diffstat | 94 files changed, 6292 insertions(+), 7875 deletions(-) [+] |
line wrap: on
line diff
--- a/make/Makefile Tue May 14 17:33:07 2013 +0000 +++ b/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/make/bsd/makefiles/buildtree.make Tue May 14 17:33:07 2013 +0000 +++ b/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/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/make/bsd/makefiles/vm.make Tue May 14 17:33:07 2013 +0000 +++ b/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/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/make/jprt.properties Tue May 14 17:33:07 2013 +0000 +++ b/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/make/linux/makefiles/buildtree.make Tue May 14 17:33:07 2013 +0000 +++ b/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/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/make/linux/makefiles/vm.make Tue May 14 17:33:07 2013 +0000 +++ b/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/make/solaris/makefiles/buildtree.make Tue May 14 17:33:07 2013 +0000 +++ b/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/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/make/solaris/makefiles/vm.make Tue May 14 17:33:07 2013 +0000 +++ b/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/make/windows/makefiles/debug.make Tue May 14 17:33:07 2013 +0000 +++ b/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/make/windows/makefiles/fastdebug.make Tue May 14 17:33:07 2013 +0000 +++ b/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/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/make/windows/makefiles/product.make Tue May 14 17:33:07 2013 +0000 +++ b/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/make/windows/makefiles/projectcreator.make Tue May 14 17:33:07 2013 +0000 +++ b/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/make/windows/projectfiles/common/Makefile Tue May 14 17:33:07 2013 +0000 +++ b/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/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/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/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/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/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/src/share/tools/ProjectCreator/BuildConfig.java Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/tools/ProjectCreator/WinGammaPlatformVC10.java Tue May 14 17:33:07 2013 +0000 +++ b/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/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/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/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/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/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/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/src/share/vm/ci/ciInstanceKlass.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/ci/ciInstanceKlass.hpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/ci/ciMethod.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/ci/ciMethod.hpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/classfile/classFileParser.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/classfile/vmSymbols.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/classfile/vmSymbols.hpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/compiler/compileBroker.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/oops/method.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/bytecodeInfo.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/c2_globals.hpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/c2compiler.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/callGenerator.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/callGenerator.hpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/callnode.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/callnode.hpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/cfgnode.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/compile.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/compile.hpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/doCall.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/escape.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/graphKit.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/ifnode.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/lcm.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/library_call.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/loopPredicate.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/machnode.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/macro.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/macro.hpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/memnode.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/memnode.hpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/multnode.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/multnode.hpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/node.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/node.hpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/output.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/parse.hpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/parse1.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/parse2.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/parse3.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/parseHelper.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/phase.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/phase.hpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/phaseX.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/runtime.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/subnode.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/type.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/opto/type.hpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/prims/methodHandles.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/prims/nativeLookup.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/runtime/arguments.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/runtime/sharedRuntime.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/runtime/vmStructs.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/src/share/vm/utilities/quickSort.cpp Tue May 14 17:33:07 2013 +0000 +++ b/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/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/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/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/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/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/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/test/compiler/8009761/Test8009761.java Tue May 14 17:33:07 2013 +0000 +++ b/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/test/compiler/ciReplay/TestSA.sh Tue May 14 17:33:07 2013 +0000 +++ b/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/test/compiler/ciReplay/common.sh Tue May 14 17:33:07 2013 +0000 +++ b/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