stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge

Browse Source
This commit is contained in:
J. Duke 2017-07-05 19:46:27 +02:00
commit 570afa4e42
652 changed files with 8731 additions and 6766 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.hgtags-top-repo
View File

@ -261,3 +261,4 @@ b114474fb25af4e73cb7219f7c04bd8994da03a5 jdk9-b15
cf22a728521f91a4692b433d39d730a0a1b23155 jdk9-b16
24152ee0ee1abef54a8bab04c099261dba7bcca5 jdk9-b17
65abab59f783fcf02ff8e133431c252f9e5f07d5 jdk9-b18
75a08df650eb3126bab0c4d15241f5886162393c jdk9-b19

315
common/autoconf/flags.m4
View File

@ -116,15 +116,15 @@ AC_DEFUN_ONCE([FLAGS_SETUP_INIT_FLAGS],
AC_SUBST(RC_FLAGS)
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
# FIXME: likely bug, should be CCXXFLAGS_JDK? or one for C or CXX.
CCXXFLAGS="$CCXXFLAGS -nologo"
# silence copyright notice and other headers.
COMMON_CCXXFLAGS="$COMMON_CCXXFLAGS -nologo"
fi
if test "x$SYSROOT" != "x"; then
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
# Solaris Studio does not have a concept of sysroot. Instead we must
# make sure the default include and lib dirs are appended to each
# make sure the default include and lib dirs are appended to each
# compile and link command line.
SYSROOT_CFLAGS="-I$SYSROOT/usr/include"
SYSROOT_LDFLAGS="-L$SYSROOT/usr/lib$OPENJDK_TARGET_CPU_ISADIR \
@ -302,6 +302,7 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION],
# Debug symbols
if test "x$TOOLCHAIN_TYPE" = xgcc; then
if test "x$OPENJDK_TARGET_CPU_BITS" = "x64" && test "x$DEBUG_LEVEL" = "xfastdebug"; then
# reduce from default "-g2" option to save space
CFLAGS_DEBUG_SYMBOLS="-g1"
CXXFLAGS_DEBUG_SYMBOLS="-g1"
else
@ -313,6 +314,7 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION],
CXXFLAGS_DEBUG_SYMBOLS="-g"
elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
CFLAGS_DEBUG_SYMBOLS="-g -xs"
# FIXME: likely a bug, this disables debug symbols rather than enables them
CXXFLAGS_DEBUG_SYMBOLS="-g0 -xs"
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
CFLAGS_DEBUG_SYMBOLS="-g"
@ -321,6 +323,31 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION],
AC_SUBST(CFLAGS_DEBUG_SYMBOLS)
AC_SUBST(CXXFLAGS_DEBUG_SYMBOLS)
# bounds, memory and behavior checking options
if test "x$TOOLCHAIN_TYPE" = xgcc; then
case $DEBUG_LEVEL in
release )
# no adjustment
;;
fastdebug )
# Add compile time bounds checks.
CFLAGS_DEBUG_OPTIONS="-U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1"
CXXFLAGS_DEBUG_OPTIONS="-U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1"
;;
slowdebug )
# Add runtime bounds checks and symbol info.
CFLAGS_DEBUG_OPTIONS="-U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fstack-protector-all --param ssp-buffer-size=1"
CXXFLAGS_DEBUG_OPTIONS="-U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fstack-protector-all --param ssp-buffer-size=1"
if test "x$HAS_CFLAG_DETECT_UNDEFINED_BEHAVIOR" = "xtrue"; then
CFLAGS_DEBUG_OPTIONS="$CFLAGS_DEBUG_OPTIONS $CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG"
CXXFLAGS_DEBUG_OPTIONS="$CXXFLAGS_DEBUG_OPTIONS $CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG"
fi
;;
esac
fi
AC_SUBST(CFLAGS_DEBUG_OPTIONS)
AC_SUBST(CXXFLAGS_DEBUG_OPTIONS)
# Optimization levels
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
CC_HIGHEST="$CC_HIGHEST -fns -fsimple -fsingle -xbuiltin=%all -xdepend -xrestrict -xlibmil"
@ -330,10 +357,12 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION],
C_O_FLAG_HIGHEST="-xO4 -Wu,-O4~yz $CC_HIGHEST -xalias_level=basic -xregs=no%frameptr"
C_O_FLAG_HI="-xO4 -Wu,-O4~yz -xregs=no%frameptr"
C_O_FLAG_NORM="-xO2 -Wu,-O2~yz -xregs=no%frameptr"
C_O_FLAG_DEBUG="-xregs=no%frameptr"
C_O_FLAG_NONE="-xregs=no%frameptr"
CXX_O_FLAG_HIGHEST="-xO4 -Qoption ube -O4~yz $CC_HIGHEST -xregs=no%frameptr"
CXX_O_FLAG_HI="-xO4 -Qoption ube -O4~yz -xregs=no%frameptr"
CXX_O_FLAG_NORM="-xO2 -Qoption ube -O2~yz -xregs=no%frameptr"
CXX_O_FLAG_DEBUG="-xregs=no%frameptr"
CXX_O_FLAG_NONE="-xregs=no%frameptr"
if test "x$OPENJDK_TARGET_CPU_BITS" = "x32"; then
C_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST -xchip=pentium"
@ -343,10 +372,12 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION],
C_O_FLAG_HIGHEST="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0 $CC_HIGHEST -xalias_level=basic -xprefetch=auto,explicit -xchip=ultra"
C_O_FLAG_HI="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0"
C_O_FLAG_NORM="-xO2 -Wc,-Qrm-s -Wc,-Qiselect-T0"
C_O_FLAG_DEBUG=""
C_O_FLAG_NONE=""
CXX_O_FLAG_HIGHEST="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra"
CXX_O_FLAG_HI="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0"
CXX_O_FLAG_NORM="-xO2 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0"
C_O_FLAG_DEBUG=""
CXX_O_FLAG_NONE=""
fi
else
@ -359,13 +390,17 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION],
C_O_FLAG_HIGHEST="-Os"
C_O_FLAG_HI="-Os"
C_O_FLAG_NORM="-Os"
C_O_FLAG_NONE=""
else
C_O_FLAG_HIGHEST="-O3"
C_O_FLAG_HI="-O3"
C_O_FLAG_NORM="-O2"
C_O_FLAG_NONE="-O0"
fi
if test "x$HAS_CFLAG_OPTIMIZE_DEBUG" = "xtrue"; then
C_O_FLAG_DEBUG="$CFLAG_OPTIMIZE_DEBUG_FLAG"
else
C_O_FLAG_DEBUG="-O0"
fi
C_O_FLAG_NONE="-O0"
elif test "x$TOOLCHAIN_TYPE" = xclang; then
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
# On MacOSX we optimize for size, something
@ -373,37 +408,63 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION],
C_O_FLAG_HIGHEST="-Os"
C_O_FLAG_HI="-Os"
C_O_FLAG_NORM="-Os"
C_O_FLAG_NONE=""
else
C_O_FLAG_HIGHEST="-O3"
C_O_FLAG_HI="-O3"
C_O_FLAG_NORM="-O2"
C_O_FLAG_NONE="-O0"
fi
C_O_FLAG_DEBUG="-O0"
C_O_FLAG_NONE="-O0"
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
C_O_FLAG_HIGHEST="-O3"
C_O_FLAG_HI="-O3 -qstrict"
C_O_FLAG_NORM="-O2"
C_O_FLAG_NONE=""
C_O_FLAG_DEBUG="-qnoopt"
C_O_FLAG_NONE="-qnoop"
elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
C_O_FLAG_HIGHEST="-O2"
C_O_FLAG_HI="-O1"
C_O_FLAG_NORM="-O1"
C_O_FLAG_DEBUG="-Od"
C_O_FLAG_NONE="-Od"
fi
CXX_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST"
CXX_O_FLAG_HI="$C_O_FLAG_HI"
CXX_O_FLAG_NORM="$C_O_FLAG_NORM"
CXX_O_FLAG_DEBUG="$C_O_FLAG_DEBUG"
CXX_O_FLAG_NONE="$C_O_FLAG_NONE"
fi
# Adjust optimization flags according to debug level.
case $DEBUG_LEVEL in
release )
# no adjustment
;;
fastdebug )
# Not quite so much optimization
C_O_FLAG_HI="$C_O_FLAG_NORM"
CXX_O_FLAG_HI="$CXX_O_FLAG_NORM"
;;
slowdebug )
# Disable optimization
C_O_FLAG_HIGHEST="$C_O_FLAG_DEBUG"
C_O_FLAG_HI="$C_O_FLAG_DEBUG"
C_O_FLAG_NORM="$C_O_FLAG_DEBUG"
CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_DEBUG"
CXX_O_FLAG_HI="$CXX_O_FLAG_DEBUG"
CXX_O_FLAG_NORM="$CXX_O_FLAG_DEBUG"
;;
esac
AC_SUBST(C_O_FLAG_HIGHEST)
AC_SUBST(C_O_FLAG_HI)
AC_SUBST(C_O_FLAG_NORM)
AC_SUBST(C_O_FLAG_DEBUG)
AC_SUBST(C_O_FLAG_NONE)
AC_SUBST(CXX_O_FLAG_HIGHEST)
AC_SUBST(CXX_O_FLAG_HI)
AC_SUBST(CXX_O_FLAG_NORM)
AC_SUBST(CXX_O_FLAG_DEBUG)
AC_SUBST(CXX_O_FLAG_NONE)
])
@ -461,11 +522,12 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
# Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build.
#
# Setup compiler/platform specific flags to CFLAGS_JDK,
# CXXFLAGS_JDK and CCXXFLAGS_JDK (common to C and CXX?)
# Setup compiler/platform specific flags into
# CFLAGS_JDK - C Compiler flags
# CXXFLAGS_JDK - C++ Compiler flags
# COMMON_CCXXFLAGS_JDK - common to C and C++
if test "x$TOOLCHAIN_TYPE" = xgcc; then
# these options are used for both C and C++ compiles
CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -Wall -Wno-parentheses -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -Wall -Wno-parentheses -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
-pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
case $OPENJDK_TARGET_CPU_ARCH in
arm )
@ -477,31 +539,31 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
;;
* )
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -fno-omit-frame-pointer"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer"
CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
;;
esac
elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
if test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_TARGET_CPU_LEGACY_LIB"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_TARGET_CPU_LEGACY_LIB"
CFLAGS_JDK="$CFLAGS_JDK -erroff=E_BAD_PRAGMA_PACK_VALUE"
fi
CFLAGS_JDK="$CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal"
CXXFLAGS_JDK="$CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib"
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
CFLAGS_JDK="$CFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
CXXFLAGS_JDK="$CXXFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \
-D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB -DWIN32_LEAN_AND_MEAN \
-D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
-DWIN32 -DIAL"
if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_AMD64_ -Damd64"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_AMD64_ -Damd64"
else
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_X86_ -Dx86"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_X86_ -Dx86"
fi
fi
@ -509,28 +571,20 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
# Adjust flags according to debug level.
case $DEBUG_LEVEL in
fastdebug )
CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS"
CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS"
C_O_FLAG_HI="$C_O_FLAG_NORM"
C_O_FLAG_NORM="$C_O_FLAG_NORM"
CXX_O_FLAG_HI="$CXX_O_FLAG_NORM"
CXX_O_FLAG_NORM="$CXX_O_FLAG_NORM"
fastdebug | slowdebug )
CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS $CFLAGS_DEBUG_OPTIONS"
CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS $CXXFLAGS_DEBUG_OPTIONS"
JAVAC_FLAGS="$JAVAC_FLAGS -g"
;;
slowdebug )
CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS"
CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS"
C_O_FLAG_HI="$C_O_FLAG_NONE"
C_O_FLAG_NORM="$C_O_FLAG_NONE"
CXX_O_FLAG_HI="$CXX_O_FLAG_NONE"
CXX_O_FLAG_NORM="$CXX_O_FLAG_NONE"
JAVAC_FLAGS="$JAVAC_FLAGS -g"
release )
;;
* )
AC_MSG_ERROR([Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL])
;;
esac
# Setup LP64
CCXXFLAGS_JDK="$CCXXFLAGS_JDK $ADD_LP64"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK $ADD_LP64"
# Set some common defines. These works for all compilers, but assume
# -D is universally accepted.
@ -543,49 +597,49 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
# Note: -Dmacro is the same as #define macro 1
# -Dmacro= is the same as #define macro
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN="
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN="
else
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN"
fi
else
# Same goes for _BIG_ENDIAN. Do we really need to set *ENDIAN on Solaris if they
# are defined in the system?
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_BIG_ENDIAN="
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN="
else
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_BIG_ENDIAN"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN"
fi
fi
# Setup target OS define. Use OS target name but in upper case.
OPENJDK_TARGET_OS_UPPERCASE=`$ECHO $OPENJDK_TARGET_OS | $TR 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D$OPENJDK_TARGET_OS_UPPERCASE"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D$OPENJDK_TARGET_OS_UPPERCASE"
# Setup target CPU
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DARCH='\"$OPENJDK_TARGET_CPU_LEGACY\"' -D$OPENJDK_TARGET_CPU_LEGACY"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DARCH='\"$OPENJDK_TARGET_CPU_LEGACY\"' -D$OPENJDK_TARGET_CPU_LEGACY"
# Setup debug/release defines
if test "x$DEBUG_LEVEL" = xrelease; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DNDEBUG"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DNDEBUG"
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DTRIMMED"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DTRIMMED"
fi
else
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DDEBUG"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DDEBUG"
fi
# Setup release name
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DRELEASE='\"\$(RELEASE)\"'"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DRELEASE='\"\$(RELEASE)\"'"
# Set some additional per-OS defines.
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT"
elif test "x$OPENJDK_TARGET_OS" = xaix; then
# FIXME: PPC64 should not be here.
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DPPC64"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DPPC64"
elif test "x$OPENJDK_TARGET_OS" = xbsd; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_ALLBSD_SOURCE"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE"
fi
# Additional macosx handling
@ -595,22 +649,22 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
# FIXME: clean this up, and/or move it elsewhere.
# Setting these parameters makes it an error to link to macosx APIs that are
# newer than the given OS version and makes the linked binaries compatible
# newer than the given OS version and makes the linked binaries compatible
# even if built on a newer version of the OS.
# The expected format is X.Y.Z
MACOSX_VERSION_MIN=10.7.0
AC_SUBST(MACOSX_VERSION_MIN)
# The macro takes the version with no dots, ex: 1070
# Let the flags variables get resolved in make for easier override on make
# command line.
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MIN)) -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MIN)) -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
LDFLAGS_JDK="$LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
fi
fi
# Setup some hard coded includes
CCXXFLAGS_JDK="$CCXXFLAGS_JDK \
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK \
-I${JDK_OUTPUTDIR}/include \
-I${JDK_OUTPUTDIR}/include/$OPENJDK_TARGET_OS \
-I${JDK_TOPDIR}/src/share/javavm/export \
@ -619,12 +673,12 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
-I${JDK_TOPDIR}/src/$OPENJDK_TARGET_OS_API_DIR/native/common"
# The shared libraries are compiled using the picflag.
CFLAGS_JDKLIB="$CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"
CXXFLAGS_JDKLIB="$CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA "
CFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"
CXXFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA "
# Executable flags
CFLAGS_JDKEXE="$CCXXFLAGS_JDK $CFLAGS_JDK"
CXXFLAGS_JDKEXE="$CCXXFLAGS_JDK $CXXFLAGS_JDK"
CFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK"
CXXFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK"
AC_SUBST(CFLAGS_JDKLIB)
AC_SUBST(CFLAGS_JDKEXE)
@ -633,6 +687,7 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
# Setup LDFLAGS et al.
#
# Now this is odd. The JDK native libraries have to link against libjvm.so
# On 32-bit machines there is normally two distinct libjvm.so:s, client and server.
# Which should we link to? Are we lucky enough that the binary api to the libjvm.so library
@ -648,39 +703,93 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
fi
# TODO: make -debug optional "--disable-full-debug-symbols"
LDFLAGS_JDK="$LDFLAGS_JDK -debug"
LDFLAGS_JDKLIB="${LDFLAGS_JDK} -dll -libpath:${JDK_OUTPUTDIR}/lib"
LDFLAGS_JDKLIB_SUFFIX=""
elif test "x$TOOLCHAIN_TYPE" = xgcc; then
# If this is a --hash-style=gnu system, use --hash-style=both, why?
# We have previously set HAS_GNU_HASH if this is the case
if test -n "$HAS_GNU_HASH"; then
LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker --hash-style=both"
fi
if test "x$OPENJDK_TARGET_OS" = xlinux; then
# And since we now know that the linker is gnu, then add -z defs, to forbid
# undefined symbols in object files.
LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -z -Xlinker defs"
case $DEBUG_LEVEL in
release )
# tell linker to optimize libraries.
# Should this be supplied to the OSS linker as well?
LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -O1"
;;
slowdebug )
if test "x$HAS_LINKER_NOW" = "xtrue"; then
# do relocations at load
LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_NOW_FLAG"
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_NOW_FLAG"
fi
if test "x$HAS_LINKER_RELRO" = "xtrue"; then
# mark relocations read only
LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_RELRO_FLAG"
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_RELRO_FLAG"
fi
;;
fastdebug )
if test "x$HAS_LINKER_RELRO" = "xtrue"; then
# mark relocations read only
LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_RELRO_FLAG"
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_RELRO_FLAG"
fi
;;
* )
AC_MSG_ERROR([Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL])
;;
esac
fi
elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
LDFLAGS_JDK="$LDFLAGS_JDK -z defs -xildoff -ztext"
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK -norunpath -xnolib"
fi
if test "x$TOOLCHAIN_TYPE" = xgcc || test "x$TOOLCHAIN_TYPE" = xclang; then
# If undefined behaviour detection is enabled then we need to tell linker.
case $DEBUG_LEVEL in
release | fastdebug )
;;
slowdebug )
AC_MSG_WARN([$HAS_CFLAG_DETECT_UNDEFINED_BEHAVIOR])
if test "x$HAS_CFLAG_DETECT_UNDEFINED_BEHAVIOR" = "xtrue"; then
# enable undefined behaviour checking
LDFLAGS_JDK="$LDFLAGS_JDK `$ECHO -n $CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG | sed -e "s/[ ]*\([^ ]\+\)/ -Xlinker \1/g"`"
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK `$ECHO -n $CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG | sed -e "s/[ ]*\([^ ]\+\)/ -Xlinker \1/g"`"
fi
;;
* )
AC_MSG_ERROR([Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL])
;;
esac
fi
# Customize LDFLAGS for executables
LDFLAGS_JDKEXE="${LDFLAGS_JDK}"
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
LDFLAGS_STACK_SIZE=1048576
else
LDFLAGS_STACK_SIZE=327680
fi
LDFLAGS_JDKEXE="${LDFLAGS_JDK} /STACK:$LDFLAGS_STACK_SIZE"
LDFLAGS_JDKEXE="${LDFLAGS_JDKEXE} /STACK:$LDFLAGS_STACK_SIZE"
elif test "x$OPENJDK_TARGET_OS" = xlinux; then
LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE -Xlinker --allow-shlib-undefined"
fi
# Customize LDFLAGS for libs
LDFLAGS_JDKLIB="${LDFLAGS_JDK}"
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -dll -libpath:${JDK_OUTPUTDIR}/lib"
LDFLAGS_JDKLIB_SUFFIX=""
else
if test "x$TOOLCHAIN_TYPE" = xgcc; then
# If this is a --hash-style=gnu system, use --hash-style=both, why?
# We have previously set HAS_GNU_HASH if this is the case
if test -n "$HAS_GNU_HASH"; then
LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker --hash-style=both "
fi
if test "x$OPENJDK_TARGET_OS" = xlinux; then
# And since we now know that the linker is gnu, then add -z defs, to forbid
# undefined symbols in object files.
LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -z -Xlinker defs"
if test "x$DEBUG_LEVEL" = "xrelease"; then
# When building release libraries, tell the linker optimize them.
# Should this be supplied to the OSS linker as well?
LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -O1"
fi
fi
fi
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
LDFLAGS_JDK="$LDFLAGS_JDK -z defs -xildoff -ztext"
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK -norunpath -xnolib"
fi
LDFLAGS_JDKLIB="${LDFLAGS_JDK} $SHARED_LIBRARY_FLAGS \
LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} ${SHARED_LIBRARY_FLAGS} \
-L${JDK_OUTPUTDIR}/lib${OPENJDK_TARGET_CPU_LIBDIR}"
# On some platforms (mac) the linker warns about non existing -L dirs.
@ -701,12 +810,8 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
LDFLAGS_JDKLIB_SUFFIX="$LDFLAGS_JDKLIB_SUFFIX -lc"
fi
LDFLAGS_JDKEXE="${LDFLAGS_JDK}"
if test "x$OPENJDK_TARGET_OS" = xlinux; then
LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE -Xlinker --allow-shlib-undefined"
fi
fi
AC_SUBST(LDFLAGS_JDKLIB)
AC_SUBST(LDFLAGS_JDKEXE)
AC_SUBST(LDFLAGS_JDKLIB_SUFFIX)
@ -714,7 +819,6 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
AC_SUBST(LDFLAGS_CXX_JDK)
])
# FLAGS_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
# [RUN-IF-FALSE])
# ------------------------------------------------------------
@ -727,7 +831,7 @@ AC_DEFUN([FLAGS_COMPILER_CHECK_ARGUMENTS],
saved_cflags="$CFLAGS"
CFLAGS="$CFLAGS $1"
AC_LANG_PUSH([C])
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int i;]])], [],
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int i;]])], [],
[supports=no])
AC_LANG_POP([C])
CFLAGS="$saved_cflags"
@ -735,7 +839,7 @@ AC_DEFUN([FLAGS_COMPILER_CHECK_ARGUMENTS],
saved_cxxflags="$CXXFLAGS"
CXXFLAGS="$CXXFLAG $1"
AC_LANG_PUSH([C++])
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int i;]])], [],
AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int i;]])], [],
[supports=no])
AC_LANG_POP([C++])
CXXFLAGS="$saved_cxxflags"
@ -748,6 +852,31 @@ AC_DEFUN([FLAGS_COMPILER_CHECK_ARGUMENTS],
fi
])
# FLAGS_LINKER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
# [RUN-IF-FALSE])
# ------------------------------------------------------------
# Check that the linker support an argument
AC_DEFUN([FLAGS_LINKER_CHECK_ARGUMENTS],
[
AC_MSG_CHECKING([if linker supports "$1"])
supports=yes
saved_ldflags="$LDFLAGS"
LDFLAGS="$LDFLAGS $1"
AC_LANG_PUSH([C])
AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])],
[], [supports=no])
AC_LANG_POP([C])
LDFLAGS="$saved_ldflags"
AC_MSG_RESULT([$supports])
if test "x$supports" = "xyes" ; then
m4_ifval([$2], [$2], [:])
else
m4_ifval([$3], [$3], [:])
fi
])
AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_MISC],
[
# Some Zero and Shark settings.

575
common/autoconf/generated-configure.sh
View File

@ -692,13 +692,17 @@ LEGACY_EXTRA_LDFLAGS
LEGACY_EXTRA_CXXFLAGS
LEGACY_EXTRA_CFLAGS
CXX_O_FLAG_NONE
CXX_O_FLAG_DEBUG
CXX_O_FLAG_NORM
CXX_O_FLAG_HI
CXX_O_FLAG_HIGHEST
C_O_FLAG_NONE
C_O_FLAG_DEBUG
C_O_FLAG_NORM
C_O_FLAG_HI
C_O_FLAG_HIGHEST
CXXFLAGS_DEBUG_OPTIONS
CFLAGS_DEBUG_OPTIONS
CXXFLAGS_DEBUG_SYMBOLS
CFLAGS_DEBUG_SYMBOLS
CXX_FLAG_DEPS
@ -2346,6 +2350,52 @@ fi
} # ac_fn_objc_try_compile
# ac_fn_c_try_link LINENO
# -----------------------
# Try to link conftest.$ac_ext, and return whether this succeeded.
ac_fn_c_try_link ()
{
as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
rm -f conftest.$ac_objext conftest$ac_exeext
if { { ac_try="$ac_link"
case "(($ac_try" in
*\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
*) ac_try_echo=$ac_try;;
esac
eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
$as_echo "$ac_try_echo"; } >&5
(eval "$ac_link") 2>conftest.err
ac_status=$?
if test -s conftest.err; then
grep -v '^ *+' conftest.err >conftest.er1
cat conftest.er1 >&5
mv -f conftest.er1 conftest.err
fi
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; } && {
test -z "$ac_c_werror_flag" ||
test ! -s conftest.err
} && test -s conftest$ac_exeext && {
test "$cross_compiling" = yes ||
test -x conftest$ac_exeext
}; then :
ac_retval=0
else
$as_echo "$as_me: failed program was:" >&5
sed 's/^/| /' conftest.$ac_ext >&5
ac_retval=1
fi
# Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
# created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
# interfere with the next link command; also delete a directory that is
# left behind by Apple's compiler. We do this before executing the actions.
rm -rf conftest.dSYM conftest_ipa8_conftest.oo
eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
as_fn_set_status $ac_retval
} # ac_fn_c_try_link
# ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
# ---------------------------------------------------------
# Tests whether HEADER exists, giving a warning if it cannot be compiled using
@ -3761,13 +3811,18 @@ ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var.
# FLAGS_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
# [RUN-IF-FALSE])
# ------------------------------------------------------------
# Check that the c and c++ compilers support an argument
# FLAGS_LINKER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE],
# [RUN-IF-FALSE])
# ------------------------------------------------------------
# Check that the linker support an argument
#
@ -4253,7 +4308,7 @@ TOOLCHAIN_DESCRIPTION_xlc="IBM XL C/C++"
#CUSTOM_AUTOCONF_INCLUDE
# Do not change or remove the following line, it is needed for consistency checks:
DATE_WHEN_GENERATED=1399969244
DATE_WHEN_GENERATED=1402614845
###############################################################################
#
@ -40264,6 +40319,8 @@ $as_echo "$as_me: Rewriting BUILD_LD to \"$new_complete\"" >&6;}
# The package path is used only on macosx?
# FIXME: clean this up, and/or move it elsewhere.
PACKAGE_PATH=/opt/local
@ -40289,6 +40346,242 @@ $as_echo "$as_me: Rewriting BUILD_LD to \"$new_complete\"" >&6;}
# If this is a --hash-style=gnu system, use --hash-style=both, why?
HAS_GNU_HASH=`$CC -dumpspecs 2>/dev/null | $GREP 'hash-style=gnu'`
# This is later checked when setting flags.
# "-Og" suppported for GCC 4.8 and later
CFLAG_OPTIMIZE_DEBUG_FLAG="-Og"
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if compiler supports \"$CFLAG_OPTIMIZE_DEBUG_FLAG\"" >&5
$as_echo_n "checking if compiler supports \"$CFLAG_OPTIMIZE_DEBUG_FLAG\"... " >&6; }
supports=yes
saved_cflags="$CFLAGS"
CFLAGS="$CFLAGS $CFLAG_OPTIMIZE_DEBUG_FLAG"
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int i;
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
else
supports=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
CFLAGS="$saved_cflags"
saved_cxxflags="$CXXFLAGS"
CXXFLAGS="$CXXFLAG $CFLAG_OPTIMIZE_DEBUG_FLAG"
ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int i;
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
else
supports=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
CXXFLAGS="$saved_cxxflags"
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
$as_echo "$supports" >&6; }
if test "x$supports" = "xyes" ; then
HAS_CFLAG_OPTIMIZE_DEBUG=true
else
HAS_CFLAG_OPTIMIZE_DEBUG=false
fi
# "-fsanitize=undefined" supported for GCC 4.9 and later
CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG="-fsanitize=undefined -fsanitize-recover"
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if compiler supports \"$CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG\"" >&5
$as_echo_n "checking if compiler supports \"$CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG\"... " >&6; }
supports=yes
saved_cflags="$CFLAGS"
CFLAGS="$CFLAGS $CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG"
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int i;
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
else
supports=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
CFLAGS="$saved_cflags"
saved_cxxflags="$CXXFLAGS"
CXXFLAGS="$CXXFLAG $CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG"
ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int i;
_ACEOF
if ac_fn_cxx_try_compile "$LINENO"; then :
else
supports=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
CXXFLAGS="$saved_cxxflags"
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
$as_echo "$supports" >&6; }
if test "x$supports" = "xyes" ; then
HAS_CFLAG_DETECT_UNDEFINED_BEHAVIOR=true
else
HAS_CFLAG_DETECT_UNDEFINED_BEHAVIOR=false
fi
# "-z relro" supported in GNU binutils 2.17 and later
LINKER_RELRO_FLAG="-Xlinker -z -Xlinker relro"
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if linker supports \"$LINKER_RELRO_FLAG\"" >&5
$as_echo_n "checking if linker supports \"$LINKER_RELRO_FLAG\"... " >&6; }
supports=yes
saved_ldflags="$LDFLAGS"
LDFLAGS="$LDFLAGS $LINKER_RELRO_FLAG"
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main ()
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
else
supports=no
fi
rm -f core conftest.err conftest.$ac_objext \
conftest$ac_exeext conftest.$ac_ext
ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
LDFLAGS="$saved_ldflags"
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
$as_echo "$supports" >&6; }
if test "x$supports" = "xyes" ; then
HAS_LINKER_RELRO=true
else
HAS_LINKER_RELRO=false
fi
# "-z now" supported in GNU binutils 2.11 and later
LINKER_NOW_FLAG="-Xlinker -z -Xlinker now"
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if linker supports \"$LINKER_NOW_FLAG\"" >&5
$as_echo_n "checking if linker supports \"$LINKER_NOW_FLAG\"... " >&6; }
supports=yes
saved_ldflags="$LDFLAGS"
LDFLAGS="$LDFLAGS $LINKER_NOW_FLAG"
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main ()
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
else
supports=no
fi
rm -f core conftest.err conftest.$ac_objext \
conftest$ac_exeext conftest.$ac_ext
ac_ext=cpp
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
LDFLAGS="$saved_ldflags"
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
$as_echo "$supports" >&6; }
if test "x$supports" = "xyes" ; then
HAS_LINKER_NOW=true
else
HAS_LINKER_NOW=false
fi
fi
# Check for broken SuSE 'ld' for which 'Only anonymous version tag is allowed
@ -40297,8 +40590,8 @@ $as_echo "$as_me: Rewriting BUILD_LD to \"$new_complete\"" >&6;}
if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$TOOLCHAIN_TYPE" = xgcc; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for broken SuSE 'ld' which only understands anonymous version tags in executables" >&5
$as_echo_n "checking for broken SuSE 'ld' which only understands anonymous version tags in executables... " >&6; }
echo "SUNWprivate_1.1 { local: *; };" > version-script.map
echo "int main() { }" > main.c
$ECHO "SUNWprivate_1.1 { local: *; };" > version-script.map
$ECHO "int main() { }" > main.c
if $CXX -Xlinker -version-script=version-script.map main.c 2>&5 >&5; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
@ -40768,8 +41061,8 @@ $as_echo "$tool_specified" >&6; }
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
# FIXME: likely bug, should be CCXXFLAGS_JDK? or one for C or CXX.
CCXXFLAGS="$CCXXFLAGS -nologo"
# silence copyright notice and other headers.
COMMON_CCXXFLAGS="$COMMON_CCXXFLAGS -nologo"
fi
if test "x$SYSROOT" != "x"; then
@ -40803,7 +41096,6 @@ $as_echo "$tool_specified" >&6; }
# Now we can test some aspects on the target using configure macros.
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
$as_echo_n "checking for ANSI C header files... " >&6; }
if ${ac_cv_header_stdc+:} false; then :
@ -41488,6 +41780,7 @@ $as_echo "$ac_cv_c_bigendian" >&6; }
# Debug symbols
if test "x$TOOLCHAIN_TYPE" = xgcc; then
if test "x$OPENJDK_TARGET_CPU_BITS" = "x64" && test "x$DEBUG_LEVEL" = "xfastdebug"; then
# reduce from default "-g2" option to save space
CFLAGS_DEBUG_SYMBOLS="-g1"
CXXFLAGS_DEBUG_SYMBOLS="-g1"
else
@ -41499,6 +41792,7 @@ $as_echo "$ac_cv_c_bigendian" >&6; }
CXXFLAGS_DEBUG_SYMBOLS="-g"
elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
CFLAGS_DEBUG_SYMBOLS="-g -xs"
# FIXME: likely a bug, this disables debug symbols rather than enables them
CXXFLAGS_DEBUG_SYMBOLS="-g0 -xs"
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
CFLAGS_DEBUG_SYMBOLS="-g"
@ -41507,6 +41801,31 @@ $as_echo "$ac_cv_c_bigendian" >&6; }
# bounds, memory and behavior checking options
if test "x$TOOLCHAIN_TYPE" = xgcc; then
case $DEBUG_LEVEL in
release )
# no adjustment
;;
fastdebug )
# Add compile time bounds checks.
CFLAGS_DEBUG_OPTIONS="-U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1"
CXXFLAGS_DEBUG_OPTIONS="-U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1"
;;
slowdebug )
# Add runtime bounds checks and symbol info.
CFLAGS_DEBUG_OPTIONS="-U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fstack-protector-all --param ssp-buffer-size=1"
CXXFLAGS_DEBUG_OPTIONS="-U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fstack-protector-all --param ssp-buffer-size=1"
if test "x$HAS_CFLAG_DETECT_UNDEFINED_BEHAVIOR" = "xtrue"; then
CFLAGS_DEBUG_OPTIONS="$CFLAGS_DEBUG_OPTIONS $CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG"
CXXFLAGS_DEBUG_OPTIONS="$CXXFLAGS_DEBUG_OPTIONS $CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG"
fi
;;
esac
fi
# Optimization levels
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
CC_HIGHEST="$CC_HIGHEST -fns -fsimple -fsingle -xbuiltin=%all -xdepend -xrestrict -xlibmil"
@ -41516,10 +41835,12 @@ $as_echo "$ac_cv_c_bigendian" >&6; }
C_O_FLAG_HIGHEST="-xO4 -Wu,-O4~yz $CC_HIGHEST -xalias_level=basic -xregs=no%frameptr"
C_O_FLAG_HI="-xO4 -Wu,-O4~yz -xregs=no%frameptr"
C_O_FLAG_NORM="-xO2 -Wu,-O2~yz -xregs=no%frameptr"
C_O_FLAG_DEBUG="-xregs=no%frameptr"
C_O_FLAG_NONE="-xregs=no%frameptr"
CXX_O_FLAG_HIGHEST="-xO4 -Qoption ube -O4~yz $CC_HIGHEST -xregs=no%frameptr"
CXX_O_FLAG_HI="-xO4 -Qoption ube -O4~yz -xregs=no%frameptr"
CXX_O_FLAG_NORM="-xO2 -Qoption ube -O2~yz -xregs=no%frameptr"
CXX_O_FLAG_DEBUG="-xregs=no%frameptr"
CXX_O_FLAG_NONE="-xregs=no%frameptr"
if test "x$OPENJDK_TARGET_CPU_BITS" = "x32"; then
C_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST -xchip=pentium"
@ -41529,10 +41850,12 @@ $as_echo "$ac_cv_c_bigendian" >&6; }
C_O_FLAG_HIGHEST="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0 $CC_HIGHEST -xalias_level=basic -xprefetch=auto,explicit -xchip=ultra"
C_O_FLAG_HI="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0"
C_O_FLAG_NORM="-xO2 -Wc,-Qrm-s -Wc,-Qiselect-T0"
C_O_FLAG_DEBUG=""
C_O_FLAG_NONE=""
CXX_O_FLAG_HIGHEST="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra"
CXX_O_FLAG_HI="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0"
CXX_O_FLAG_NORM="-xO2 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0"
C_O_FLAG_DEBUG=""
CXX_O_FLAG_NONE=""
fi
else
@ -41545,13 +41868,17 @@ $as_echo "$ac_cv_c_bigendian" >&6; }
C_O_FLAG_HIGHEST="-Os"
C_O_FLAG_HI="-Os"
C_O_FLAG_NORM="-Os"
C_O_FLAG_NONE=""
else
C_O_FLAG_HIGHEST="-O3"
C_O_FLAG_HI="-O3"
C_O_FLAG_NORM="-O2"
C_O_FLAG_NONE="-O0"
fi
if test "x$HAS_CFLAG_OPTIMIZE_DEBUG" = "xtrue"; then
C_O_FLAG_DEBUG="$CFLAG_OPTIMIZE_DEBUG_FLAG"
else
C_O_FLAG_DEBUG="-O0"
fi
C_O_FLAG_NONE="-O0"
elif test "x$TOOLCHAIN_TYPE" = xclang; then
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
# On MacOSX we optimize for size, something
@ -41559,30 +41886,56 @@ $as_echo "$ac_cv_c_bigendian" >&6; }
C_O_FLAG_HIGHEST="-Os"
C_O_FLAG_HI="-Os"
C_O_FLAG_NORM="-Os"
C_O_FLAG_NONE=""
else
C_O_FLAG_HIGHEST="-O3"
C_O_FLAG_HI="-O3"
C_O_FLAG_NORM="-O2"
C_O_FLAG_NONE="-O0"
fi
C_O_FLAG_DEBUG="-O0"
C_O_FLAG_NONE="-O0"
elif test "x$TOOLCHAIN_TYPE" = xxlc; then
C_O_FLAG_HIGHEST="-O3"
C_O_FLAG_HI="-O3 -qstrict"
C_O_FLAG_NORM="-O2"
C_O_FLAG_NONE=""
C_O_FLAG_DEBUG="-qnoopt"
C_O_FLAG_NONE="-qnoop"
elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
C_O_FLAG_HIGHEST="-O2"
C_O_FLAG_HI="-O1"
C_O_FLAG_NORM="-O1"
C_O_FLAG_DEBUG="-Od"
C_O_FLAG_NONE="-Od"
fi
CXX_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST"
CXX_O_FLAG_HI="$C_O_FLAG_HI"
CXX_O_FLAG_NORM="$C_O_FLAG_NORM"
CXX_O_FLAG_DEBUG="$C_O_FLAG_DEBUG"
CXX_O_FLAG_NONE="$C_O_FLAG_NONE"
fi
# Adjust optimization flags according to debug level.
case $DEBUG_LEVEL in
release )
# no adjustment
;;
fastdebug )
# Not quite so much optimization
C_O_FLAG_HI="$C_O_FLAG_NORM"
CXX_O_FLAG_HI="$CXX_O_FLAG_NORM"
;;
slowdebug )
# Disable optimization
C_O_FLAG_HIGHEST="$C_O_FLAG_DEBUG"
C_O_FLAG_HI="$C_O_FLAG_DEBUG"
C_O_FLAG_NORM="$C_O_FLAG_DEBUG"
CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_DEBUG"
CXX_O_FLAG_HI="$CXX_O_FLAG_DEBUG"
CXX_O_FLAG_NORM="$CXX_O_FLAG_DEBUG"
;;
esac
@ -41660,11 +42013,12 @@ fi
# Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build.
#
# Setup compiler/platform specific flags to CFLAGS_JDK,
# CXXFLAGS_JDK and CCXXFLAGS_JDK (common to C and CXX?)
# Setup compiler/platform specific flags into
# CFLAGS_JDK - C Compiler flags
# CXXFLAGS_JDK - C++ Compiler flags
# COMMON_CCXXFLAGS_JDK - common to C and C++
if test "x$TOOLCHAIN_TYPE" = xgcc; then
# these options are used for both C and C++ compiles
CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -Wall -Wno-parentheses -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -Wall -Wno-parentheses -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
-pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
case $OPENJDK_TARGET_CPU_ARCH in
arm )
@ -41676,14 +42030,14 @@ fi
CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
;;
* )
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -fno-omit-frame-pointer"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer"
CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing"
;;
esac
elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
if test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_TARGET_CPU_LEGACY_LIB"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_TARGET_CPU_LEGACY_LIB"
CFLAGS_JDK="$CFLAGS_JDK -erroff=E_BAD_PRAGMA_PACK_VALUE"
fi
@ -41693,14 +42047,14 @@ fi
CFLAGS_JDK="$CFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
CXXFLAGS_JDK="$CXXFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC"
elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
CCXXFLAGS_JDK="$CCXXFLAGS $CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \
-D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB -DWIN32_LEAN_AND_MEAN \
-D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
-DWIN32 -DIAL"
if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_AMD64_ -Damd64"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_AMD64_ -Damd64"
else
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_X86_ -Dx86"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_X86_ -Dx86"
fi
fi
@ -41708,28 +42062,20 @@ fi
# Adjust flags according to debug level.
case $DEBUG_LEVEL in
fastdebug )
CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS"
CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS"
C_O_FLAG_HI="$C_O_FLAG_NORM"
C_O_FLAG_NORM="$C_O_FLAG_NORM"
CXX_O_FLAG_HI="$CXX_O_FLAG_NORM"
CXX_O_FLAG_NORM="$CXX_O_FLAG_NORM"
fastdebug | slowdebug )
CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS $CFLAGS_DEBUG_OPTIONS"
CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS $CXXFLAGS_DEBUG_OPTIONS"
JAVAC_FLAGS="$JAVAC_FLAGS -g"
;;
slowdebug )
CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS"
CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS"
C_O_FLAG_HI="$C_O_FLAG_NONE"
C_O_FLAG_NORM="$C_O_FLAG_NONE"
CXX_O_FLAG_HI="$CXX_O_FLAG_NONE"
CXX_O_FLAG_NORM="$CXX_O_FLAG_NONE"
JAVAC_FLAGS="$JAVAC_FLAGS -g"
release )
;;
* )
as_fn_error $? "Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL" "$LINENO" 5
;;
esac
# Setup LP64
CCXXFLAGS_JDK="$CCXXFLAGS_JDK $ADD_LP64"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK $ADD_LP64"
# Set some common defines. These works for all compilers, but assume
# -D is universally accepted.
@ -41742,49 +42088,49 @@ fi
# Note: -Dmacro is the same as #define macro 1
# -Dmacro= is the same as #define macro
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN="
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN="
else
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_LITTLE_ENDIAN"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN"
fi
else
# Same goes for _BIG_ENDIAN. Do we really need to set *ENDIAN on Solaris if they
# are defined in the system?
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_BIG_ENDIAN="
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN="
else
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_BIG_ENDIAN"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN"
fi
fi
# Setup target OS define. Use OS target name but in upper case.
OPENJDK_TARGET_OS_UPPERCASE=`$ECHO $OPENJDK_TARGET_OS | $TR 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D$OPENJDK_TARGET_OS_UPPERCASE"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D$OPENJDK_TARGET_OS_UPPERCASE"
# Setup target CPU
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DARCH='\"$OPENJDK_TARGET_CPU_LEGACY\"' -D$OPENJDK_TARGET_CPU_LEGACY"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DARCH='\"$OPENJDK_TARGET_CPU_LEGACY\"' -D$OPENJDK_TARGET_CPU_LEGACY"
# Setup debug/release defines
if test "x$DEBUG_LEVEL" = xrelease; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DNDEBUG"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DNDEBUG"
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DTRIMMED"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DTRIMMED"
fi
else
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DDEBUG"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DDEBUG"
fi
# Setup release name
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DRELEASE='\"\$(RELEASE)\"'"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DRELEASE='\"\$(RELEASE)\"'"
# Set some additional per-OS defines.
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT"
elif test "x$OPENJDK_TARGET_OS" = xaix; then
# FIXME: PPC64 should not be here.
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DPPC64"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DPPC64"
elif test "x$OPENJDK_TARGET_OS" = xbsd; then
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_ALLBSD_SOURCE"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE"
fi
# Additional macosx handling
@ -41803,13 +42149,13 @@ fi
# The macro takes the version with no dots, ex: 1070
# Let the flags variables get resolved in make for easier override on make
# command line.
CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MIN)) -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MIN)) -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
LDFLAGS_JDK="$LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)"
fi
fi
# Setup some hard coded includes
CCXXFLAGS_JDK="$CCXXFLAGS_JDK \
COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK \
-I${JDK_OUTPUTDIR}/include \
-I${JDK_OUTPUTDIR}/include/$OPENJDK_TARGET_OS \
-I${JDK_TOPDIR}/src/share/javavm/export \
@ -41818,12 +42164,12 @@ fi
-I${JDK_TOPDIR}/src/$OPENJDK_TARGET_OS_API_DIR/native/common"
# The shared libraries are compiled using the picflag.
CFLAGS_JDKLIB="$CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"
CXXFLAGS_JDKLIB="$CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA "
CFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"
CXXFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA "
# Executable flags
CFLAGS_JDKEXE="$CCXXFLAGS_JDK $CFLAGS_JDK"
CXXFLAGS_JDKEXE="$CCXXFLAGS_JDK $CXXFLAGS_JDK"
CFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK"
CXXFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK"
@ -41832,6 +42178,7 @@ fi
# Setup LDFLAGS et al.
#
# Now this is odd. The JDK native libraries have to link against libjvm.so
# On 32-bit machines there is normally two distinct libjvm.so:s, client and server.
# Which should we link to? Are we lucky enough that the binary api to the libjvm.so library
@ -41847,39 +42194,94 @@ fi
fi
# TODO: make -debug optional "--disable-full-debug-symbols"
LDFLAGS_JDK="$LDFLAGS_JDK -debug"
LDFLAGS_JDKLIB="${LDFLAGS_JDK} -dll -libpath:${JDK_OUTPUTDIR}/lib"
LDFLAGS_JDKLIB_SUFFIX=""
elif test "x$TOOLCHAIN_TYPE" = xgcc; then
# If this is a --hash-style=gnu system, use --hash-style=both, why?
# We have previously set HAS_GNU_HASH if this is the case
if test -n "$HAS_GNU_HASH"; then
LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker --hash-style=both"
fi
if test "x$OPENJDK_TARGET_OS" = xlinux; then
# And since we now know that the linker is gnu, then add -z defs, to forbid
# undefined symbols in object files.
LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -z -Xlinker defs"
case $DEBUG_LEVEL in
release )
# tell linker to optimize libraries.
# Should this be supplied to the OSS linker as well?
LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -O1"
;;
slowdebug )
if test "x$HAS_LINKER_NOW" = "xtrue"; then
# do relocations at load
LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_NOW_FLAG"
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_NOW_FLAG"
fi
if test "x$HAS_LINKER_RELRO" = "xtrue"; then
# mark relocations read only
LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_RELRO_FLAG"
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_RELRO_FLAG"
fi
;;
fastdebug )
if test "x$HAS_LINKER_RELRO" = "xtrue"; then
# mark relocations read only
LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_RELRO_FLAG"
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_RELRO_FLAG"
fi
;;
* )
as_fn_error $? "Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL" "$LINENO" 5
;;
esac
fi
elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
LDFLAGS_JDK="$LDFLAGS_JDK -z defs -xildoff -ztext"
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK -norunpath -xnolib"
fi
if test "x$TOOLCHAIN_TYPE" = xgcc || test "x$TOOLCHAIN_TYPE" = xclang; then
# If undefined behaviour detection is enabled then we need to tell linker.
case $DEBUG_LEVEL in
release | fastdebug )
;;
slowdebug )
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $HAS_CFLAG_DETECT_UNDEFINED_BEHAVIOR" >&5
$as_echo "$as_me: WARNING: $HAS_CFLAG_DETECT_UNDEFINED_BEHAVIOR" >&2;}
if test "x$HAS_CFLAG_DETECT_UNDEFINED_BEHAVIOR" = "xtrue"; then
# enable undefined behaviour checking
LDFLAGS_JDK="$LDFLAGS_JDK `$ECHO -n $CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG | sed -e "s/ *\(^ \+\)/ -Xlinker \1/g"`"
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK `$ECHO -n $CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG | sed -e "s/ *\(^ \+\)/ -Xlinker \1/g"`"
fi
;;
* )
as_fn_error $? "Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL" "$LINENO" 5
;;
esac
fi
# Customize LDFLAGS for executables
LDFLAGS_JDKEXE="${LDFLAGS_JDK}"
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then
LDFLAGS_STACK_SIZE=1048576
else
LDFLAGS_STACK_SIZE=327680
fi
LDFLAGS_JDKEXE="${LDFLAGS_JDK} /STACK:$LDFLAGS_STACK_SIZE"
LDFLAGS_JDKEXE="${LDFLAGS_JDKEXE} /STACK:$LDFLAGS_STACK_SIZE"
elif test "x$OPENJDK_TARGET_OS" = xlinux; then
LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE -Xlinker --allow-shlib-undefined"
fi
# Customize LDFLAGS for libs
LDFLAGS_JDKLIB="${LDFLAGS_JDK}"
if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -dll -libpath:${JDK_OUTPUTDIR}/lib"
LDFLAGS_JDKLIB_SUFFIX=""
else
if test "x$TOOLCHAIN_TYPE" = xgcc; then
# If this is a --hash-style=gnu system, use --hash-style=both, why?
# We have previously set HAS_GNU_HASH if this is the case
if test -n "$HAS_GNU_HASH"; then
LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker --hash-style=both "
fi
if test "x$OPENJDK_TARGET_OS" = xlinux; then
# And since we now know that the linker is gnu, then add -z defs, to forbid
# undefined symbols in object files.
LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -z -Xlinker defs"
if test "x$DEBUG_LEVEL" = "xrelease"; then
# When building release libraries, tell the linker optimize them.
# Should this be supplied to the OSS linker as well?
LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -O1"
fi
fi
fi
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
LDFLAGS_JDK="$LDFLAGS_JDK -z defs -xildoff -ztext"
LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK -norunpath -xnolib"
fi
LDFLAGS_JDKLIB="${LDFLAGS_JDK} $SHARED_LIBRARY_FLAGS \
LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} ${SHARED_LIBRARY_FLAGS} \
-L${JDK_OUTPUTDIR}/lib${OPENJDK_TARGET_CPU_LIBDIR}"
# On some platforms (mac) the linker warns about non existing -L dirs.
@ -41900,11 +42302,6 @@ fi
if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
LDFLAGS_JDKLIB_SUFFIX="$LDFLAGS_JDKLIB_SUFFIX -lc"
fi
LDFLAGS_JDKEXE="${LDFLAGS_JDK}"
if test "x$OPENJDK_TARGET_OS" = xlinux; then
LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE -Xlinker --allow-shlib-undefined"
fi
fi

80
common/autoconf/toolchain.m4
View File

@ -24,11 +24,11 @@
#
########################################################################
# This file is responsible for detecting, verifying and setting up the
# toolchain, i.e. the compiler, linker and related utilities. It will setup
# This file is responsible for detecting, verifying and setting up the
# toolchain, i.e. the compiler, linker and related utilities. It will setup
# proper paths to the binaries, but it will not setup any flags.
#
# The binaries used is determined by the toolchain type, which is the family of
# The binaries used is determined by the toolchain type, which is the family of
# compilers and related tools that are used.
########################################################################
@ -83,7 +83,7 @@ AC_DEFUN([TOOLCHAIN_SETUP_FILENAME_PATTERNS],
AC_SUBST(SHARED_LIBRARY)
AC_SUBST(STATIC_LIBRARY)
AC_SUBST(OBJ_SUFFIX)
AC_SUBST(EXE_SUFFIX)
AC_SUBST(EXE_SUFFIX)
])
# Determine which toolchain type to use, and make sure it is valid for this
@ -117,7 +117,7 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETERMINE_TOOLCHAIN_TYPE],
# First toolchain type in the list is the default
DEFAULT_TOOLCHAIN=${VALID_TOOLCHAINS%% *}
fi
if test "x$with_toolchain_type" = xlist; then
# List all toolchains
AC_MSG_NOTICE([The following toolchains are valid on this platform:])
@ -126,7 +126,7 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETERMINE_TOOLCHAIN_TYPE],
TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
$PRINTF " %-10s %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
done
exit 0
elif test "x$with_toolchain_type" != x; then
# User override; check that it is valid
@ -168,10 +168,10 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETERMINE_TOOLCHAIN_TYPE],
AC_MSG_NOTICE([Using default toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION)])
else
AC_MSG_NOTICE([Using user selected toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION). Default toolchain is $DEFAULT_TOOLCHAIN.])
fi
fi
])
# Before we start detecting the toolchain executables, we might need some
# Before we start detecting the toolchain executables, we might need some
# special setup, e.g. additional paths etc.
AC_DEFUN_ONCE([TOOLCHAIN_PRE_DETECTION],
[
@ -184,7 +184,7 @@ AC_DEFUN_ONCE([TOOLCHAIN_PRE_DETECTION],
ORG_OBJCFLAGS="$OBJCFLAGS"
# On Windows, we need to detect the visual studio installation first.
# This will change the PATH, but we need to keep that new PATH even
# This will change the PATH, but we need to keep that new PATH even
# after toolchain detection is done, since the compiler (on x86) uses
# it for DLL resolution in runtime.
if test "x$OPENJDK_BUILD_OS" = "xwindows" && test "x$TOOLCHAIN_TYPE" = "xmicrosoft"; then
@ -208,7 +208,7 @@ AC_DEFUN_ONCE([TOOLCHAIN_PRE_DETECTION],
PATH="/usr/ccs/bin:$PATH"
fi
# Finally add TOOLCHAIN_PATH at the beginning, to allow --with-tools-dir to
# Finally add TOOLCHAIN_PATH at the beginning, to allow --with-tools-dir to
# override all other locations.
if test "x$TOOLCHAIN_PATH" != x; then
PATH=$TOOLCHAIN_PATH:$PATH
@ -254,7 +254,7 @@ AC_DEFUN([TOOLCHAIN_CHECK_COMPILER_VERSION],
AC_MSG_NOTICE([The result from running with --version was: "$ALT_VERSION_OUTPUT"])
AC_MSG_ERROR([A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir.])
fi
# Remove usage instructions (if present), and
# Remove usage instructions (if present), and
# collapse compiler output into a single line
COMPILER_VERSION_STRING=`$ECHO $COMPILER_VERSION_OUTPUT | \
$SED -e 's/ *@<:@Uu@:>@sage:.*//'`
@ -282,7 +282,7 @@ AC_DEFUN([TOOLCHAIN_CHECK_COMPILER_VERSION],
# There is no specific version flag, but all output starts with a version string.
# First line typically looks something like:
# Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.40219.01 for 80x86
COMPILER_VERSION_OUTPUT=`$COMPILER 2>&1 | $HEAD -n 1 | $TR -d '\r'`
COMPILER_VERSION_OUTPUT=`$COMPILER 2>&1 | $HEAD -n 1 | $TR -d '\r'`
# Check that this is likely to be Microsoft CL.EXE.
$ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Microsoft.*Compiler" > /dev/null
if test $? -ne 0; then
@ -360,7 +360,7 @@ AC_DEFUN([TOOLCHAIN_FIND_COMPILER],
AC_MSG_NOTICE([Will use user supplied compiler $1=[$]$1])
if test "x`basename [$]$1`" = "x[$]$1"; then
# A command without a complete path is provided, search $PATH.
AC_PATH_PROGS(POTENTIAL_$1, [$]$1)
if test "x$POTENTIAL_$1" != x; then
$1=$POTENTIAL_$1
@ -375,12 +375,12 @@ AC_DEFUN([TOOLCHAIN_FIND_COMPILER],
fi
else
# No user supplied value. Locate compiler ourselves.
# If we are cross compiling, assume cross compilation tools follows the
# cross compilation standard where they are prefixed with the autoconf
# standard name for the target. For example the binary
# standard name for the target. For example the binary
# i686-sun-solaris2.10-gcc will cross compile for i686-sun-solaris2.10.
# If we are not cross compiling, then the default compiler name will be
# If we are not cross compiling, then the default compiler name will be
# used.
$1=
@ -450,9 +450,9 @@ AC_DEFUN([TOOLCHAIN_FIND_COMPILER],
TOOLCHAIN_CHECK_COMPILER_VERSION([$1], [$COMPILER_NAME])
])
# Detect the core components of the toolchain, i.e. the compilers (CC and CXX),
# preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the
# archiver (AR). Verify that the compilers are correct according to the
# Detect the core components of the toolchain, i.e. the compilers (CC and CXX),
# preprocessor (CPP and CXXCPP), the linker (LD), the assembler (AS) and the
# archiver (AR). Verify that the compilers are correct according to the
# toolchain type.
AC_DEFUN_ONCE([TOOLCHAIN_DETECT_TOOLCHAIN_CORE],
[
@ -529,7 +529,7 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETECT_TOOLCHAIN_CORE],
])
# Setup additional tools that is considered a part of the toolchain, but not the
# core part. Many of these are highly platform-specific and do not exist,
# core part. Many of these are highly platform-specific and do not exist,
# and/or are not needed on all platforms.
AC_DEFUN_ONCE([TOOLCHAIN_DETECT_TOOLCHAIN_EXTRA],
[
@ -551,7 +551,7 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETECT_TOOLCHAIN_EXTRA],
AC_CHECK_PROG([DUMPBIN], [dumpbin], [dumpbin],,,)
BASIC_FIXUP_EXECUTABLE(DUMPBIN)
fi
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
BASIC_PATH_PROGS(STRIP, strip)
BASIC_FIXUP_EXECUTABLE(STRIP)
@ -559,7 +559,7 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETECT_TOOLCHAIN_EXTRA],
BASIC_FIXUP_EXECUTABLE(NM)
BASIC_PATH_PROGS(GNM, gnm)
BASIC_FIXUP_EXECUTABLE(GNM)
BASIC_PATH_PROGS(MCS, mcs)
BASIC_FIXUP_EXECUTABLE(MCS)
elif test "x$OPENJDK_TARGET_OS" != xwindows; then
@ -592,17 +592,17 @@ AC_DEFUN_ONCE([TOOLCHAIN_DETECT_TOOLCHAIN_EXTRA],
# Setup the build tools (i.e, the compiler and linker used to build programs
# that should be run on the build platform, not the target platform, as a build
# helper). Since the non-cross-compile case uses the normal, target compilers
# helper). Since the non-cross-compile case uses the normal, target compilers
# for this, we can only do this after these have been setup.
AC_DEFUN_ONCE([TOOLCHAIN_SETUP_BUILD_COMPILERS],
[
[
if test "x$COMPILE_TYPE" = "xcross"; then
# Now we need to find a C/C++ compiler that can build executables for the
# build platform. We can't use the AC_PROG_CC macro, since it can only be
# used once. Also, we need to do this without adding a tools dir to the
# path, otherwise we might pick up cross-compilers which don't use standard
# naming.
# FIXME: we should list the discovered compilers as an exclude pattern!
# If we do that, we can do this detection before POST_DETECTION, and still
# find the build compilers in the tools dir, if needed.
@ -690,15 +690,39 @@ AC_DEFUN_ONCE([TOOLCHAIN_MISC_CHECKS],
# If this is a --hash-style=gnu system, use --hash-style=both, why?
HAS_GNU_HASH=`$CC -dumpspecs 2>/dev/null | $GREP 'hash-style=gnu'`
# This is later checked when setting flags.
# "-Og" suppported for GCC 4.8 and later
CFLAG_OPTIMIZE_DEBUG_FLAG="-Og"
FLAGS_COMPILER_CHECK_ARGUMENTS([$CFLAG_OPTIMIZE_DEBUG_FLAG],
[HAS_CFLAG_OPTIMIZE_DEBUG=true],
[HAS_CFLAG_OPTIMIZE_DEBUG=false])
# "-fsanitize=undefined" supported for GCC 4.9 and later
CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG="-fsanitize=undefined -fsanitize-recover"
FLAGS_COMPILER_CHECK_ARGUMENTS([$CFLAG_DETECT_UNDEFINED_BEHAVIOR_FLAG],
[HAS_CFLAG_DETECT_UNDEFINED_BEHAVIOR=true],
[HAS_CFLAG_DETECT_UNDEFINED_BEHAVIOR=false])
# "-z relro" supported in GNU binutils 2.17 and later
LINKER_RELRO_FLAG="-Xlinker -z -Xlinker relro"
FLAGS_LINKER_CHECK_ARGUMENTS([$LINKER_RELRO_FLAG],
[HAS_LINKER_RELRO=true],
[HAS_LINKER_RELRO=false])
# "-z now" supported in GNU binutils 2.11 and later
LINKER_NOW_FLAG="-Xlinker -z -Xlinker now"
FLAGS_LINKER_CHECK_ARGUMENTS([$LINKER_NOW_FLAG],
[HAS_LINKER_NOW=true],
[HAS_LINKER_NOW=false])
fi
# Check for broken SuSE 'ld' for which 'Only anonymous version tag is allowed
# Check for broken SuSE 'ld' for which 'Only anonymous version tag is allowed
# in executable.'
USING_BROKEN_SUSE_LD=no
if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$TOOLCHAIN_TYPE" = xgcc; then
AC_MSG_CHECKING([for broken SuSE 'ld' which only understands anonymous version tags in executables])
echo "SUNWprivate_1.1 { local: *; };" > version-script.map
echo "int main() { }" > main.c
$ECHO "SUNWprivate_1.1 { local: *; };" > version-script.map
$ECHO "int main() { }" > main.c
if $CXX -Xlinker -version-script=version-script.map main.c 2>&AS_MESSAGE_LOG_FD >&AS_MESSAGE_LOG_FD; then
AC_MSG_RESULT(no)
USING_BROKEN_SUSE_LD=no

1
corba/.hgtags
View File

@ -261,3 +261,4 @@ e54022d0dd92106fff7f7fe670010cd7e6517ee3 jdk9-b15
422ef9d29d84f571453f015c4cb8713c3af70ee4 jdk9-b16
4c75c2ca7cf3e0618315879acf17f42c8fcd0c09 jdk9-b17
77565aaaa2bb814e94817e92d680168052a25395 jdk9-b18
eecc1b6adc7e193d00a0641eb0963add5a4c06e8 jdk9-b19

1
hotspot/.hgtags
View File

@ -421,3 +421,4 @@ bd333491bb6c012d7b606939406d0fa9a5ac7ffd jdk9-b14
b14e7c0b7d3ec04127f565cda1d84122e205680c jdk9-b16
14b656df31c2cb09c505921061e79977823de71a jdk9-b17
871fd128548480095e0dc3fc34c422666baeec75 jdk9-b18
d4cffb3ae6213c66c7522ebffe0349360a45f0ef jdk9-b19

31
hotspot/make/bsd/makefiles/fastdebug.make
View File

@ -24,37 +24,30 @@
# Sets make macros for making debug version of VM
# Compiler specific DEBUG_CFLAGS are passed in from gcc.make, sparcWorks.make
# They may also specify FASTDEBUG_CFLAGS, but it defaults to DEBUG_CFLAGS.
FASTDEBUG_CFLAGS$(FASTDEBUG_CFLAGS) = $(DEBUG_CFLAGS)
# Compiler specific OPT_CFLAGS are passed in from gcc.make, sparcWorks.make
OPT_CFLAGS/DEFAULT= $(OPT_CFLAGS)
OPT_CFLAGS/BYFILE = $(OPT_CFLAGS/$@)$(OPT_CFLAGS/DEFAULT$(OPT_CFLAGS/$@))
# (OPT_CFLAGS/SLOWER is also available, to alter compilation of buggy files)
ifeq ($(BUILDARCH), ia64)
# Bug in GCC, causes hang. -O1 will override the -O3 specified earlier
OPT_CFLAGS/callGenerator.o += -O1
OPT_CFLAGS/ciTypeFlow.o += -O1
OPT_CFLAGS/compile.o += -O1
OPT_CFLAGS/concurrentMarkSweepGeneration.o += -O1
OPT_CFLAGS/doCall.o += -O1
OPT_CFLAGS/generateOopMap.o += -O1
OPT_CFLAGS/generateOptoStub.o += -O1
OPT_CFLAGS/graphKit.o += -O1
OPT_CFLAGS/instanceKlass.o += -O1
OPT_CFLAGS/interpreterRT_ia64.o += -O1
OPT_CFLAGS/output.o += -O1
OPT_CFLAGS/parse1.o += -O1
OPT_CFLAGS/runtime.o += -O1
OPT_CFLAGS/synchronizer.o += -O1
endif
# If you set HOTSPARC_GENERIC=yes, you disable all OPT_CFLAGS settings
CFLAGS$(HOTSPARC_GENERIC) += $(OPT_CFLAGS/BYFILE)
# Set the environment variable HOTSPARC_GENERIC to "true"
# to inhibit the effect of the previous line on CFLAGS.
# The following lines are copied from debug.make, except that we
# consult FASTDEBUG_CFLAGS instead of DEBUG_CFLAGS.
# Compiler specific DEBUG_CFLAGS are passed in from gcc.make, sparcWorks.make
DEBUG_CFLAGS/DEFAULT= $(FASTDEBUG_CFLAGS)
DEBUG_CFLAGS/BYFILE = $(DEBUG_CFLAGS/$@)$(DEBUG_CFLAGS/DEFAULT$(DEBUG_CFLAGS/$@))
CFLAGS += $(DEBUG_CFLAGS/BYFILE)
# Linker mapfile
MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-debug
ifeq ($(OS_VENDOR), Darwin)

93
hotspot/make/bsd/makefiles/gcc.make
View File

@ -19,7 +19,7 @@
# 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.
#
#
#
OS_VENDOR = $(shell uname -s)
@ -80,7 +80,7 @@ ifeq ($(SPEC),)
HOSTCC = $(CC)
endif
AS = $(CC) -c
AS = $(CC) -c
endif
ifeq ($(OS_VENDOR), Darwin)
@ -100,7 +100,7 @@ else
endif
ifeq ($(USE_CLANG), true)
# clang has precompiled headers support by default, but the user can switch
# Clang has precompiled headers support by default, but the user can switch
# it off by using 'USE_PRECOMPILED_HEADER=0'.
ifdef LP64
ifeq ($(USE_PRECOMPILED_HEADER),)
@ -112,29 +112,29 @@ ifeq ($(USE_CLANG), true)
# Clang produces an error if the PCH file was compiled with other options than the actual compilation unit.
USE_PRECOMPILED_HEADER=0
endif
ifeq ($(USE_PRECOMPILED_HEADER),1)
ifndef LP64
$(error " Precompiled Headers only supported on 64-bit platforms!")
endif
PRECOMPILED_HEADER_DIR=.
PRECOMPILED_HEADER_SRC=$(GAMMADIR)/src/share/vm/precompiled/precompiled.hpp
PRECOMPILED_HEADER=$(PRECOMPILED_HEADER_DIR)/precompiled.hpp.pch
PCH_FLAG = -include precompiled.hpp
PCH_FLAG/DEFAULT = $(PCH_FLAG)
PCH_FLAG/NO_PCH = -DNO_PCH
PCH_FLAG/BY_FILE = $(PCH_FLAG/$@)$(PCH_FLAG/DEFAULT$(PCH_FLAG/$@))
VM_PCH_FLAG/LIBJVM = $(PCH_FLAG/BY_FILE)
VM_PCH_FLAG/AOUT =
VM_PCH_FLAG = $(VM_PCH_FLAG/$(LINK_INTO))
# We only use precompiled headers for the JVM build
CFLAGS += $(VM_PCH_FLAG)
# The following files are compiled at various optimization
# levels due to optimization issues encountered at the
# 'OPT_CFLAGS_DEFAULT' level. The Clang compiler issues a compile
@ -149,7 +149,7 @@ ifeq ($(USE_CLANG), true)
PCH_FLAG/sharedRuntimeTrig.o = $(PCH_FLAG/NO_PCH)
PCH_FLAG/sharedRuntimeTrans.o = $(PCH_FLAG/NO_PCH)
PCH_FLAG/unsafe.o = $(PCH_FLAG/NO_PCH)
endif
else # ($(USE_CLANG), true)
# check for precompiled headers support
@ -272,21 +272,24 @@ endif
CFLAGS_WARN/DEFAULT = $(WARNINGS_ARE_ERRORS) $(WARNING_FLAGS)
# Special cases
CFLAGS_WARN/BYFILE = $(CFLAGS_WARN/$@)$(CFLAGS_WARN/DEFAULT$(CFLAGS_WARN/$@))
CFLAGS_WARN/BYFILE = $(CFLAGS_WARN/$@)$(CFLAGS_WARN/DEFAULT$(CFLAGS_WARN/$@))
# XXXDARWIN: for _dyld_bind_fully_image_containing_address
ifeq ($(OS_VENDOR), Darwin)
CFLAGS_WARN/os_bsd.o = $(CFLAGS_WARN/DEFAULT) -Wno-deprecated-declarations
endif
# optimization control flags (Used by fastdebug and release variants)
OPT_CFLAGS/NOOPT=-O0
ifeq "$(shell expr \( $(CC_VER_MAJOR) \> 4 \) \| \( \( $(CC_VER_MAJOR) = 4 \) \& \( $(CC_VER_MINOR) \>= 8 \) \))" "1"
# Allow basic optimizations which don't distrupt debugging. (Principally dead code elimination)
OPT_CFLAGS/DEBUG=-Og
else
# Allow no optimizations.
OPT_CFLAGS/DEBUG=-O0
endif
OPT_CFLAGS/SIZE=-Os
OPT_CFLAGS/SPEED=-O3
# Hotspot uses very unstrict aliasing turn this optimization off
# This option is added to CFLAGS rather than OPT_CFLAGS
# so that OPT_CFLAGS overrides get this option too.
CFLAGS += -fno-strict-aliasing
# The flags to use for an Optimized g++ build
ifeq ($(OS_VENDOR), Darwin)
# use -Os by default, unless -O3 can be proved to be worth the cost, as per policy
# <https://wiki.openjdk.java.net/display/MacOSXPort/Compiler+Errata>
@ -295,6 +298,11 @@ else
OPT_CFLAGS_DEFAULT ?= SPEED
endif
# Hotspot uses very unstrict aliasing turn this optimization off
# This option is added to CFLAGS rather than OPT_CFLAGS
# so that OPT_CFLAGS overrides get this option too.
CFLAGS += -fno-strict-aliasing
ifdef OPT_CFLAGS
ifneq ("$(origin OPT_CFLAGS)", "command line")
$(error " Use OPT_EXTRAS instead of OPT_CFLAGS to add extra flags to OPT_CFLAGS.")
@ -309,8 +317,6 @@ ifeq ($(BUILDARCH), ia64)
OPT_CFLAGS += -fno-expensive-optimizations
endif
OPT_CFLAGS/NOOPT=-O0
# Work around some compiler bugs.
ifeq ($(USE_CLANG), true)
ifeq ($(shell expr $(CC_VER_MAJOR) = 4 \& $(CC_VER_MINOR) = 2), 1)
@ -338,7 +344,7 @@ CFLAGS += -DDONT_USE_PRECOMPILED_HEADER
endif
ifeq ($(OS_VENDOR), Darwin)
# Setting these parameters makes it an error to link to macosx APIs that are
# Setting these parameters makes it an error to link to macosx APIs that are
# newer than the given OS version and makes the linked binaries compatible even
# if built on a newer version of the OS.
# The expected format is X.Y.Z
@ -371,10 +377,22 @@ endif
ifeq ($(USE_CLANG),)
# statically link libgcc and/or libgcc_s, libgcc does not exist before gcc-3.x.
ifneq ("${CC_VER_MAJOR}", "2")
ifneq ($(CC_VER_MAJOR), 2)
STATIC_LIBGCC += -static-libgcc
endif
ifneq ($(OS_VENDOR), Darwin)
ifneq (, findstring(debug,$(BUILD_FLAVOR)))
# for relocations read-only
LFLAGS += -Xlinker -z -Xlinker relro
ifeq ($(BUILD_FLAVOR), debug)
# disable incremental relocations linking
LFLAGS += -Xlinker -z -Xlinker now
endif
endif
endif
ifeq ($(BUILDARCH), ia64)
LFLAGS += -Wl,-relax
endif
@ -425,6 +443,14 @@ ifeq ($(USE_CLANG), true)
CFLAGS += -flimit-debug-info
endif
ifeq "$(shell expr \( $(CC_VER_MAJOR) \> 4 \) \| \( \( $(CC_VER_MAJOR) = 4 \) \& \( $(CC_VER_MINOR) \>= 8 \) \))" "1"
# Allow basic optimizations which don't distrupt debugging. (Principally dead code elimination)
DEBUG_CFLAGS=-Og
else
# Allow no optimizations.
DEBUG_CFLAGS=-O0
endif
# DEBUG_BINARIES uses full -g debug information for all configs
ifeq ($(DEBUG_BINARIES), true)
CFLAGS += -g
@ -441,9 +467,14 @@ else
DEBUG_CFLAGS/ppc = -g
DEBUG_CFLAGS += $(DEBUG_CFLAGS/$(BUILDARCH))
ifeq ($(DEBUG_CFLAGS/$(BUILDARCH)),)
DEBUG_CFLAGS += -gstabs
ifeq ($(USE_CLANG), true)
# Clang doesn't understand -gstabs
DEBUG_CFLAGS += -g
else
DEBUG_CFLAGS += -gstabs
endif
endif
ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1)
FASTDEBUG_CFLAGS/ia64 = -g
FASTDEBUG_CFLAGS/amd64 = -g
@ -458,7 +489,7 @@ else
FASTDEBUG_CFLAGS += -gstabs
endif
endif
OPT_CFLAGS/ia64 = -g
OPT_CFLAGS/amd64 = -g
OPT_CFLAGS/arm = -g
@ -475,6 +506,18 @@ else
endif
endif
ifeq ($(USE_CLANG),)
# Enable bounds checking.
# _FORTIFY_SOURCE appears in GCC 4.0+
ifeq "$(shell expr \( $(CC_VER_MAJOR) \> 3 \) )" "1"
# compile time size bounds checks
FASTDEBUG_CFLAGS += -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1
# and runtime size bounds checks and paranoid stack smashing checks.
DEBUG_CFLAGS += -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fstack-protector-all --param ssp-buffer-size=1
endif
endif
# If we are building HEADLESS, pass on to VM
# so it can set the java.awt.headless property
ifdef HEADLESS

11
hotspot/make/linux/makefiles/fastdebug.make
View File

@ -24,6 +24,11 @@
# Sets make macros for making debug version of VM
# Compiler specific DEBUG_CFLAGS are passed in from gcc.make, sparcWorks.make
# They may also specify FASTDEBUG_CFLAGS, but it defaults to DEBUG_CFLAGS.
FASTDEBUG_CFLAGS$(FASTDEBUG_CFLAGS) = $(DEBUG_CFLAGS)
# Compiler specific OPT_CFLAGS are passed in from gcc.make, sparcWorks.make
OPT_CFLAGS/DEFAULT= $(OPT_CFLAGS)
OPT_CFLAGS/BYFILE = $(OPT_CFLAGS/$@)$(OPT_CFLAGS/DEFAULT$(OPT_CFLAGS/$@))
@ -54,6 +59,12 @@ CFLAGS$(HOTSPARC_GENERIC) += $(OPT_CFLAGS/BYFILE)
# Set the environment variable HOTSPARC_GENERIC to "true"
# to inhibit the effect of the previous line on CFLAGS.
# The following lines are copied from debug.make, except that we
# consult FASTDEBUG_CFLAGS instead of DEBUG_CFLAGS.
# Compiler specific DEBUG_CFLAGS are passed in from gcc.make, sparcWorks.make
DEBUG_CFLAGS/DEFAULT= $(FASTDEBUG_CFLAGS)
DEBUG_CFLAGS/BYFILE = $(DEBUG_CFLAGS/$@)$(DEBUG_CFLAGS/DEFAULT$(DEBUG_CFLAGS/$@))
CFLAGS += $(DEBUG_CFLAGS/BYFILE)
# Linker mapfile
MAPFILE = $(GAMMADIR)/make/linux/makefiles/mapfile-vers-debug

73
hotspot/make/linux/makefiles/gcc.make
View File

@ -19,7 +19,7 @@
# 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.
#
#
#
#------------------------------------------------------------------------
@ -62,7 +62,6 @@ else
CC_VER_MINOR := $(shell $(CC) -dumpversion | sed 's/egcs-//' | cut -d'.' -f2)
endif
ifeq ($(USE_CLANG), true)
# Clang has precompiled headers support by default, but the user can switch
# it off by using 'USE_PRECOMPILED_HEADER=0'.
@ -104,7 +103,7 @@ ifeq ($(USE_CLANG), true)
# But Clang doesn't support a precompiled header which was compiled with -O3
# to be used in a compilation unit which uses '-O0'. We could also prepare an
# extra '-O0' PCH file for the opt build and use it here, but it's probably
# not worth the effoert as long as only two files need this special handling.
# not worth the effort as long as only two files need this special handling.
PCH_FLAG/loopTransform.o = $(PCH_FLAG/NO_PCH)
PCH_FLAG/sharedRuntimeTrig.o = $(PCH_FLAG/NO_PCH)
PCH_FLAG/sharedRuntimeTrans.o = $(PCH_FLAG/NO_PCH)
@ -226,19 +225,28 @@ ifeq ($(USE_CLANG),)
endif
CFLAGS_WARN/DEFAULT = $(WARNINGS_ARE_ERRORS) $(WARNING_FLAGS)
# Special cases
CFLAGS_WARN/BYFILE = $(CFLAGS_WARN/$@)$(CFLAGS_WARN/DEFAULT$(CFLAGS_WARN/$@))
# The flags to use for an Optimized g++ build
# Special cases
CFLAGS_WARN/BYFILE = $(CFLAGS_WARN/$@)$(CFLAGS_WARN/DEFAULT$(CFLAGS_WARN/$@))
# optimization control flags (Used by fastdebug and release variants)
OPT_CFLAGS/NOOPT=-O0
ifeq "$(shell expr \( $(CC_VER_MAJOR) \> 4 \) \| \( \( $(CC_VER_MAJOR) = 4 \) \& \( $(CC_VER_MINOR) \>= 8 \) \))" "1"
# Allow basic optimizations which don't distrupt debugging. (Principally dead code elimination)
OPT_CFLAGS/DEBUG=-Og
else
# Allow no optimizations.
OPT_CFLAGS/DEBUG=-O0
endif
OPT_CFLAGS/SIZE=-Os
OPT_CFLAGS/SPEED=-O3
OPT_CFLAGS_DEFAULT ?= SPEED
# Hotspot uses very unstrict aliasing turn this optimization off
# This option is added to CFLAGS rather than OPT_CFLAGS
# so that OPT_CFLAGS overrides get this option too.
CFLAGS += -fno-strict-aliasing
OPT_CFLAGS_DEFAULT ?= SPEED
CFLAGS += -fno-strict-aliasing
ifdef OPT_CFLAGS
ifneq ("$(origin OPT_CFLAGS)", "command line")
@ -248,14 +256,12 @@ endif
OPT_CFLAGS = $(OPT_CFLAGS/$(OPT_CFLAGS_DEFAULT)) $(OPT_EXTRAS)
# The gcc compiler segv's on ia64 when compiling bytecodeInterpreter.cpp
# The gcc compiler segv's on ia64 when compiling bytecodeInterpreter.cpp
# if we use expensive-optimizations
ifeq ($(BUILDARCH), ia64)
OPT_CFLAGS += -fno-expensive-optimizations
endif
OPT_CFLAGS/NOOPT=-O0
# Work around some compiler bugs.
ifeq ($(USE_CLANG), true)
ifeq ($(shell expr $(CC_VER_MAJOR) = 4 \& $(CC_VER_MINOR) = 2), 1)
@ -271,7 +277,7 @@ endif
# Flags for generating make dependency flags.
DEPFLAGS = -MMD -MP -MF $(DEP_DIR)/$(@:%=%.d)
ifeq ($(USE_CLANG),)
ifneq ("${CC_VER_MAJOR}", "2")
ifneq ($(CC_VER_MAJOR), 2)
DEPFLAGS += -fpch-deps
endif
endif
@ -282,21 +288,26 @@ endif
# statically link libstdc++.so, work with gcc but ignored by g++
STATIC_STDCXX = -Wl,-Bstatic -lstdc++ -Wl,-Bdynamic
# Enable linker optimization
LFLAGS += -Xlinker -O1
ifeq ($(USE_CLANG),)
# statically link libgcc and/or libgcc_s, libgcc does not exist before gcc-3.x.
ifneq ("${CC_VER_MAJOR}", "2")
STATIC_LIBGCC += -static-libgcc
STATIC_LIBGCC += -static-libgcc
ifneq (, findstring(debug,$(BUILD_FLAVOR)))
# for relocations read-only
LFLAGS += -Xlinker -z -Xlinker relro
ifeq ($(BUILD_FLAVOR), debug)
# disable incremental relocations linking
LFLAGS += -Xlinker -z -Xlinker now
endif
endif
ifeq ($(BUILDARCH), ia64)
LFLAGS += -Wl,-relax
endif
endif
# Enable linker optimization
LFLAGS += -Xlinker -O1
ifeq ($(USE_CLANG),)
# If this is a --hash-style=gnu system, use --hash-style=both
# The gnu .hash section won't work on some Linux systems like SuSE 10.
_HAS_HASH_STYLE_GNU:=$(shell $(CC) -dumpspecs | grep -- '--hash-style=gnu')
@ -333,6 +344,14 @@ ifeq ($(USE_CLANG), true)
CFLAGS += -flimit-debug-info
endif
ifeq "$(shell expr \( $(CC_VER_MAJOR) \> 4 \) \| \( \( $(CC_VER_MAJOR) = 4 \) \& \( $(CC_VER_MINOR) \>= 8 \) \))" "1"
# Allow basic optimizations which don't distrupt debugging. (Principally dead code elimination)
DEBUG_CFLAGS=-Og
else
# Allow no optimizations.
DEBUG_CFLAGS=-O0
endif
# DEBUG_BINARIES uses full -g debug information for all configs
ifeq ($(DEBUG_BINARIES), true)
CFLAGS += -g
@ -355,6 +374,18 @@ else
endif
endif
ifeq ($(USE_CLANG),)
# Enable bounds checking.
# _FORTIFY_SOURCE appears in GCC 4.0+
ifeq "$(shell expr \( $(CC_VER_MAJOR) \> 3 \) )" "1"
# compile time size bounds checks
FASTDEBUG_CFLAGS += -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1
# and runtime size bounds checks and paranoid stack smashing checks.
DEBUG_CFLAGS += -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fstack-protector-all --param ssp-buffer-size=1
endif
endif
# If we are building HEADLESS, pass on to VM
# so it can set the java.awt.headless property
ifdef HEADLESS

147
hotspot/make/solaris/makefiles/gcc.make
View File

@ -19,7 +19,7 @@
# 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.
#
#
#
#------------------------------------------------------------------------
@ -40,7 +40,7 @@ Compiler = gcc
CC_VER_MAJOR := $(shell $(CC) -dumpversion | sed 's/egcs-//' | cut -d'.' -f1)
CC_VER_MINOR := $(shell $(CC) -dumpversion | sed 's/egcs-//' | cut -d'.' -f2)
# Check for the versions of C++ and C compilers ($CXX and $CC) used.
# Check for the versions of C++ and C compilers ($CXX and $CC) used.
# Get the last thing on the line that looks like x.x+ (x is a digit).
COMPILER_REV := \
@ -98,7 +98,7 @@ ASFLAGS += $(ARCHFLAG)
ifeq ($(BUILDARCH), amd64)
ASFLAGS += -march=k8 -march=amd64
LFLAGS += -march=k8
LFLAGS += -march=k8
endif
@ -115,21 +115,44 @@ else
endif
# Compiler warnings are treated as errors
WARNINGS_ARE_ERRORS = -Werror
# Compiler warnings are treated as errors
WARNINGS_ARE_ERRORS = -Werror
# Enable these warnings. See 'info gcc' about details on these options
WARNING_FLAGS = -Wpointer-arith -Wconversion -Wsign-compare -Wundef -Wformat=2
CFLAGS_WARN/DEFAULT = $(WARNINGS_ARE_ERRORS) $(WARNING_FLAGS)
# Special cases
CFLAGS_WARN/BYFILE = $(CFLAGS_WARN/$@)$(CFLAGS_WARN/DEFAULT$(CFLAGS_WARN/$@))
# The flags to use for an Optimized g++ build
OPT_CFLAGS += -O3
# Special cases
CFLAGS_WARN/BYFILE = $(CFLAGS_WARN/$@)$(CFLAGS_WARN/DEFAULT$(CFLAGS_WARN/$@))
# optimization control flags (Used by fastdebug and release variants)
OPT_CFLAGS/NOOPT=-O0
ifeq "$(shell expr \( $(CC_VER_MAJOR) \> 4 \) \| \( \( $(CC_VER_MAJOR) = 4 \) \& \( $(CC_VER_MINOR) \>= 8 \) \))" "1"
# Allow basic optimizations which don't distrupt debugging. (Principally dead code elimination)
OPT_CFLAGS/DEBUG=-Og
+else
# Allow no optimizations.
OPT_CFLAGS/DEBUG=-O0
endif
OPT_CFLAGS/SIZE=-Os
OPT_CFLAGS/SPEED=-O3
OPT_CFLAGS_DEFAULT ?= SPEED
# Hotspot uses very unstrict aliasing turn this optimization off
OPT_CFLAGS += -fno-strict-aliasing
# This option is added to CFLAGS rather than OPT_CFLAGS
# so that OPT_CFLAGS overrides get this option too.
CFLAGS += -fno-strict-aliasing
# The gcc compiler segv's on ia64 when compiling bytecodeInterpreter.cpp
ifdef OPT_CFLAGS
ifneq ("$(origin OPT_CFLAGS)", "command line")
$(error " Use OPT_EXTRAS instead of OPT_CFLAGS to add extra flags to OPT_CFLAGS.")
endif
endif
OPT_CFLAGS = $(OPT_CFLAGS/$(OPT_CFLAGS_DEFAULT)) $(OPT_EXTRAS)
# The gcc compiler segv's on ia64 when compiling bytecodeInterpreter.cpp
# if we use expensive-optimizations
# Note: all ia64 setting reflect the ones for linux
# No actial testing was performed: there is no Solaris on ia64 presently
@ -137,10 +160,20 @@ ifeq ($(BUILDARCH), ia64)
OPT_CFLAGS/bytecodeInterpreter.o += -fno-expensive-optimizations
endif
OPT_CFLAGS/NOOPT=-O0
# Work around some compiler bugs.
ifeq ($(USE_CLANG), true)
ifeq ($(shell expr $(CC_VER_MAJOR) = 4 \& $(CC_VER_MINOR) = 2), 1)
OPT_CFLAGS/loopTransform.o += $(OPT_CFLAGS/NOOPT)
endif
else
# 6835796. Problem in GCC 4.3.0 with mulnode.o optimized compilation.
ifeq ($(shell expr $(CC_VER_MAJOR) = 4 \& $(CC_VER_MINOR) = 3), 1)
OPT_CFLAGS/mulnode.o += $(OPT_CFLAGS/NOOPT)
endif
endif
# Flags for generating make dependency flags.
ifneq ("${CC_VER_MAJOR}", "2")
ifneq ($(CC_VER_MAJOR), 2)
DEPFLAGS = -fpch-deps -MMD -MP -MF $(DEP_DIR)/$(@:%=%.d)
endif
@ -155,26 +188,37 @@ endif
# statically link libstdc++.so, work with gcc but ignored by g++
STATIC_STDCXX = -Wl,-Bstatic -lstdc++ -Wl,-Bdynamic
# statically link libgcc and/or libgcc_s, libgcc does not exist before gcc-3.x.
ifneq ("${CC_VER_MAJOR}", "2")
STATIC_LIBGCC += -static-libgcc
endif
ifeq ($(BUILDARCH), ia64)
# Note: all ia64 setting reflect the ones for linux
# No actial testing was performed: there is no Solaris on ia64 presently
LFLAGS += -Wl,-relax
endif
ifdef USE_GNULD
# Enable linker optimization
LFLAGS += -Xlinker -O1
# statically link libgcc and/or libgcc_s, libgcc does not exist before gcc-3.x.
ifneq ($(CC_VER_MAJOR), 2)
STATIC_LIBGCC += -static-libgcc
endif
# Use $(MAPFLAG:FILENAME=real_file_name) to specify a map file.
MAPFLAG = -Xlinker --version-script=FILENAME
else
MAPFLAG = -Xlinker -M -Xlinker FILENAME
endif
# Enable linker optimization
LFLAGS += -Xlinker -O1
ifneq (, findstring(debug,$(BUILD_FLAVOR)))
# for relocations read-only
LFLAGS += -Xlinker -z -Xlinker relro
ifeq ($(BUILD_FLAVOR), debug)
# disable incremental relocations linking
LFLAGS += -Xlinker -z -Xlinker now
endif
endif
ifeq ($(BUILDARCH), ia64)
# Note: all ia64 setting reflect the ones for linux
# No actual testing was performed: there is no Solaris on ia64 presently
LFLAGS += -Wl,-relax
endif
# Use $(MAPFLAG:FILENAME=real_file_name) to specify a map file.
MAPFLAG = -Xlinker --version-script=FILENAME
else
MAPFLAG = -Xlinker -M -Xlinker FILENAME
endif
# Use $(SONAMEFLAG:SONAME=soname) to specify the intrinsic name of a shared obj
SONAMEFLAG = -Xlinker -soname=SONAME
@ -185,15 +229,34 @@ SHARED_FLAG = -shared
#------------------------------------------------------------------------
# Debug flags
# Use the stabs format for debugging information (this is the default
# on gcc-2.91). It's good enough, has all the information about line
# numbers and local variables, and libjvm.so is only about 16M.
# Change this back to "-g" if you want the most expressive format.
# (warning: that could easily inflate libjvm.so to 150M!)
# Note: The Itanium gcc compiler crashes when using -gstabs.
DEBUG_CFLAGS/ia64 = -g
DEBUG_CFLAGS/amd64 = -g
DEBUG_CFLAGS += $(DEBUG_CFLAGS/$(BUILDARCH))
ifeq ($(DEBUG_CFLAGS/$(BUILDARCH)),)
DEBUG_CFLAGS += -gstabs
endif
ifeq "$(shell expr \( $(CC_VER_MAJOR) \> 4 \) \| \( \( $(CC_VER_MAJOR) = 4 \) \& \( $(CC_VER_MINOR) \>= 8 \) \))" "1"
# Allow basic optimizations which don't distrupt debugging. (Principally dead code elimination)
DEBUG_CFLAGS=-Og
else
# Allow no optimizations.
DEBUG_CFLAGS=-O0
endif
# Use the stabs format for debugging information (this is the default
# on gcc-2.91). It's good enough, has all the information about line
# numbers and local variables, and libjvm.so is only about 16M.
# Change this back to "-g" if you want the most expressive format.
# (warning: that could easily inflate libjvm.so to 150M!)
# Note: The Itanium gcc compiler crashes when using -gstabs.
DEBUG_CFLAGS/ia64 = -g
DEBUG_CFLAGS/amd64 = -g
DEBUG_CFLAGS += $(DEBUG_CFLAGS/$(BUILDARCH))
ifeq ($(DEBUG_CFLAGS/$(BUILDARCH)),)
DEBUG_CFLAGS += -gstabs
endif
# Enable bounds checking.
# _FORTIFY_SOURCE appears in GCC 4.0+
ifeq "$(shell expr \( $(CC_VER_MAJOR) \> 3 \) )" "1"
# compile time size bounds checks
FASTDEBUG_CFLAGS += -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1
# and runtime size bounds checks and paranoid stack smashing checks.
DEBUG_CFLAGS += -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fstack-protector-all --param ssp-buffer-size=1
endif

188
hotspot/src/cpu/ppc/vm/ppc.ad
View File

@ -1285,9 +1285,9 @@ bool MachConstantBaseNode::requires_postalloc_expand() const { return true; }
void MachConstantBaseNode::postalloc_expand(GrowableArray <Node *> *nodes, PhaseRegAlloc *ra_) {
Compile *C = ra_->C;
iRegPdstOper *op_dst = new (C) iRegPdstOper();
MachNode *m1 = new (C) loadToc_hiNode();
MachNode *m2 = new (C) loadToc_loNode();
iRegPdstOper *op_dst = new iRegPdstOper();
MachNode *m1 = new loadToc_hiNode();
MachNode *m2 = new loadToc_loNode();
m1->add_req(NULL);
m2->add_req(NULL, m1);
@ -2232,9 +2232,9 @@ const bool Matcher::isSimpleConstant64(jlong value) {
MachTypeNode *Matcher::make_decode_node(Compile *C) {
assert(Universe::narrow_oop_base() == NULL && Universe::narrow_oop_shift() == 0,
"This method is only implemented for unscaled cOops mode so far");
MachTypeNode *decode = new (C) decodeN_unscaledNode();
decode->set_opnd_array(0, new (C) iRegPdstOper());
decode->set_opnd_array(1, new (C) iRegNsrcOper());
MachTypeNode *decode = new decodeN_unscaledNode();
decode->set_opnd_array(0, new iRegPdstOper());
decode->set_opnd_array(1, new iRegNsrcOper());
return decode;
}
*/
@ -2600,20 +2600,20 @@ loadConLNodesTuple loadConLNodesTuple_create(Compile *C, PhaseRegAlloc *ra_, Nod
const bool large_constant_pool = true; // TODO: PPC port C->cfg()->_consts_size > 4000;
if (large_constant_pool) {
// Create new nodes.
loadConL_hiNode *m1 = new (C) loadConL_hiNode();
loadConL_loNode *m2 = new (C) loadConL_loNode();
loadConL_hiNode *m1 = new loadConL_hiNode();
loadConL_loNode *m2 = new loadConL_loNode();
// inputs for new nodes
m1->add_req(NULL, toc);
m2->add_req(NULL, m1);
// operands for new nodes
m1->_opnds[0] = new (C) iRegLdstOper(); // dst
m1->_opnds[1] = immSrc; // src
m1->_opnds[2] = new (C) iRegPdstOper(); // toc
m2->_opnds[0] = new (C) iRegLdstOper(); // dst
m2->_opnds[1] = immSrc; // src
m2->_opnds[2] = new (C) iRegLdstOper(); // base
m1->_opnds[0] = new iRegLdstOper(); // dst
m1->_opnds[1] = immSrc; // src
m1->_opnds[2] = new iRegPdstOper(); // toc
m2->_opnds[0] = new iRegLdstOper(); // dst
m2->_opnds[1] = immSrc; // src
m2->_opnds[2] = new iRegLdstOper(); // base
// Initialize ins_attrib TOC fields.
m1->_const_toc_offset = -1;
@ -2633,15 +2633,15 @@ loadConLNodesTuple loadConLNodesTuple_create(Compile *C, PhaseRegAlloc *ra_, Nod
nodes._last = nodes._large_lo;
assert(m2->bottom_type()->isa_long(), "must be long");
} else {
loadConLNode *m2 = new (C) loadConLNode();
loadConLNode *m2 = new loadConLNode();
// inputs for new nodes
m2->add_req(NULL, toc);
// operands for new nodes
m2->_opnds[0] = new (C) iRegLdstOper(); // dst
m2->_opnds[1] = immSrc; // src
m2->_opnds[2] = new (C) iRegPdstOper(); // toc
m2->_opnds[0] = new iRegLdstOper(); // dst
m2->_opnds[1] = immSrc; // src
m2->_opnds[2] = new iRegPdstOper(); // toc
// Initialize ins_attrib instruction offset.
m2->_cbuf_insts_offset = -1;
@ -2750,20 +2750,20 @@ encode %{
const bool large_constant_pool = true; // TODO: PPC port C->cfg()->_consts_size > 4000;
if (large_constant_pool) {
// Create new nodes.
loadConP_hiNode *m1 = new (C) loadConP_hiNode();
loadConP_loNode *m2 = new (C) loadConP_loNode();
loadConP_hiNode *m1 = new loadConP_hiNode();
loadConP_loNode *m2 = new loadConP_loNode();
// inputs for new nodes
m1->add_req(NULL, n_toc);
m2->add_req(NULL, m1);
// operands for new nodes
m1->_opnds[0] = new (C) iRegPdstOper(); // dst
m1->_opnds[1] = op_src; // src
m1->_opnds[2] = new (C) iRegPdstOper(); // toc
m2->_opnds[0] = new (C) iRegPdstOper(); // dst
m2->_opnds[1] = op_src; // src
m2->_opnds[2] = new (C) iRegLdstOper(); // base
m1->_opnds[0] = new iRegPdstOper(); // dst
m1->_opnds[1] = op_src; // src
m1->_opnds[2] = new iRegPdstOper(); // toc
m2->_opnds[0] = new iRegPdstOper(); // dst
m2->_opnds[1] = op_src; // src
m2->_opnds[2] = new iRegLdstOper(); // base
// Initialize ins_attrib TOC fields.
m1->_const_toc_offset = -1;
@ -2777,15 +2777,15 @@ encode %{
nodes->push(m2);
assert(m2->bottom_type()->isa_ptr(), "must be ptr");
} else {
loadConPNode *m2 = new (C) loadConPNode();
loadConPNode *m2 = new loadConPNode();
// inputs for new nodes
m2->add_req(NULL, n_toc);
// operands for new nodes
m2->_opnds[0] = new (C) iRegPdstOper(); // dst
m2->_opnds[1] = op_src; // src
m2->_opnds[2] = new (C) iRegPdstOper(); // toc
m2->_opnds[0] = new iRegPdstOper(); // dst
m2->_opnds[1] = op_src; // src
m2->_opnds[2] = new iRegPdstOper(); // toc
// Register allocation for new nodes.
ra_->set_pair(m2->_idx, ra_->get_reg_second(this), ra_->get_reg_first(this));
@ -2802,9 +2802,9 @@ encode %{
MachNode *m2;
if (large_constant_pool) {
m2 = new (C) loadConFCompNode();
m2 = new loadConFCompNode();
} else {
m2 = new (C) loadConFNode();
m2 = new loadConFNode();
}
// inputs for new nodes
m2->add_req(NULL, n_toc);
@ -2812,7 +2812,7 @@ encode %{
// operands for new nodes
m2->_opnds[0] = op_dst;
m2->_opnds[1] = op_src;
m2->_opnds[2] = new (C) iRegPdstOper(); // constanttablebase
m2->_opnds[2] = new iRegPdstOper(); // constanttablebase
// register allocation for new nodes
ra_->set_pair(m2->_idx, ra_->get_reg_second(this), ra_->get_reg_first(this));
@ -2826,9 +2826,9 @@ encode %{
MachNode *m2;
if (large_constant_pool) {
m2 = new (C) loadConDCompNode();
m2 = new loadConDCompNode();
} else {
m2 = new (C) loadConDNode();
m2 = new loadConDNode();
}
// inputs for new nodes
m2->add_req(NULL, n_toc);
@ -2836,7 +2836,7 @@ encode %{
// operands for new nodes
m2->_opnds[0] = op_dst;
m2->_opnds[1] = op_src;
m2->_opnds[2] = new (C) iRegPdstOper(); // constanttablebase
m2->_opnds[2] = new iRegPdstOper(); // constanttablebase
// register allocation for new nodes
ra_->set_pair(m2->_idx, ra_->get_reg_second(this), ra_->get_reg_first(this));
@ -2918,15 +2918,15 @@ encode %{
if (VM_Version::has_isel()) {
// use isel instruction with Power 7
cmpP_reg_imm16Node *n_compare = new (C) cmpP_reg_imm16Node();
encodeP_subNode *n_sub_base = new (C) encodeP_subNode();
encodeP_shiftNode *n_shift = new (C) encodeP_shiftNode();
cond_set_0_oopNode *n_cond_set = new (C) cond_set_0_oopNode();
cmpP_reg_imm16Node *n_compare = new cmpP_reg_imm16Node();
encodeP_subNode *n_sub_base = new encodeP_subNode();
encodeP_shiftNode *n_shift = new encodeP_shiftNode();
cond_set_0_oopNode *n_cond_set = new cond_set_0_oopNode();
n_compare->add_req(n_region, n_src);
n_compare->_opnds[0] = op_crx;
n_compare->_opnds[1] = op_src;
n_compare->_opnds[2] = new (C) immL16Oper(0);
n_compare->_opnds[2] = new immL16Oper(0);
n_sub_base->add_req(n_region, n_src);
n_sub_base->_opnds[0] = op_dst;
@ -2956,10 +2956,10 @@ encode %{
} else {
// before Power 7
moveRegNode *n_move = new (C) moveRegNode();
cmpP_reg_imm16Node *n_compare = new (C) cmpP_reg_imm16Node();
encodeP_shiftNode *n_shift = new (C) encodeP_shiftNode();
cond_sub_baseNode *n_sub_base = new (C) cond_sub_baseNode();
moveRegNode *n_move = new moveRegNode();
cmpP_reg_imm16Node *n_compare = new cmpP_reg_imm16Node();
encodeP_shiftNode *n_shift = new encodeP_shiftNode();
cond_sub_baseNode *n_sub_base = new cond_sub_baseNode();
n_move->add_req(n_region, n_src);
n_move->_opnds[0] = op_dst;
@ -2971,7 +2971,7 @@ encode %{
n_compare->_opnds[0] = op_crx;
n_compare->_opnds[1] = op_src;
n_compare->_opnds[2] = new (C) immL16Oper(0);
n_compare->_opnds[2] = new immL16Oper(0);
n_sub_base->add_req(n_region, n_compare, n_src);
n_sub_base->_opnds[0] = op_dst;
@ -3000,13 +3000,13 @@ encode %{
enc_class postalloc_expand_encode_oop_not_null(iRegNdst dst, iRegPdst src) %{
encodeP_subNode *n1 = new (C) encodeP_subNode();
encodeP_subNode *n1 = new encodeP_subNode();
n1->add_req(n_region, n_src);
n1->_opnds[0] = op_dst;
n1->_opnds[1] = op_src;
n1->_bottom_type = _bottom_type;
encodeP_shiftNode *n2 = new (C) encodeP_shiftNode();
encodeP_shiftNode *n2 = new encodeP_shiftNode();
n2->add_req(n_region, n1);
n2->_opnds[0] = op_dst;
n2->_opnds[1] = op_dst;
@ -3020,13 +3020,13 @@ encode %{
%}
enc_class postalloc_expand_decode_oop(iRegPdst dst, iRegNsrc src, flagsReg crx) %{
decodeN_shiftNode *n_shift = new (C) decodeN_shiftNode();
cmpN_reg_imm0Node *n_compare = new (C) cmpN_reg_imm0Node();
decodeN_shiftNode *n_shift = new decodeN_shiftNode();
cmpN_reg_imm0Node *n_compare = new cmpN_reg_imm0Node();
n_compare->add_req(n_region, n_src);
n_compare->_opnds[0] = op_crx;
n_compare->_opnds[1] = op_src;
n_compare->_opnds[2] = new (C) immN_0Oper(TypeNarrowOop::NULL_PTR);
n_compare->_opnds[2] = new immN_0Oper(TypeNarrowOop::NULL_PTR);
n_shift->add_req(n_region, n_src);
n_shift->_opnds[0] = op_dst;
@ -3036,13 +3036,13 @@ encode %{
if (VM_Version::has_isel()) {
// use isel instruction with Power 7
decodeN_addNode *n_add_base = new (C) decodeN_addNode();
decodeN_addNode *n_add_base = new decodeN_addNode();
n_add_base->add_req(n_region, n_shift);
n_add_base->_opnds[0] = op_dst;
n_add_base->_opnds[1] = op_dst;
n_add_base->_bottom_type = _bottom_type;
cond_set_0_ptrNode *n_cond_set = new (C) cond_set_0_ptrNode();
cond_set_0_ptrNode *n_cond_set = new cond_set_0_ptrNode();
n_cond_set->add_req(n_region, n_compare, n_add_base);
n_cond_set->_opnds[0] = op_dst;
n_cond_set->_opnds[1] = op_crx;
@ -3064,7 +3064,7 @@ encode %{
} else {
// before Power 7
cond_add_baseNode *n_add_base = new (C) cond_add_baseNode();
cond_add_baseNode *n_add_base = new cond_add_baseNode();
n_add_base->add_req(n_region, n_compare, n_shift);
n_add_base->_opnds[0] = op_dst;
@ -3086,13 +3086,13 @@ encode %{
%}
enc_class postalloc_expand_decode_oop_not_null(iRegPdst dst, iRegNsrc src) %{
decodeN_shiftNode *n1 = new (C) decodeN_shiftNode();
decodeN_shiftNode *n1 = new decodeN_shiftNode();
n1->add_req(n_region, n_src);
n1->_opnds[0] = op_dst;
n1->_opnds[1] = op_src;
n1->_bottom_type = _bottom_type;
decodeN_addNode *n2 = new (C) decodeN_addNode();
decodeN_addNode *n2 = new decodeN_addNode();
n2->add_req(n_region, n1);
n2->_opnds[0] = op_dst;
n2->_opnds[1] = op_dst;
@ -3388,7 +3388,7 @@ encode %{
// Create new nodes.
// Make an operand with the bit pattern to load as float.
immLOper *op_repl = new (C) immLOper((jlong)replicate_immF(op_src->constantF()));
immLOper *op_repl = new immLOper((jlong)replicate_immF(op_src->constantF()));
loadConLNodesTuple loadConLNodes =
loadConLNodesTuple_create(C, ra_, n_toc, op_repl,
@ -3611,11 +3611,11 @@ encode %{
// Create the nodes for loading the IC from the TOC.
loadConLNodesTuple loadConLNodes_IC =
loadConLNodesTuple_create(C, ra_, n_toc, new (C) immLOper((jlong)Universe::non_oop_word()),
loadConLNodesTuple_create(C, ra_, n_toc, new immLOper((jlong)Universe::non_oop_word()),
OptoReg::Name(R19_H_num), OptoReg::Name(R19_num));
// Create the call node.
CallDynamicJavaDirectSchedNode *call = new (C) CallDynamicJavaDirectSchedNode();
CallDynamicJavaDirectSchedNode *call = new CallDynamicJavaDirectSchedNode();
call->_method_handle_invoke = _method_handle_invoke;
call->_vtable_index = _vtable_index;
call->_method = _method;
@ -3765,7 +3765,7 @@ encode %{
#if defined(ABI_ELFv2)
jlong entry_address = (jlong) this->entry_point();
assert(entry_address, "need address here");
loadConLNodes_Entry = loadConLNodesTuple_create(C, ra_, n_toc, new (C) immLOper(entry_address),
loadConLNodes_Entry = loadConLNodesTuple_create(C, ra_, n_toc, new immLOper(entry_address),
OptoReg::Name(R12_H_num), OptoReg::Name(R12_num));
#else
// Get the struct that describes the function we are about to call.
@ -3777,42 +3777,42 @@ encode %{
loadConLNodesTuple loadConLNodes_Toc;
// Create nodes and operands for loading the entry point.
loadConLNodes_Entry = loadConLNodesTuple_create(C, ra_, n_toc, new (C) immLOper(entry_address),
loadConLNodes_Entry = loadConLNodesTuple_create(C, ra_, n_toc, new immLOper(entry_address),
OptoReg::Name(R12_H_num), OptoReg::Name(R12_num));
// Create nodes and operands for loading the env pointer.
if (fd->env() != NULL) {
loadConLNodes_Env = loadConLNodesTuple_create(C, ra_, n_toc, new (C) immLOper((jlong) fd->env()),
loadConLNodes_Env = loadConLNodesTuple_create(C, ra_, n_toc, new immLOper((jlong) fd->env()),
OptoReg::Name(R11_H_num), OptoReg::Name(R11_num));
} else {
loadConLNodes_Env._large_hi = NULL;
loadConLNodes_Env._large_lo = NULL;
loadConLNodes_Env._small = NULL;
loadConLNodes_Env._last = new (C) loadConL16Node();
loadConLNodes_Env._last->_opnds[0] = new (C) iRegLdstOper();
loadConLNodes_Env._last->_opnds[1] = new (C) immL16Oper(0);
loadConLNodes_Env._last = new loadConL16Node();
loadConLNodes_Env._last->_opnds[0] = new iRegLdstOper();
loadConLNodes_Env._last->_opnds[1] = new immL16Oper(0);
ra_->set_pair(loadConLNodes_Env._last->_idx, OptoReg::Name(R11_H_num), OptoReg::Name(R11_num));
}
// Create nodes and operands for loading the Toc point.
loadConLNodes_Toc = loadConLNodesTuple_create(C, ra_, n_toc, new (C) immLOper((jlong) fd->toc()),
loadConLNodes_Toc = loadConLNodesTuple_create(C, ra_, n_toc, new immLOper((jlong) fd->toc()),
OptoReg::Name(R2_H_num), OptoReg::Name(R2_num));
#endif // ABI_ELFv2
// mtctr node
MachNode *mtctr = new (C) CallLeafDirect_mtctrNode();
MachNode *mtctr = new CallLeafDirect_mtctrNode();
assert(loadConLNodes_Entry._last != NULL, "entry must exist");
mtctr->add_req(0, loadConLNodes_Entry._last);
mtctr->_opnds[0] = new (C) iRegLdstOper();
mtctr->_opnds[1] = new (C) iRegLdstOper();
mtctr->_opnds[0] = new iRegLdstOper();
mtctr->_opnds[1] = new iRegLdstOper();
// call node
MachCallLeafNode *call = new (C) CallLeafDirectNode();
MachCallLeafNode *call = new CallLeafDirectNode();
call->_opnds[0] = _opnds[0];
call->_opnds[1] = new (C) methodOper((intptr_t) entry_address); // May get set later.
call->_opnds[1] = new methodOper((intptr_t) entry_address); // May get set later.
// Make the new call node look like the old one.
call->_name = _name;
@ -6050,9 +6050,9 @@ instruct loadConN_Ex(iRegNdst dst, immN src) %{
format %{ "LoadN $dst, $src \t// postalloc expanded" %} // mask
postalloc_expand %{
MachNode *m1 = new (C) loadConN_hiNode();
MachNode *m2 = new (C) loadConN_loNode();
MachNode *m3 = new (C) clearMs32bNode();
MachNode *m1 = new loadConN_hiNode();
MachNode *m2 = new loadConN_loNode();
MachNode *m3 = new clearMs32bNode();
m1->add_req(NULL);
m2->add_req(NULL, m1);
m3->add_req(NULL, m2);
@ -6117,7 +6117,7 @@ instruct loadConNKlass_Ex(iRegNdst dst, immNKlass src) %{
format %{ "LoadN $dst, $src \t// postalloc expanded" %} // mask
postalloc_expand %{
// Load high bits into register. Sign extended.
MachNode *m1 = new (C) loadConNKlass_hiNode();
MachNode *m1 = new loadConNKlass_hiNode();
m1->add_req(NULL);
m1->_opnds[0] = op_dst;
m1->_opnds[1] = op_src;
@ -6127,7 +6127,7 @@ instruct loadConNKlass_Ex(iRegNdst dst, immNKlass src) %{
MachNode *m2 = m1;
if (!Assembler::is_uimm((jlong)Klass::encode_klass((Klass *)op_src->constant()), 31)) {
// Value might be 1-extended. Mask out these bits.
m2 = new (C) clearMs32bNode();
m2 = new clearMs32bNode();
m2->add_req(NULL, m1);
m2->_opnds[0] = op_dst;
m2->_opnds[1] = op_dst;
@ -6135,7 +6135,7 @@ instruct loadConNKlass_Ex(iRegNdst dst, immNKlass src) %{
nodes->push(m2);
}
MachNode *m3 = new (C) loadConNKlass_loNode();
MachNode *m3 = new loadConNKlass_loNode();
m3->add_req(NULL, m2);
m3->_opnds[0] = op_dst;
m3->_opnds[1] = op_src;
@ -6987,14 +6987,14 @@ instruct encodePKlass_not_null_Ex(iRegNdst dst, iRegLsrc base, iRegPsrc src) %{
format %{ "EncodePKlass $dst, $src\t// $src != Null, postalloc expanded" %}
postalloc_expand %{
encodePKlass_sub_baseNode *n1 = new (C) encodePKlass_sub_baseNode();
encodePKlass_sub_baseNode *n1 = new encodePKlass_sub_baseNode();
n1->add_req(n_region, n_base, n_src);
n1->_opnds[0] = op_dst;
n1->_opnds[1] = op_base;
n1->_opnds[2] = op_src;
n1->_bottom_type = _bottom_type;
encodePKlass_shiftNode *n2 = new (C) encodePKlass_shiftNode();
encodePKlass_shiftNode *n2 = new encodePKlass_shiftNode();
n2->add_req(n_region, n1);
n2->_opnds[0] = op_dst;
n2->_opnds[1] = op_dst;
@ -7064,14 +7064,14 @@ instruct decodeNKlass_notNull_addBase_Ex(iRegPdst dst, iRegLsrc base, iRegNsrc s
format %{ "DecodeNKlass $dst = $base + ($src << 3) \t// $src != NULL, postalloc expanded" %}
postalloc_expand %{
decodeNKlass_add_baseNode *n1 = new (C) decodeNKlass_add_baseNode();
decodeNKlass_add_baseNode *n1 = new decodeNKlass_add_baseNode();
n1->add_req(n_region, n_base, n_src);
n1->_opnds[0] = op_dst;
n1->_opnds[1] = op_base;
n1->_opnds[2] = op_src;
n1->_bottom_type = _bottom_type;
decodeNKlass_shiftNode *n2 = new (C) decodeNKlass_shiftNode();
decodeNKlass_shiftNode *n2 = new decodeNKlass_shiftNode();
n2->add_req(n_region, n1);
n2->_opnds[0] = op_dst;
n2->_opnds[1] = op_dst;
@ -9773,8 +9773,8 @@ instruct cmovI_bso_stackSlotL_conLvalue0_Ex(iRegIdst dst, flagsReg crx, stackSlo
//
// Create new nodes.
MachNode *m1 = new (C) loadConI16Node();
MachNode *m2 = new (C) cmovI_bso_stackSlotLNode();
MachNode *m1 = new loadConI16Node();
MachNode *m2 = new cmovI_bso_stackSlotLNode();
// inputs for new nodes
m1->add_req(n_region);
@ -9785,7 +9785,7 @@ instruct cmovI_bso_stackSlotL_conLvalue0_Ex(iRegIdst dst, flagsReg crx, stackSlo
// operands for new nodes
m1->_opnds[0] = op_dst;
m1->_opnds[1] = new (C) immI16Oper(0);
m1->_opnds[1] = new immI16Oper(0);
m2->_opnds[0] = op_dst;
m2->_opnds[1] = op_crx;
@ -9942,8 +9942,8 @@ instruct cmovL_bso_stackSlotL_conLvalue0_Ex(iRegLdst dst, flagsReg crx, stackSlo
//
// Create new nodes.
MachNode *m1 = new (C) loadConL16Node();
MachNode *m2 = new (C) cmovL_bso_stackSlotLNode();
MachNode *m1 = new loadConL16Node();
MachNode *m2 = new cmovL_bso_stackSlotLNode();
// inputs for new nodes
m1->add_req(n_region);
@ -9952,7 +9952,7 @@ instruct cmovL_bso_stackSlotL_conLvalue0_Ex(iRegLdst dst, flagsReg crx, stackSlo
// operands for new nodes
m1->_opnds[0] = op_dst;
m1->_opnds[1] = new (C) immL16Oper(0);
m1->_opnds[1] = new immL16Oper(0);
m2->_opnds[0] = op_dst;
m2->_opnds[1] = op_crx;
m2->_opnds[2] = op_mem;
@ -10288,8 +10288,8 @@ instruct cmovI_conIvalueMinus1_conIvalue0_conIvalue1_Ex(iRegIdst dst, flagsReg c
//
// Create new nodes.
MachNode *m1 = new (C) loadConI16Node();
MachNode *m2 = new (C) cmovI_conIvalueMinus1_conIvalue1Node();
MachNode *m1 = new loadConI16Node();
MachNode *m2 = new cmovI_conIvalueMinus1_conIvalue1Node();
// inputs for new nodes
m1->add_req(n_region);
@ -10298,7 +10298,7 @@ instruct cmovI_conIvalueMinus1_conIvalue0_conIvalue1_Ex(iRegIdst dst, flagsReg c
// operands for new nodes
m1->_opnds[0] = op_dst;
m1->_opnds[1] = new (C) immI16Oper(0);
m1->_opnds[1] = new immI16Oper(0);
m2->_opnds[0] = op_dst;
m2->_opnds[1] = op_crx;
@ -10623,8 +10623,8 @@ instruct cmpF_reg_reg_Ex(flagsReg crx, regF src1, regF src2) %{
//
// Create new nodes.
MachNode *m1 = new (C) cmpFUnordered_reg_regNode();
MachNode *m2 = new (C) cmov_bns_lessNode();
MachNode *m1 = new cmpFUnordered_reg_regNode();
MachNode *m2 = new cmov_bns_lessNode();
// inputs for new nodes
m1->add_req(n_region, n_src1, n_src2);
@ -10698,8 +10698,8 @@ instruct cmpD_reg_reg_Ex(flagsReg crx, regD src1, regD src2) %{
//
// create new nodes
MachNode *m1 = new (C) cmpDUnordered_reg_regNode();
MachNode *m2 = new (C) cmov_bns_lessNode();
MachNode *m1 = new cmpDUnordered_reg_regNode();
MachNode *m2 = new cmov_bns_lessNode();
// inputs for new nodes
m1->add_req(n_region, n_src1, n_src2);

19
hotspot/src/cpu/sparc/vm/assembler_sparc.hpp
View File

@ -123,6 +123,7 @@ class Assembler : public AbstractAssembler {
fpop2_op3 = 0x35,
impdep1_op3 = 0x36,
aes3_op3 = 0x36,
sha_op3 = 0x36,
alignaddr_op3 = 0x36,
faligndata_op3 = 0x36,
flog3_op3 = 0x36,
@ -223,7 +224,11 @@ class Assembler : public AbstractAssembler {
mwtos_opf = 0x119,
aes_kexpand0_opf = 0x130,
aes_kexpand2_opf = 0x131
aes_kexpand2_opf = 0x131,
sha1_opf = 0x141,
sha256_opf = 0x142,
sha512_opf = 0x143
};
enum op5s {
@ -595,6 +600,11 @@ class Assembler : public AbstractAssembler {
// AES crypto instructions supported only on certain processors
static void aes_only() { assert( VM_Version::has_aes(), "This instruction only works on SPARC with AES instructions support"); }
// SHA crypto instructions supported only on certain processors
static void sha1_only() { assert( VM_Version::has_sha1(), "This instruction only works on SPARC with SHA1"); }
static void sha256_only() { assert( VM_Version::has_sha256(), "This instruction only works on SPARC with SHA256"); }
static void sha512_only() { assert( VM_Version::has_sha512(), "This instruction only works on SPARC with SHA512"); }
// instruction only in VIS1
static void vis1_only() { assert( VM_Version::has_vis1(), "This instruction only works on SPARC with VIS1"); }
@ -1179,7 +1189,6 @@ public:
u_field(3, 29, 25) | immed(true) | simm(simm13a, 13)); }
inline void wrfprs( Register d) { v9_only(); emit_int32( op(arith_op) | rs1(d) | op3(wrreg_op3) | u_field(6, 29, 25)); }
// VIS1 instructions
void alignaddr( Register s1, Register s2, Register d ) { vis1_only(); emit_int32( op(arith_op) | rd(d) | op3(alignaddr_op3) | rs1(s1) | opf(alignaddr_opf) | rs2(s2)); }
@ -1203,6 +1212,12 @@ public:
void movwtos( Register s, FloatRegister d ) { vis3_only(); emit_int32( op(arith_op) | fd(d, FloatRegisterImpl::S) | op3(mftoi_op3) | opf(mwtos_opf) | rs2(s)); }
void movxtod( Register s, FloatRegister d ) { vis3_only(); emit_int32( op(arith_op) | fd(d, FloatRegisterImpl::D) | op3(mftoi_op3) | opf(mxtod_opf) | rs2(s)); }
// Crypto SHA instructions
void sha1() { sha1_only(); emit_int32( op(arith_op) | op3(sha_op3) | opf(sha1_opf)); }
void sha256() { sha256_only(); emit_int32( op(arith_op) | op3(sha_op3) | opf(sha256_opf)); }
void sha512() { sha512_only(); emit_int32( op(arith_op) | op3(sha_op3) | opf(sha512_opf)); }
// Creation
Assembler(CodeBuffer* code) : AbstractAssembler(code) {
#ifdef CHECK_DELAY

5
hotspot/src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp
View File

@ -1612,13 +1612,10 @@ int LIR_Assembler::safepoint_poll(LIR_Opr tmp, CodeEmitInfo* info) {
__ set((intptr_t)os::get_polling_page(), tmp->as_register());
if (info != NULL) {
add_debug_info_for_branch(info);
} else {
__ relocate(relocInfo::poll_type);
}
int offset = __ offset();
__ relocate(relocInfo::poll_type);
__ ld_ptr(tmp->as_register(), 0, G0);
return offset;
}

10
hotspot/src/cpu/sparc/vm/c1_LIRGenerator_sparc.cpp
View File

@ -872,21 +872,19 @@ void LIRGenerator::do_Convert(Convert* x) {
void LIRGenerator::do_NewInstance(NewInstance* x) {
print_if_not_loaded(x);
// This instruction can be deoptimized in the slow path : use
// O0 as result register.
const LIR_Opr reg = result_register_for(x->type());
#ifndef PRODUCT
if (PrintNotLoaded && !x->klass()->is_loaded()) {
tty->print_cr(" ###class not loaded at new bci %d", x->printable_bci());
}
#endif
CodeEmitInfo* info = state_for(x, x->state());
LIR_Opr tmp1 = FrameMap::G1_oop_opr;
LIR_Opr tmp2 = FrameMap::G3_oop_opr;
LIR_Opr tmp3 = FrameMap::G4_oop_opr;
LIR_Opr tmp4 = FrameMap::O1_oop_opr;
LIR_Opr klass_reg = FrameMap::G5_metadata_opr;
new_instance(reg, x->klass(), tmp1, tmp2, tmp3, tmp4, klass_reg, info);
new_instance(reg, x->klass(), x->is_unresolved(), tmp1, tmp2, tmp3, tmp4, klass_reg, info);
LIR_Opr result = rlock_result(x);
__ move(reg, result);
}

2
hotspot/src/cpu/sparc/vm/compiledIC_sparc.cpp
View File

@ -135,7 +135,7 @@ void CompiledStaticCall::set_to_interpreted(methodHandle callee, address entry)
if (TraceICs) {
ResourceMark rm;
tty->print_cr("CompiledStaticCall@" INTPTR_FORMAT ": set_to_interpreted %s",
instruction_address(),
p2i(instruction_address()),
callee->name_and_sig_as_C_string());
}

22
hotspot/src/cpu/sparc/vm/debug_sparc.cpp
View File

@ -42,20 +42,24 @@ void pd_ps(frame f) {
intptr_t *pc = NULL;
intptr_t *next_pc = NULL;
int count = 0;
tty->print("register window backtrace from %#x:\n", sp);
tty->print_cr("register window backtrace from " INTPTR_FORMAT ":", p2i(sp));
while (sp != NULL && ((intptr_t)sp & 7) == 0 && sp > prev_sp && sp < prev_sp+1000) {
pc = next_pc;
next_pc = (intptr_t*) sp[I7->sp_offset_in_saved_window()];
tty->print("[%d] sp=%#x pc=", count, sp);
tty->print("[%d] sp=" INTPTR_FORMAT " pc=", count, p2i(sp));
findpc((intptr_t)pc);
if (WizardMode && Verbose) {
// print register window contents also
tty->print_cr(" L0..L7: {%#x %#x %#x %#x %#x %#x %#x %#x}",
sp[0+0],sp[0+1],sp[0+2],sp[0+3],
sp[0+4],sp[0+5],sp[0+6],sp[0+7]);
tty->print_cr(" I0..I7: {%#x %#x %#x %#x %#x %#x %#x %#x}",
sp[8+0],sp[8+1],sp[8+2],sp[8+3],
sp[8+4],sp[8+5],sp[8+6],sp[8+7]);
tty->print_cr(" L0..L7: {"
INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT " "
INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT " ",
sp[0+0], sp[0+1], sp[0+2], sp[0+3],
sp[0+4], sp[0+5], sp[0+6], sp[0+7]);
tty->print_cr(" I0..I7: {"
INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT " "
INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT " ",
sp[8+0], sp[8+1], sp[8+2], sp[8+3],
sp[8+4], sp[8+5], sp[8+6], sp[8+7]);
// (and print stack frame contents too??)
CodeBlob *b = CodeCache::find_blob((address) pc);
@ -74,7 +78,7 @@ void pd_ps(frame f) {
count += 1;
}
if (sp != NULL)
tty->print("[%d] sp=%#x [bogus sp!]", count, sp);
tty->print("[%d] sp=" INTPTR_FORMAT " [bogus sp!]", count, p2i(sp));
}
#endif // PRODUCT

3
hotspot/src/cpu/sparc/vm/frame_sparc.cpp
View File

@ -557,7 +557,8 @@ void frame::patch_pc(Thread* thread, address pc) {
// QQQ this assert is invalid (or too strong anyway) sice _pc could
// be original pc and frame could have the deopt pc.
// assert(_pc == *O7_addr() + pc_return_offset, "frame has wrong pc");
tty->print_cr("patch_pc at address 0x%x [0x%x -> 0x%x] ", O7_addr(), _pc, pc);
tty->print_cr("patch_pc at address " INTPTR_FORMAT " [" INTPTR_FORMAT " -> " INTPTR_FORMAT "]",
p2i(O7_addr()), p2i(_pc), p2i(pc));
}
_cb = CodeCache::find_blob(pc);
*O7_addr() = pc - pc_return_offset;

2
hotspot/src/cpu/sparc/vm/macroAssembler_sparc.cpp
View File

@ -1202,7 +1202,7 @@ void RegistersForDebugging::print(outputStream* s) {
if ( j != last ) s->print(" - f%d", last);
s->print(" = %f", val);
s->fill_to(25);
s->print_cr(" (0x%x)", val);
s->print_cr(" (0x%x)", *(int*)&val);
j = last + 1;
}
s->cr();

2
hotspot/src/cpu/sparc/vm/methodHandles_sparc.cpp
View File

@ -483,7 +483,7 @@ void trace_method_handle_stub(const char* adaptername,
const char* mh_reg_name = has_mh ? "G3_mh" : "G3";
tty->print_cr("MH %s %s="INTPTR_FORMAT " saved_sp=" INTPTR_FORMAT " args=" INTPTR_FORMAT,
adaptername, mh_reg_name,
(intptr_t) mh, saved_sp, args);
p2i(mh), p2i(saved_sp), p2i(args));
if (Verbose) {
// dumping last frame with frame::describe

160
hotspot/src/cpu/sparc/vm/nativeInst_sparc.cpp
View File

@ -78,7 +78,7 @@ void NativeInstruction::verify() {
}
void NativeInstruction::print() {
tty->print_cr(INTPTR_FORMAT ": 0x%x", addr_at(0), long_at(0));
tty->print_cr(INTPTR_FORMAT ": 0x%x", p2i(addr_at(0)), long_at(0));
}
void NativeInstruction::set_long_at(int offset, int i) {
@ -142,7 +142,7 @@ void NativeCall::verify() {
}
void NativeCall::print() {
tty->print_cr(INTPTR_FORMAT ": call " INTPTR_FORMAT, instruction_address(), destination());
tty->print_cr(INTPTR_FORMAT ": call " INTPTR_FORMAT, p2i(instruction_address()), p2i(destination()));
}
@ -271,7 +271,7 @@ bool NativeFarCall::is_call_at(address instr) {
}
void NativeFarCall::print() {
tty->print_cr(INTPTR_FORMAT ": call " INTPTR_FORMAT, instruction_address(), destination());
tty->print_cr(INTPTR_FORMAT ": call " INTPTR_FORMAT, p2i(instruction_address()), p2i(destination()));
}
bool NativeFarCall::destination_is_compiled_verified_entry_point() {
@ -324,7 +324,7 @@ void NativeMovConstReg::verify() {
void NativeMovConstReg::print() {
tty->print_cr(INTPTR_FORMAT ": mov reg, " INTPTR_FORMAT, instruction_address(), data());
tty->print_cr(INTPTR_FORMAT ": mov reg, " INTPTR_FORMAT, p2i(instruction_address()), data());
}
@ -446,7 +446,7 @@ void NativeMovConstRegPatching::verify() {
void NativeMovConstRegPatching::print() {
tty->print_cr(INTPTR_FORMAT ": mov reg, " INTPTR_FORMAT, instruction_address(), data());
tty->print_cr(INTPTR_FORMAT ": mov reg, 0x%x", p2i(instruction_address()), data());
}
@ -585,9 +585,10 @@ void NativeMovRegMem::verify() {
void NativeMovRegMem::print() {
if (is_immediate()) {
tty->print_cr(INTPTR_FORMAT ": mov reg, [reg + %x]", instruction_address(), offset());
// offset is a signed 13-bit immediate, so casting it to int will not lose significant bits
tty->print_cr(INTPTR_FORMAT ": mov reg, [reg + %d]", p2i(instruction_address()), (int)offset());
} else {
tty->print_cr(INTPTR_FORMAT ": mov reg, [reg + reg]", instruction_address());
tty->print_cr(INTPTR_FORMAT ": mov reg, [reg + reg]", p2i(instruction_address()));
}
}
@ -689,149 +690,6 @@ void NativeMovRegMem::test() {
// End code for unit testing implementation of NativeMovRegMem class
//--------------------------------------------------------------------------------
void NativeMovRegMemPatching::copy_instruction_to(address new_instruction_address) {
Untested("copy_instruction_to");
int instruction_size = next_instruction_address() - instruction_address();
for (int i = 0; i < instruction_size; i += wordSize) {
*(long*)(new_instruction_address + i) = *(long*)(address(this) + i);
}
}
void NativeMovRegMemPatching::verify() {
NativeInstruction::verify();
// make sure code pattern is actually a "ld" or "st" of some sort.
int i0 = long_at(0);
int op3 = inv_op3(i0);
assert((int)nop_offset == (int)NativeMovConstReg::add_offset, "sethi size ok");
if (!(is_op(i0, Assembler::ldst_op) &&
inv_immed(i0) &&
0 != (op3 < op3_ldst_int_limit
? (1 << op3 ) & (op3_mask_ld | op3_mask_st)
: (1 << (op3 - op3_ldst_int_limit)) & (op3_mask_ldf | op3_mask_stf)))) {
int i1 = long_at(ldst_offset);
Register rd = inv_rd(i0);
op3 = inv_op3(i1);
if (!is_op(i1, Assembler::ldst_op) && rd == inv_rs2(i1) &&
0 != (op3 < op3_ldst_int_limit
? (1 << op3 ) & (op3_mask_ld | op3_mask_st)
: (1 << (op3 - op3_ldst_int_limit)) & (op3_mask_ldf | op3_mask_stf))) {
fatal("not a ld* or st* op");
}
}
}
void NativeMovRegMemPatching::print() {
if (is_immediate()) {
tty->print_cr(INTPTR_FORMAT ": mov reg, [reg + %x]", instruction_address(), offset());
} else {
tty->print_cr(INTPTR_FORMAT ": mov reg, [reg + reg]", instruction_address());
}
}
// Code for unit testing implementation of NativeMovRegMemPatching class
void NativeMovRegMemPatching::test() {
#ifdef ASSERT
ResourceMark rm;
CodeBuffer cb("test", 1000, 1000);
MacroAssembler* a = new MacroAssembler(&cb);
NativeMovRegMemPatching* nm;
uint idx = 0;
uint idx1;
int offsets[] = {
0x0,
0xffffffff,
0x7fffffff,
0x80000000,
4096,
4097,
0x20,
0x4000,
};
VM_Version::allow_all();
AddressLiteral al(0xffffffff, relocInfo::external_word_type);
a->ldsw( G5, al.low10(), G4); idx++;
a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
a->ldsw( G5, I3, G4 ); idx++;
a->ldsb( G5, al.low10(), G4); idx++;
a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
a->ldsb( G5, I3, G4 ); idx++;
a->ldsh( G5, al.low10(), G4); idx++;
a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
a->ldsh( G5, I3, G4 ); idx++;
a->lduw( G5, al.low10(), G4); idx++;
a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
a->lduw( G5, I3, G4 ); idx++;
a->ldub( G5, al.low10(), G4); idx++;
a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
a->ldub( G5, I3, G4 ); idx++;
a->lduh( G5, al.low10(), G4); idx++;
a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
a->lduh( G5, I3, G4 ); idx++;
a->ldx( G5, al.low10(), G4); idx++;
a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
a->ldx( G5, I3, G4 ); idx++;
a->ldd( G5, al.low10(), G4); idx++;
a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
a->ldd( G5, I3, G4 ); idx++;
a->ldf( FloatRegisterImpl::D, O2, -1, F14 ); idx++;
a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
a->ldf( FloatRegisterImpl::S, O0, I3, F15 ); idx++;
a->stw( G5, G4, al.low10()); idx++;
a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
a->stw( G5, G4, I3 ); idx++;
a->stb( G5, G4, al.low10()); idx++;
a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
a->stb( G5, G4, I3 ); idx++;
a->sth( G5, G4, al.low10()); idx++;
a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
a->sth( G5, G4, I3 ); idx++;
a->stx( G5, G4, al.low10()); idx++;
a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
a->stx( G5, G4, I3 ); idx++;
a->std( G5, G4, al.low10()); idx++;
a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
a->std( G5, G4, I3 ); idx++;
a->stf( FloatRegisterImpl::S, F18, O2, -1 ); idx++;
a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
a->stf( FloatRegisterImpl::S, F15, O0, I3 ); idx++;
nm = nativeMovRegMemPatching_at( cb.insts_begin() );
nm->print();
nm->set_offset( low10(0) );
nm->print();
nm->add_offset_in_bytes( low10(0xbb) * wordSize );
nm->print();
while (--idx) {
nm = nativeMovRegMemPatching_at( nm->next_instruction_address() );
nm->print();
for (idx1 = 0; idx1 < ARRAY_SIZE(offsets); idx1++) {
nm->set_offset( nm->is_immediate() ? low10(offsets[idx1]) : offsets[idx1] );
assert(nm->offset() == (nm->is_immediate() ? low10(offsets[idx1]) : offsets[idx1]),
"check unit test");
nm->print();
}
nm->add_offset_in_bytes( low10(0xbb) * wordSize );
nm->print();
}
VM_Version::revert();
#endif // ASSERT
}
// End code for unit testing implementation of NativeMovRegMemPatching class
//--------------------------------------------------------------------------------
@ -863,7 +721,7 @@ void NativeJump::verify() {
void NativeJump::print() {
tty->print_cr(INTPTR_FORMAT ": jmpl reg, " INTPTR_FORMAT, instruction_address(), jump_destination());
tty->print_cr(INTPTR_FORMAT ": jmpl reg, " INTPTR_FORMAT, p2i(instruction_address()), p2i(jump_destination()));
}

91
hotspot/src/cpu/sparc/vm/nativeInst_sparc.hpp
View File

@ -38,7 +38,6 @@
// - - NativeMovConstReg
// - - NativeMovConstRegPatching
// - - NativeMovRegMem
// - - NativeMovRegMemPatching
// - - NativeJump
// - - NativeGeneralJump
// - - NativeIllegalInstruction
@ -710,96 +709,6 @@ class NativeMovRegMem: public NativeInstruction {
};
// An interface for accessing/manipulating native memory ops
// ld* [reg + offset], reg
// st* reg, [reg + offset]
// sethi %hi(imm), reg; nop; add reg, %lo(imm), reg; ld* [reg1 + reg], reg2
// sethi %hi(imm), reg; nop; add reg, %lo(imm), reg; st* reg2, [reg1 + reg]
// Ops covered: {lds,ldu,st}{w,b,h}, {ld,st}{d,x}
//
// Note that it is identical to NativeMovRegMem with the exception of a nop between the
// sethi and the add. The nop is required to be in the delay slot of the call instruction
// which overwrites the sethi during patching.
class NativeMovRegMemPatching;
inline NativeMovRegMemPatching* nativeMovRegMemPatching_at (address address);
class NativeMovRegMemPatching: public NativeInstruction {
public:
enum Sparc_specific_constants {
op3_mask_ld = 1 << Assembler::lduw_op3 |
1 << Assembler::ldub_op3 |
1 << Assembler::lduh_op3 |
1 << Assembler::ldd_op3 |
1 << Assembler::ldsw_op3 |
1 << Assembler::ldsb_op3 |
1 << Assembler::ldsh_op3 |
1 << Assembler::ldx_op3,
op3_mask_st = 1 << Assembler::stw_op3 |
1 << Assembler::stb_op3 |
1 << Assembler::sth_op3 |
1 << Assembler::std_op3 |
1 << Assembler::stx_op3,
op3_ldst_int_limit = Assembler::ldf_op3,
op3_mask_ldf = 1 << (Assembler::ldf_op3 - op3_ldst_int_limit) |
1 << (Assembler::lddf_op3 - op3_ldst_int_limit),
op3_mask_stf = 1 << (Assembler::stf_op3 - op3_ldst_int_limit) |
1 << (Assembler::stdf_op3 - op3_ldst_int_limit),
offset_width = 13,
sethi_offset = 0,
#ifdef _LP64
nop_offset = 7 * BytesPerInstWord,
#else
nop_offset = 4,
#endif
add_offset = nop_offset + BytesPerInstWord,
ldst_offset = add_offset + BytesPerInstWord
};
bool is_immediate() const {
// check if instruction is ld* [reg + offset], reg or st* reg, [reg + offset]
int i0 = long_at(0);
return (is_op(i0, Assembler::ldst_op));
}
address instruction_address() const { return addr_at(0); }
address next_instruction_address() const {
return addr_at(is_immediate()? 4 : 16);
}
int offset() const {
return is_immediate()? inv_simm(long_at(0), offset_width) :
nativeMovConstRegPatching_at(addr_at(0))->data();
}
void set_offset(int x) {
if (is_immediate()) {
guarantee(fits_in_simm(x, offset_width), "data block offset overflow");
set_long_at(0, set_simm(long_at(0), x, offset_width));
}
else
nativeMovConstRegPatching_at(addr_at(0))->set_data(x);
}
void add_offset_in_bytes(intptr_t radd_offset) {
set_offset (offset() + radd_offset);
}
void copy_instruction_to(address new_instruction_address);
void verify();
void print ();
// unit test stuff
static void test();
private:
friend inline NativeMovRegMemPatching* nativeMovRegMemPatching_at (address address) {
NativeMovRegMemPatching* test = (NativeMovRegMemPatching*)address;
#ifdef ASSERT
test->verify();
#endif
return test;
}
};
// An interface for accessing/manipulating native jumps
// jump_to addr
// == sethi %hi22(addr), temp ; jumpl reg, %lo10(addr), G0 ; <delay>

6
hotspot/src/cpu/sparc/vm/sparc.ad
View File

@ -1206,10 +1206,10 @@ void MachPrologNode::format( PhaseRegAlloc *ra_, outputStream *st ) const {
}
if (Assembler::is_simm13(-framesize)) {
st->print ("SAVE R_SP,-%d,R_SP",framesize);
st->print ("SAVE R_SP,-" SIZE_FORMAT ",R_SP",framesize);
} else {
st->print_cr("SETHI R_SP,hi%%(-%d),R_G3",framesize); st->print("\t");
st->print_cr("ADD R_G3,lo%%(-%d),R_G3",framesize); st->print("\t");
st->print_cr("SETHI R_SP,hi%%(-" SIZE_FORMAT "),R_G3",framesize); st->print("\t");
st->print_cr("ADD R_G3,lo%%(-" SIZE_FORMAT "),R_G3",framesize); st->print("\t");
st->print ("SAVE R_SP,R_G3,R_SP");
}

227
hotspot/src/cpu/sparc/vm/stubGenerator_sparc.cpp
View File

@ -4575,6 +4575,219 @@ class StubGenerator: public StubCodeGenerator {
return start;
}
address generate_sha1_implCompress(bool multi_block, const char *name) {
__ align(CodeEntryAlignment);
StubCodeMark mark(this, "StubRoutines", name);
address start = __ pc();
Label L_sha1_loop, L_sha1_unaligned_input, L_sha1_unaligned_input_loop;
int i;
Register buf = O0; // byte[] source+offset
Register state = O1; // int[] SHA.state
Register ofs = O2; // int offset
Register limit = O3; // int limit
// load state into F0-F4
for (i = 0; i < 5; i++) {
__ ldf(FloatRegisterImpl::S, state, i*4, as_FloatRegister(i));
}
__ andcc(buf, 7, G0);
__ br(Assembler::notZero, false, Assembler::pn, L_sha1_unaligned_input);
__ delayed()->nop();
__ BIND(L_sha1_loop);
// load buf into F8-F22
for (i = 0; i < 8; i++) {
__ ldf(FloatRegisterImpl::D, buf, i*8, as_FloatRegister(i*2 + 8));
}
__ sha1();
if (multi_block) {
__ add(ofs, 64, ofs);
__ add(buf, 64, buf);
__ cmp_and_brx_short(ofs, limit, Assembler::lessEqual, Assembler::pt, L_sha1_loop);
__ mov(ofs, O0); // to be returned
}
// store F0-F4 into state and return
for (i = 0; i < 4; i++) {
__ stf(FloatRegisterImpl::S, as_FloatRegister(i), state, i*4);
}
__ retl();
__ delayed()->stf(FloatRegisterImpl::S, F4, state, 0x10);
__ BIND(L_sha1_unaligned_input);
__ alignaddr(buf, G0, buf);
__ BIND(L_sha1_unaligned_input_loop);
// load buf into F8-F22
for (i = 0; i < 9; i++) {
__ ldf(FloatRegisterImpl::D, buf, i*8, as_FloatRegister(i*2 + 8));
}
for (i = 0; i < 8; i++) {
__ faligndata(as_FloatRegister(i*2 + 8), as_FloatRegister(i*2 + 10), as_FloatRegister(i*2 + 8));
}
__ sha1();
if (multi_block) {
__ add(ofs, 64, ofs);
__ add(buf, 64, buf);
__ cmp_and_brx_short(ofs, limit, Assembler::lessEqual, Assembler::pt, L_sha1_unaligned_input_loop);
__ mov(ofs, O0); // to be returned
}
// store F0-F4 into state and return
for (i = 0; i < 4; i++) {
__ stf(FloatRegisterImpl::S, as_FloatRegister(i), state, i*4);
}
__ retl();
__ delayed()->stf(FloatRegisterImpl::S, F4, state, 0x10);
return start;
}
address generate_sha256_implCompress(bool multi_block, const char *name) {
__ align(CodeEntryAlignment);
StubCodeMark mark(this, "StubRoutines", name);
address start = __ pc();
Label L_sha256_loop, L_sha256_unaligned_input, L_sha256_unaligned_input_loop;
int i;
Register buf = O0; // byte[] source+offset
Register state = O1; // int[] SHA2.state
Register ofs = O2; // int offset
Register limit = O3; // int limit
// load state into F0-F7
for (i = 0; i < 8; i++) {
__ ldf(FloatRegisterImpl::S, state, i*4, as_FloatRegister(i));
}
__ andcc(buf, 7, G0);
__ br(Assembler::notZero, false, Assembler::pn, L_sha256_unaligned_input);
__ delayed()->nop();
__ BIND(L_sha256_loop);
// load buf into F8-F22
for (i = 0; i < 8; i++) {
__ ldf(FloatRegisterImpl::D, buf, i*8, as_FloatRegister(i*2 + 8));
}
__ sha256();
if (multi_block) {
__ add(ofs, 64, ofs);
__ add(buf, 64, buf);
__ cmp_and_brx_short(ofs, limit, Assembler::lessEqual, Assembler::pt, L_sha256_loop);
__ mov(ofs, O0); // to be returned
}
// store F0-F7 into state and return
for (i = 0; i < 7; i++) {
__ stf(FloatRegisterImpl::S, as_FloatRegister(i), state, i*4);
}
__ retl();
__ delayed()->stf(FloatRegisterImpl::S, F7, state, 0x1c);
__ BIND(L_sha256_unaligned_input);
__ alignaddr(buf, G0, buf);
__ BIND(L_sha256_unaligned_input_loop);
// load buf into F8-F22
for (i = 0; i < 9; i++) {
__ ldf(FloatRegisterImpl::D, buf, i*8, as_FloatRegister(i*2 + 8));
}
for (i = 0; i < 8; i++) {
__ faligndata(as_FloatRegister(i*2 + 8), as_FloatRegister(i*2 + 10), as_FloatRegister(i*2 + 8));
}
__ sha256();
if (multi_block) {
__ add(ofs, 64, ofs);
__ add(buf, 64, buf);
__ cmp_and_brx_short(ofs, limit, Assembler::lessEqual, Assembler::pt, L_sha256_unaligned_input_loop);
__ mov(ofs, O0); // to be returned
}
// store F0-F7 into state and return
for (i = 0; i < 7; i++) {
__ stf(FloatRegisterImpl::S, as_FloatRegister(i), state, i*4);
}
__ retl();
__ delayed()->stf(FloatRegisterImpl::S, F7, state, 0x1c);
return start;
}
address generate_sha512_implCompress(bool multi_block, const char *name) {
__ align(CodeEntryAlignment);
StubCodeMark mark(this, "StubRoutines", name);
address start = __ pc();
Label L_sha512_loop, L_sha512_unaligned_input, L_sha512_unaligned_input_loop;
int i;
Register buf = O0; // byte[] source+offset
Register state = O1; // long[] SHA5.state
Register ofs = O2; // int offset
Register limit = O3; // int limit
// load state into F0-F14
for (i = 0; i < 8; i++) {
__ ldf(FloatRegisterImpl::D, state, i*8, as_FloatRegister(i*2));
}
__ andcc(buf, 7, G0);
__ br(Assembler::notZero, false, Assembler::pn, L_sha512_unaligned_input);
__ delayed()->nop();
__ BIND(L_sha512_loop);
// load buf into F16-F46
for (i = 0; i < 16; i++) {
__ ldf(FloatRegisterImpl::D, buf, i*8, as_FloatRegister(i*2 + 16));
}
__ sha512();
if (multi_block) {
__ add(ofs, 128, ofs);
__ add(buf, 128, buf);
__ cmp_and_brx_short(ofs, limit, Assembler::lessEqual, Assembler::pt, L_sha512_loop);
__ mov(ofs, O0); // to be returned
}
// store F0-F14 into state and return
for (i = 0; i < 7; i++) {
__ stf(FloatRegisterImpl::D, as_FloatRegister(i*2), state, i*8);
}
__ retl();
__ delayed()->stf(FloatRegisterImpl::D, F14, state, 0x38);
__ BIND(L_sha512_unaligned_input);
__ alignaddr(buf, G0, buf);
__ BIND(L_sha512_unaligned_input_loop);
// load buf into F16-F46
for (i = 0; i < 17; i++) {
__ ldf(FloatRegisterImpl::D, buf, i*8, as_FloatRegister(i*2 + 16));
}
for (i = 0; i < 16; i++) {
__ faligndata(as_FloatRegister(i*2 + 16), as_FloatRegister(i*2 + 18), as_FloatRegister(i*2 + 16));
}
__ sha512();
if (multi_block) {
__ add(ofs, 128, ofs);
__ add(buf, 128, buf);
__ cmp_and_brx_short(ofs, limit, Assembler::lessEqual, Assembler::pt, L_sha512_unaligned_input_loop);
__ mov(ofs, O0); // to be returned
}
// store F0-F14 into state and return
for (i = 0; i < 7; i++) {
__ stf(FloatRegisterImpl::D, as_FloatRegister(i*2), state, i*8);
}
__ retl();
__ delayed()->stf(FloatRegisterImpl::D, F14, state, 0x38);
return start;
}
void generate_initial() {
// Generates all stubs and initializes the entry points
@ -4647,6 +4860,20 @@ class StubGenerator: public StubCodeGenerator {
StubRoutines::_cipherBlockChaining_encryptAESCrypt = generate_cipherBlockChaining_encryptAESCrypt();
StubRoutines::_cipherBlockChaining_decryptAESCrypt = generate_cipherBlockChaining_decryptAESCrypt_Parallel();
}
// generate SHA1/SHA256/SHA512 intrinsics code
if (UseSHA1Intrinsics) {
StubRoutines::_sha1_implCompress = generate_sha1_implCompress(false, "sha1_implCompress");
StubRoutines::_sha1_implCompressMB = generate_sha1_implCompress(true, "sha1_implCompressMB");
}
if (UseSHA256Intrinsics) {
StubRoutines::_sha256_implCompress = generate_sha256_implCompress(false, "sha256_implCompress");
StubRoutines::_sha256_implCompressMB = generate_sha256_implCompress(true, "sha256_implCompressMB");
}
if (UseSHA512Intrinsics) {
StubRoutines::_sha512_implCompress = generate_sha512_implCompress(false, "sha512_implCompress");
StubRoutines::_sha512_implCompressMB = generate_sha512_implCompress(true, "sha512_implCompressMB");
}
}

2
hotspot/src/cpu/sparc/vm/stubRoutines_sparc.hpp
View File

@ -41,7 +41,7 @@ static bool returns_to_call_stub(address return_pc) {
enum /* platform_dependent_constants */ {
// %%%%%%%% May be able to shrink this a lot
code_size1 = 20000, // simply increase if too small (assembler will crash if too small)
code_size2 = 22000 // simply increase if too small (assembler will crash if too small)
code_size2 = 23000 // simply increase if too small (assembler will crash if too small)
};
class Sparc {

18
hotspot/src/cpu/sparc/vm/templateInterpreter_sparc.cpp
View File

@ -1722,15 +1722,15 @@ void AbstractInterpreter::layout_activation(Method* method,
if (caller->is_interpreted_frame()) {
tty->print("interpreted ");
}
tty->print_cr("caller fp=0x%x sp=0x%x", caller->fp(), caller->sp());
tty->print_cr("save area = 0x%x, 0x%x", caller->sp(), caller->sp() + 16);
tty->print_cr("save area = 0x%x, 0x%x", caller->fp(), caller->fp() + 16);
tty->print_cr("interpreter fp=0x%x sp=0x%x", interpreter_frame->fp(), interpreter_frame->sp());
tty->print_cr("save area = 0x%x, 0x%x", interpreter_frame->sp(), interpreter_frame->sp() + 16);
tty->print_cr("save area = 0x%x, 0x%x", interpreter_frame->fp(), interpreter_frame->fp() + 16);
tty->print_cr("Llocals = 0x%x", locals);
tty->print_cr("Lesp = 0x%x", esp);
tty->print_cr("Lmonitors = 0x%x", monitors);
tty->print_cr("caller fp=" INTPTR_FORMAT " sp=" INTPTR_FORMAT, p2i(caller->fp()), p2i(caller->sp()));
tty->print_cr("save area = " INTPTR_FORMAT ", " INTPTR_FORMAT, p2i(caller->sp()), p2i(caller->sp() + 16));
tty->print_cr("save area = " INTPTR_FORMAT ", " INTPTR_FORMAT, p2i(caller->fp()), p2i(caller->fp() + 16));
tty->print_cr("interpreter fp=" INTPTR_FORMAT ", " INTPTR_FORMAT, p2i(interpreter_frame->fp()), p2i(interpreter_frame->sp()));
tty->print_cr("save area = " INTPTR_FORMAT ", " INTPTR_FORMAT, p2i(interpreter_frame->sp()), p2i(interpreter_frame->sp() + 16));
tty->print_cr("save area = " INTPTR_FORMAT ", " INTPTR_FORMAT, p2i(interpreter_frame->fp()), p2i(interpreter_frame->fp() + 16));
tty->print_cr("Llocals = " INTPTR_FORMAT, p2i(locals));
tty->print_cr("Lesp = " INTPTR_FORMAT, p2i(esp));
tty->print_cr("Lmonitors = " INTPTR_FORMAT, p2i(monitors));
}
if (method->max_locals() > 0) {

57
hotspot/src/cpu/sparc/vm/vm_version_sparc.cpp
View File

@ -234,7 +234,7 @@ void VM_Version::initialize() {
assert((OptoLoopAlignment % relocInfo::addr_unit()) == 0, "alignment is not a multiple of NOP size");
char buf[512];
jio_snprintf(buf, sizeof(buf), "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
jio_snprintf(buf, sizeof(buf), "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
(has_v9() ? ", v9" : (has_v8() ? ", v8" : "")),
(has_hardware_popc() ? ", popc" : ""),
(has_vis1() ? ", vis1" : ""),
@ -243,6 +243,9 @@ void VM_Version::initialize() {
(has_blk_init() ? ", blk_init" : ""),
(has_cbcond() ? ", cbcond" : ""),
(has_aes() ? ", aes" : ""),
(has_sha1() ? ", sha1" : ""),
(has_sha256() ? ", sha256" : ""),
(has_sha512() ? ", sha512" : ""),
(is_ultra3() ? ", ultra3" : ""),
(is_sun4v() ? ", sun4v" : ""),
(is_niagara_plus() ? ", niagara_plus" : (is_niagara() ? ", niagara" : "")),
@ -301,6 +304,58 @@ void VM_Version::initialize() {
}
}
// SHA1, SHA256, and SHA512 instructions were added to SPARC T-series at different times
if (has_sha1() || has_sha256() || has_sha512()) {
if (UseVIS > 0) { // SHA intrinsics use VIS1 instructions
if (FLAG_IS_DEFAULT(UseSHA)) {
FLAG_SET_DEFAULT(UseSHA, true);
}
} else {
if (UseSHA) {
warning("SPARC SHA intrinsics require VIS1 instruction support. Intrinsics will be disabled.");
FLAG_SET_DEFAULT(UseSHA, false);
}
}
} else if (UseSHA) {
warning("SHA instructions are not available on this CPU");
FLAG_SET_DEFAULT(UseSHA, false);
}
if (!UseSHA) {
FLAG_SET_DEFAULT(UseSHA1Intrinsics, false);
FLAG_SET_DEFAULT(UseSHA256Intrinsics, false);
FLAG_SET_DEFAULT(UseSHA512Intrinsics, false);
} else {
if (has_sha1()) {
if (FLAG_IS_DEFAULT(UseSHA1Intrinsics)) {
FLAG_SET_DEFAULT(UseSHA1Intrinsics, true);
}
} else if (UseSHA1Intrinsics) {
warning("SHA1 instruction is not available on this CPU.");
FLAG_SET_DEFAULT(UseSHA1Intrinsics, false);
}
if (has_sha256()) {
if (FLAG_IS_DEFAULT(UseSHA256Intrinsics)) {
FLAG_SET_DEFAULT(UseSHA256Intrinsics, true);
}
} else if (UseSHA256Intrinsics) {
warning("SHA256 instruction (for SHA-224 and SHA-256) is not available on this CPU.");
FLAG_SET_DEFAULT(UseSHA256Intrinsics, false);
}
if (has_sha512()) {
if (FLAG_IS_DEFAULT(UseSHA512Intrinsics)) {
FLAG_SET_DEFAULT(UseSHA512Intrinsics, true);
}
} else if (UseSHA512Intrinsics) {
warning("SHA512 instruction (for SHA-384 and SHA-512) is not available on this CPU.");
FLAG_SET_DEFAULT(UseSHA512Intrinsics, false);
}
if (!(UseSHA1Intrinsics || UseSHA256Intrinsics || UseSHA512Intrinsics)) {
FLAG_SET_DEFAULT(UseSHA, false);
}
}
if (FLAG_IS_DEFAULT(ContendedPaddingWidth) &&
(cache_line_size > ContendedPaddingWidth))
ContendedPaddingWidth = cache_line_size;

13
hotspot/src/cpu/sparc/vm/vm_version_sparc.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2014, 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
@ -50,7 +50,10 @@ protected:
T_family = 16,
T1_model = 17,
sparc5_instructions = 18,
aes_instructions = 19
aes_instructions = 19,
sha1_instruction = 20,
sha256_instruction = 21,
sha512_instruction = 22
};
enum Feature_Flag_Set {
@ -77,6 +80,9 @@ protected:
T1_model_m = 1 << T1_model,
sparc5_instructions_m = 1 << sparc5_instructions,
aes_instructions_m = 1 << aes_instructions,
sha1_instruction_m = 1 << sha1_instruction,
sha256_instruction_m = 1 << sha256_instruction,
sha512_instruction_m = 1 << sha512_instruction,
generic_v8_m = v8_instructions_m | hardware_mul32_m | hardware_div32_m | hardware_fsmuld_m,
generic_v9_m = generic_v8_m | v9_instructions_m,
@ -129,6 +135,9 @@ public:
static bool has_cbcond() { return (_features & cbcond_instructions_m) != 0; }
static bool has_sparc5_instr() { return (_features & sparc5_instructions_m) != 0; }
static bool has_aes() { return (_features & aes_instructions_m) != 0; }
static bool has_sha1() { return (_features & sha1_instruction_m) != 0; }
static bool has_sha256() { return (_features & sha256_instruction_m) != 0; }
static bool has_sha512() { return (_features & sha512_instruction_m) != 0; }
static bool supports_compare_and_exchange()
{ return has_v9(); }

4
hotspot/src/cpu/sparc/vm/vtableStubs_sparc.cpp
View File

@ -111,7 +111,7 @@ VtableStub* VtableStubs::create_vtable_stub(int vtable_index) {
if (PrintMiscellaneous && (WizardMode || Verbose)) {
tty->print_cr("vtable #%d at "PTR_FORMAT"[%d] left over: %d",
vtable_index, s->entry_point(),
vtable_index, p2i(s->entry_point()),
(int)(s->code_end() - s->entry_point()),
(int)(s->code_end() - __ pc()));
}
@ -206,7 +206,7 @@ VtableStub* VtableStubs::create_itable_stub(int itable_index) {
if (PrintMiscellaneous && (WizardMode || Verbose)) {
tty->print_cr("itable #%d at "PTR_FORMAT"[%d] left over: %d",
itable_index, s->entry_point(),
itable_index, p2i(s->entry_point()),
(int)(s->code_end() - s->entry_point()),
(int)(s->code_end() - __ pc()));
}

9
hotspot/src/cpu/x86/vm/c1_LIRGenerator_x86.cpp
View File

@ -1085,14 +1085,11 @@ void LIRGenerator::do_Convert(Convert* x) {
void LIRGenerator::do_NewInstance(NewInstance* x) {
#ifndef PRODUCT
if (PrintNotLoaded && !x->klass()->is_loaded()) {
tty->print_cr(" ###class not loaded at new bci %d", x->printable_bci());
}
#endif
print_if_not_loaded(x);
CodeEmitInfo* info = state_for(x, x->state());
LIR_Opr reg = result_register_for(x->type());
new_instance(reg, x->klass(),
new_instance(reg, x->klass(), x->is_unresolved(),
FrameMap::rcx_oop_opr,
FrameMap::rdi_oop_opr,
FrameMap::rsi_oop_opr,

12
hotspot/src/cpu/x86/vm/nativeInst_x86.hpp
View File

@ -327,18 +327,6 @@ inline NativeMovRegMem* nativeMovRegMem_at (address address) {
return test;
}
class NativeMovRegMemPatching: public NativeMovRegMem {
private:
friend NativeMovRegMemPatching* nativeMovRegMemPatching_at (address address) {
NativeMovRegMemPatching* test = (NativeMovRegMemPatching*)(address - instruction_offset);
#ifdef ASSERT
test->verify();
#endif
return test;
}
};
// An interface for accessing/manipulating native leal instruction of form:
// leal reg, [reg + offset]

11
hotspot/src/cpu/x86/vm/vm_version_x86.cpp
View File

@ -590,6 +590,17 @@ void VM_Version::get_processor_features() {
FLAG_SET_DEFAULT(UseAESIntrinsics, false);
}
if (UseSHA) {
warning("SHA instructions are not available on this CPU");
FLAG_SET_DEFAULT(UseSHA, false);
}
if (UseSHA1Intrinsics || UseSHA256Intrinsics || UseSHA512Intrinsics) {
warning("SHA intrinsics are not available on this CPU");
FLAG_SET_DEFAULT(UseSHA1Intrinsics, false);
FLAG_SET_DEFAULT(UseSHA256Intrinsics, false);
FLAG_SET_DEFAULT(UseSHA512Intrinsics, false);
}
// Adjust RTM (Restricted Transactional Memory) flags
if (!supports_rtm() && UseRTMLocking) {
// Can't continue because UseRTMLocking affects UseBiasedLocking flag

12
hotspot/src/cpu/x86/vm/x86_32.ad
View File

@ -1401,22 +1401,22 @@ void Matcher::pd_implicit_null_fixup(MachNode *node, uint idx) {
// No transformation necessary.
return;
case INDIRECT:
new_memory = new (C) indirect_win95_safeOper( );
new_memory = new indirect_win95_safeOper( );
break;
case INDOFFSET8:
new_memory = new (C) indOffset8_win95_safeOper(memory->disp(NULL, NULL, 0));
new_memory = new indOffset8_win95_safeOper(memory->disp(NULL, NULL, 0));
break;
case INDOFFSET32:
new_memory = new (C) indOffset32_win95_safeOper(memory->disp(NULL, NULL, 0));
new_memory = new indOffset32_win95_safeOper(memory->disp(NULL, NULL, 0));
break;
case INDINDEXOFFSET:
new_memory = new (C) indIndexOffset_win95_safeOper(memory->disp(NULL, NULL, 0));
new_memory = new indIndexOffset_win95_safeOper(memory->disp(NULL, NULL, 0));
break;
case INDINDEXSCALE:
new_memory = new (C) indIndexScale_win95_safeOper(memory->scale());
new_memory = new indIndexScale_win95_safeOper(memory->scale());
break;
case INDINDEXSCALEOFFSET:
new_memory = new (C) indIndexScaleOffset_win95_safeOper(memory->scale(), memory->disp(NULL, NULL, 0));
new_memory = new indIndexScaleOffset_win95_safeOper(memory->scale(), memory->disp(NULL, NULL, 0));
break;
case LOAD_LONG_INDIRECT:
case LOAD_LONG_INDOFFSET32:

6
hotspot/src/os/aix/vm/os_aix.cpp
View File

@ -4734,10 +4734,8 @@ int os::PlatformEvent::park(jlong millis) {
//
// Thread.interrupt and object.notify{All} both call Event::set.
// That is, we treat thread.interrupt as a special case of notification.
// The underlying Solaris implementation, cond_timedwait, admits
// spurious/premature wakeups, but the JLS/JVM spec prevents the
// JVM from making those visible to Java code. As such, we must
// filter out spurious wakeups. We assume all ETIME returns are valid.
// We ignore spurious OS wakeups unless FilterSpuriousWakeups is false.
// We assume all ETIME returns are valid.
//
// TODO: properly differentiate simultaneous notify+interrupt.
// In that case, we should propagate the notify to another waiter.

6
hotspot/src/os/bsd/vm/os_bsd.cpp
View File

@ -4299,10 +4299,8 @@ int os::PlatformEvent::park(jlong millis) {
//
// Thread.interrupt and object.notify{All} both call Event::set.
// That is, we treat thread.interrupt as a special case of notification.
// The underlying Solaris implementation, cond_timedwait, admits
// spurious/premature wakeups, but the JLS/JVM spec prevents the
// JVM from making those visible to Java code. As such, we must
// filter out spurious wakeups. We assume all ETIME returns are valid.
// We ignore spurious OS wakeups unless FilterSpuriousWakeups is false.
// We assume all ETIME returns are valid.
//
// TODO: properly differentiate simultaneous notify+interrupt.
// In that case, we should propagate the notify to another waiter.

6
hotspot/src/os/linux/vm/os_linux.cpp
View File

@ -5538,10 +5538,8 @@ int os::PlatformEvent::park(jlong millis) {
//
// Thread.interrupt and object.notify{All} both call Event::set.
// That is, we treat thread.interrupt as a special case of notification.
// The underlying Solaris implementation, cond_timedwait, admits
// spurious/premature wakeups, but the JLS/JVM spec prevents the
// JVM from making those visible to Java code. As such, we must
// filter out spurious wakeups. We assume all ETIME returns are valid.
// We ignore spurious OS wakeups unless FilterSpuriousWakeups is false.
// We assume all ETIME returns are valid.
//
// TODO: properly differentiate simultaneous notify+interrupt.
// In that case, we should propagate the notify to another waiter.

8
hotspot/src/os_cpu/linux_sparc/vm/os_linux_sparc.cpp
View File

@ -234,7 +234,7 @@ void os::print_context(outputStream *st, void *context) {
SIG_REGS(sc).u_regs[CON_G3],
SIG_REGS(sc).u_regs[CON_G4]);
st->print_cr(" G5=" INTPTR_FORMAT " G6=" INTPTR_FORMAT
" G7=" INTPTR_FORMAT " Y=" INTPTR_FORMAT,
" G7=" INTPTR_FORMAT " Y=0x%x",
SIG_REGS(sc).u_regs[CON_G5],
SIG_REGS(sc).u_regs[CON_G6],
SIG_REGS(sc).u_regs[CON_G7],
@ -285,7 +285,7 @@ void os::print_context(outputStream *st, void *context) {
st->cr();
st->cr();
st->print_cr("Top of Stack: (sp=" PTR_FORMAT ")", sp);
st->print_cr("Top of Stack: (sp=" INTPTR_FORMAT ")", p2i(sp));
print_hex_dump(st, (address)sp, (address)(sp + 32), sizeof(intptr_t));
st->cr();
@ -293,7 +293,7 @@ void os::print_context(outputStream *st, void *context) {
// point to garbage if entry point in an nmethod is corrupted. Leave
// this at the end, and hope for the best.
address pc = os::Linux::ucontext_get_pc(uc);
st->print_cr("Instructions: (pc=" PTR_FORMAT ")", pc);
st->print_cr("Instructions: (pc=" INTPTR_FORMAT ")", p2i(pc));
print_hex_dump(st, pc - 32, pc + 32, sizeof(char));
}
@ -453,7 +453,7 @@ inline static bool checkVerifyOops(address pc, address fault, address* stub) {
&& pc < MacroAssembler::_verify_oop_implicit_branch[1] ) {
*stub = MacroAssembler::_verify_oop_implicit_branch[2];
warning("fixed up memory fault in +VerifyOops at address "
INTPTR_FORMAT, fault);
INTPTR_FORMAT, p2i(fault));
return true;
}
return false;

2
hotspot/src/os_cpu/linux_sparc/vm/vm_version_linux_sparc.cpp
View File

@ -36,7 +36,7 @@ static bool detect_niagara() {
}
while (!feof(fp)) {
if (fscanf(fp, "cpu\t\t: %100[^\n]", &cpu) == 1) {
if (fscanf(fp, "cpu\t\t: %100[^\n]", cpu) == 1) {
if (strstr(cpu, "Niagara") != NULL) {
rv = true;
}

17
hotspot/src/os_cpu/solaris_sparc/vm/vm_version_solaris_sparc.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2006, 2012, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2006, 2014, 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
@ -137,6 +137,21 @@ int VM_Version::platform_features(int features) {
#endif
if (av & AV_SPARC_AES) features |= aes_instructions_m;
#ifndef AV_SPARC_SHA1
#define AV_SPARC_SHA1 0x00400000 /* sha1 instruction supported */
#endif
if (av & AV_SPARC_SHA1) features |= sha1_instruction_m;
#ifndef AV_SPARC_SHA256
#define AV_SPARC_SHA256 0x00800000 /* sha256 instruction supported */
#endif
if (av & AV_SPARC_SHA256) features |= sha256_instruction_m;
#ifndef AV_SPARC_SHA512
#define AV_SPARC_SHA512 0x01000000 /* sha512 instruction supported */
#endif
if (av & AV_SPARC_SHA512) features |= sha512_instruction_m;
} else {
// getisax(2) failed, use the old legacy code.
#ifndef PRODUCT

36
hotspot/src/share/vm/adlc/output_c.cpp
View File

@ -1000,7 +1000,7 @@ void ArchDesc::build_pipe_classes(FILE *fp_cpp) {
fprintf(fp_cpp, "void Bundle::initialize_nops(MachNode * nop_list[%d], Compile *C) {\n", nopcnt);
int i = 0;
for ( _pipeline->_noplist.reset(); (nop = _pipeline->_noplist.iter()) != NULL; i++ ) {
fprintf(fp_cpp, " nop_list[%d] = (MachNode *) new (C) %sNode();\n", i, nop);
fprintf(fp_cpp, " nop_list[%d] = (MachNode *) new %sNode();\n", i, nop);
}
fprintf(fp_cpp, "};\n\n");
fprintf(fp_cpp, "#ifndef PRODUCT\n");
@ -1328,7 +1328,7 @@ static void generate_peepreplace( FILE *fp, FormDict &globals, PeepMatch *pmatch
preplace->next_instruction(root_inst);
InstructForm *root_form = globals[root_inst]->is_instruction();
assert( root_form != NULL, "Replacement instruction was not previously defined");
fprintf(fp, " %sNode *root = new (C) %sNode();\n", root_inst, root_inst);
fprintf(fp, " %sNode *root = new %sNode();\n", root_inst, root_inst);
int inst_num;
const char *op_name;
@ -1497,11 +1497,11 @@ void ArchDesc::defineExpand(FILE *fp, InstructForm *node) {
new_oper = frm->is_operand();
char *tmp = (char *)node->_exprule->_newopconst[new_id];
if (tmp == NULL) {
fprintf(fp," MachOper *op%d = new (C) %sOper();\n",
fprintf(fp," MachOper *op%d = new %sOper();\n",
cnt, new_oper->_ident);
}
else {
fprintf(fp," MachOper *op%d = new (C) %sOper(%s);\n",
fprintf(fp," MachOper *op%d = new %sOper(%s);\n",
cnt, new_oper->_ident, tmp);
}
}
@ -1566,7 +1566,7 @@ void ArchDesc::defineExpand(FILE *fp, InstructForm *node) {
}
// Build the node for the instruction
fprintf(fp,"\n %sNode *n%d = new (C) %sNode();\n", new_id, cnt, new_id);
fprintf(fp,"\n %sNode *n%d = new %sNode();\n", new_id, cnt, new_id);
// Add control edge for this node
fprintf(fp," n%d->add_req(_in[0]);\n", cnt);
// Build the operand for the value this node defines.
@ -1729,7 +1729,7 @@ void ArchDesc::defineExpand(FILE *fp, InstructForm *node) {
declared_def = true;
}
if (op && op->_interface && op->_interface->is_RegInterface()) {
fprintf(fp," def = new (C) MachTempNode(state->MachOperGenerator( %s, C ));\n",
fprintf(fp," def = new MachTempNode(state->MachOperGenerator( %s, C ));\n",
machOperEnum(op->_ident));
fprintf(fp," add_req(def);\n");
// The operand for TEMP is already constructed during
@ -1760,7 +1760,7 @@ void ArchDesc::defineExpand(FILE *fp, InstructForm *node) {
}
fprintf(fp," kill = ");
fprintf(fp,"new (C) MachProjNode( %s, %d, (%s), Op_%s );\n",
fprintf(fp,"new MachProjNode( %s, %d, (%s), Op_%s );\n",
machNode, proj_no++, regmask, ideal_type);
fprintf(fp," proj_list.push(kill);\n");
}
@ -2840,7 +2840,7 @@ static void defineIn_RegMask(FILE *fp, FormDict &globals, OperandForm &oper) {
// generate code to create a clone for a class derived from MachOper
//
// (0) MachOper *MachOperXOper::clone(Compile* C) const {
// (1) return new (C) MachXOper( _ccode, _c0, _c1, ..., _cn);
// (1) return new MachXOper( _ccode, _c0, _c1, ..., _cn);
// (2) }
//
static void defineClone(FILE *fp, FormDict &globalNames, OperandForm &oper) {
@ -2849,7 +2849,7 @@ static void defineClone(FILE *fp, FormDict &globalNames, OperandForm &oper) {
const int num_consts = oper.num_consts(globalNames);
const bool is_ideal_bool = oper.is_ideal_bool();
if( (num_consts > 0) ) {
fprintf(fp," return new (C) %sOper(", oper._ident);
fprintf(fp," return new %sOper(", oper._ident);
// generate parameters for constants
int i = 0;
fprintf(fp,"_c%d", i);
@ -2861,7 +2861,7 @@ static void defineClone(FILE *fp, FormDict &globalNames, OperandForm &oper) {
}
else {
assert( num_consts == 0, "Currently support zero or one constant per operand clone function");
fprintf(fp," return new (C) %sOper();\n", oper._ident);
fprintf(fp," return new %sOper();\n", oper._ident);
}
// finish method
fprintf(fp,"}\n");
@ -3106,7 +3106,7 @@ void ArchDesc::defineClasses(FILE *fp) {
defineIn_RegMask(_CPP_MISC_file._fp, _globalNames, *oper);
fprintf(fp,"MachOper *%sOper::clone(Compile* C) const {\n", oper->_ident);
fprintf(fp," return new (C) %sOper(_label, _block_num);\n", oper->_ident);
fprintf(fp," return new %sOper(_label, _block_num);\n", oper->_ident);
fprintf(fp,"}\n");
fprintf(fp,"uint %sOper::opcode() const { return %s; }\n",
@ -3125,7 +3125,7 @@ void ArchDesc::defineClasses(FILE *fp) {
defineIn_RegMask(_CPP_MISC_file._fp, _globalNames, *oper);
fprintf(fp,"MachOper *%sOper::clone(Compile* C) const {\n", oper->_ident);
fprintf(fp," return new (C) %sOper(_method);\n", oper->_ident);
fprintf(fp," return new %sOper(_method);\n", oper->_ident);
fprintf(fp,"}\n");
fprintf(fp,"uint %sOper::opcode() const { return %s; }\n",
@ -3815,7 +3815,7 @@ static void genMachOperCase(FILE *fp, FormDict &globalNames, ArchDesc &AD,
// Generate the case statement for this opcode
fprintf(fp, " case %s:", opEnumName);
fprintf(fp, "\n return new (C) %sOper(", opName);
fprintf(fp, "\n return new %sOper(", opName);
// Access parameters for constructor from the stat object
//
// Build access to condition code value
@ -3894,7 +3894,7 @@ void ArchDesc::buildMachNode(FILE *fp_cpp, InstructForm *inst, const char *inden
const char *opClass = inst->_ident;
// Create the MachNode object
fprintf(fp_cpp, "%s %sNode *node = new (C) %sNode();\n",indent, opClass,opClass);
fprintf(fp_cpp, "%s %sNode *node = new %sNode();\n",indent, opClass,opClass);
if ( (inst->num_post_match_opnds() != 0) ) {
// Instruction that contains operands which are not in match rule.
@ -3936,7 +3936,7 @@ void ArchDesc::buildMachNode(FILE *fp_cpp, InstructForm *inst, const char *inden
// Check for multiple constants and then fill them in.
// Just like MachOperGenerator
const char *opName = inst->_matrule->_rChild->_opType;
fprintf(fp_cpp, "new (C) %sOper(", opName);
fprintf(fp_cpp, "new %sOper(", opName);
// Grab operand form
OperandForm *op = (_globalNames[opName])->is_operand();
// Look up the number of constants
@ -4010,7 +4010,7 @@ bool InstructForm::define_cisc_version(ArchDesc &AD, FILE *fp_cpp) {
fprintf(fp_cpp, "// Build CISC version of this instruction\n");
fprintf(fp_cpp, "MachNode *%sNode::cisc_version( int offset, Compile* C ) {\n", this->_ident);
// Create the MachNode object
fprintf(fp_cpp, " %sNode *node = new (C) %sNode();\n", name, name);
fprintf(fp_cpp, " %sNode *node = new %sNode();\n", name, name);
// Fill in the bottom_type where requested
if ( this->captures_bottom_type(AD.globalNames()) ) {
fprintf(fp_cpp, " node->_bottom_type = bottom_type();\n");
@ -4026,7 +4026,7 @@ bool InstructForm::define_cisc_version(ArchDesc &AD, FILE *fp_cpp) {
fprintf(fp_cpp, " fill_new_machnode(node, C);\n");
// Construct operand to access [stack_pointer + offset]
fprintf(fp_cpp, " // Construct operand to access [stack_pointer + offset]\n");
fprintf(fp_cpp, " node->set_opnd_array(cisc_operand(), new (C) %sOper(offset));\n", cisc_oper_name);
fprintf(fp_cpp, " node->set_opnd_array(cisc_operand(), new %sOper(offset));\n", cisc_oper_name);
fprintf(fp_cpp, "\n");
// Return result and exit scope
@ -4057,7 +4057,7 @@ bool InstructForm::define_short_branch_methods(ArchDesc &AD, FILE *fp_cpp) {
fprintf(fp_cpp, "// Build short branch version of this instruction\n");
fprintf(fp_cpp, "MachNode *%sNode::short_branch_version(Compile* C) {\n", this->_ident);
// Create the MachNode object
fprintf(fp_cpp, " %sNode *node = new (C) %sNode();\n", name, name);
fprintf(fp_cpp, " %sNode *node = new %sNode();\n", name, name);
if( is_ideal_if() ) {
fprintf(fp_cpp, " node->_prob = _prob;\n");
fprintf(fp_cpp, " node->_fcnt = _fcnt;\n");

2
hotspot/src/share/vm/c1/c1_GraphBuilder.cpp
View File

@ -2054,7 +2054,7 @@ void GraphBuilder::new_instance(int klass_index) {
bool will_link;
ciKlass* klass = stream()->get_klass(will_link);
assert(klass->is_instance_klass(), "must be an instance klass");
NewInstance* new_instance = new NewInstance(klass->as_instance_klass(), state_before);
NewInstance* new_instance = new NewInstance(klass->as_instance_klass(), state_before, stream()->is_unresolved_klass());
_memory->new_instance(new_instance);
apush(append_split(new_instance));
}

6
hotspot/src/share/vm/c1/c1_Instruction.hpp
View File

@ -1291,16 +1291,18 @@ LEAF(Invoke, StateSplit)
LEAF(NewInstance, StateSplit)
private:
ciInstanceKlass* _klass;
bool _is_unresolved;
public:
// creation
NewInstance(ciInstanceKlass* klass, ValueStack* state_before)
NewInstance(ciInstanceKlass* klass, ValueStack* state_before, bool is_unresolved)
: StateSplit(instanceType, state_before)
, _klass(klass)
, _klass(klass), _is_unresolved(is_unresolved)
{}
// accessors
ciInstanceKlass* klass() const { return _klass; }
bool is_unresolved() const { return _is_unresolved; }
virtual bool needs_exception_state() const { return false; }

1
hotspot/src/share/vm/c1/c1_LIRAssembler.cpp
View File

@ -336,7 +336,6 @@ void LIR_Assembler::check_no_unbound_labels() {
void LIR_Assembler::add_debug_info_for_branch(CodeEmitInfo* info) {
_masm->code_section()->relocate(pc(), relocInfo::poll_type);
int pc_offset = code_offset();
flush_debug_info(pc_offset);
info->record_debug_info(compilation()->debug_info_recorder(), pc_offset);

20
hotspot/src/share/vm/c1/c1_LIRGenerator.cpp
View File

@ -466,8 +466,11 @@ CodeEmitInfo* LIRGenerator::state_for(Instruction* x) {
}
void LIRGenerator::klass2reg_with_patching(LIR_Opr r, ciMetadata* obj, CodeEmitInfo* info) {
if (!obj->is_loaded() || PatchALot) {
void LIRGenerator::klass2reg_with_patching(LIR_Opr r, ciMetadata* obj, CodeEmitInfo* info, bool need_resolve) {
/* C2 relies on constant pool entries being resolved (ciTypeFlow), so if TieredCompilation
* is active and the class hasn't yet been resolved we need to emit a patch that resolves
* the class. */
if ((TieredCompilation && need_resolve) || !obj->is_loaded() || PatchALot) {
assert(info != NULL, "info must be set if class is not loaded");
__ klass2reg_patch(NULL, r, info);
} else {
@ -660,9 +663,18 @@ void LIRGenerator::monitor_exit(LIR_Opr object, LIR_Opr lock, LIR_Opr new_hdr, L
__ unlock_object(hdr, object, lock, scratch, slow_path);
}
#ifndef PRODUCT
void LIRGenerator::print_if_not_loaded(const NewInstance* new_instance) {
if (PrintNotLoaded && !new_instance->klass()->is_loaded()) {
tty->print_cr(" ###class not loaded at new bci %d", new_instance->printable_bci());
} else if (PrintNotLoaded && (TieredCompilation && new_instance->is_unresolved())) {
tty->print_cr(" ###class not resolved at new bci %d", new_instance->printable_bci());
}
}
#endif
void LIRGenerator::new_instance(LIR_Opr dst, ciInstanceKlass* klass, LIR_Opr scratch1, LIR_Opr scratch2, LIR_Opr scratch3, LIR_Opr scratch4, LIR_Opr klass_reg, CodeEmitInfo* info) {
klass2reg_with_patching(klass_reg, klass, info);
void LIRGenerator::new_instance(LIR_Opr dst, ciInstanceKlass* klass, bool is_unresolved, LIR_Opr scratch1, LIR_Opr scratch2, LIR_Opr scratch3, LIR_Opr scratch4, LIR_Opr klass_reg, CodeEmitInfo* info) {
klass2reg_with_patching(klass_reg, klass, info, is_unresolved);
// If klass is not loaded we do not know if the klass has finalizers:
if (UseFastNewInstance && klass->is_loaded()
&& !Klass::layout_helper_needs_slow_path(klass->layout_helper())) {

6
hotspot/src/share/vm/c1/c1_LIRGenerator.hpp
View File

@ -169,6 +169,8 @@ class LIRGenerator: public InstructionVisitor, public BlockClosure {
return this;
}
void print_if_not_loaded(const NewInstance* new_instance) PRODUCT_RETURN;
#ifdef ASSERT
LIR_List* lir(const char * file, int line) const {
_lir->set_file_and_line(file, line);
@ -307,7 +309,7 @@ class LIRGenerator: public InstructionVisitor, public BlockClosure {
void store_stack_parameter (LIR_Opr opr, ByteSize offset_from_sp_in_bytes);
void klass2reg_with_patching(LIR_Opr r, ciMetadata* obj, CodeEmitInfo* info);
void klass2reg_with_patching(LIR_Opr r, ciMetadata* obj, CodeEmitInfo* info, bool need_resolve = false);
// this loads the length and compares against the index
void array_range_check (LIR_Opr array, LIR_Opr index, CodeEmitInfo* null_check_info, CodeEmitInfo* range_check_info);
@ -325,7 +327,7 @@ class LIRGenerator: public InstructionVisitor, public BlockClosure {
void monitor_enter (LIR_Opr object, LIR_Opr lock, LIR_Opr hdr, LIR_Opr scratch, int monitor_no, CodeEmitInfo* info_for_exception, CodeEmitInfo* info);
void monitor_exit (LIR_Opr object, LIR_Opr lock, LIR_Opr hdr, LIR_Opr scratch, int monitor_no);
void new_instance (LIR_Opr dst, ciInstanceKlass* klass, LIR_Opr scratch1, LIR_Opr scratch2, LIR_Opr scratch3, LIR_Opr scratch4, LIR_Opr klass_reg, CodeEmitInfo* info);
void new_instance (LIR_Opr dst, ciInstanceKlass* klass, bool is_unresolved, LIR_Opr scratch1, LIR_Opr scratch2, LIR_Opr scratch3, LIR_Opr scratch4, LIR_Opr klass_reg, CodeEmitInfo* info);
// machine dependent
void cmp_mem_int(LIR_Condition condition, LIR_Opr base, int disp, int c, CodeEmitInfo* info);

30
hotspot/src/share/vm/c1/c1_Runtime1.cpp
View File

@ -123,24 +123,24 @@ int Runtime1::_throw_incompatible_class_change_error_count = 0;
int Runtime1::_throw_array_store_exception_count = 0;
int Runtime1::_throw_count = 0;
static int _byte_arraycopy_cnt = 0;
static int _short_arraycopy_cnt = 0;
static int _int_arraycopy_cnt = 0;
static int _long_arraycopy_cnt = 0;
static int _oop_arraycopy_cnt = 0;
static int _byte_arraycopy_stub_cnt = 0;
static int _short_arraycopy_stub_cnt = 0;
static int _int_arraycopy_stub_cnt = 0;
static int _long_arraycopy_stub_cnt = 0;
static int _oop_arraycopy_stub_cnt = 0;
address Runtime1::arraycopy_count_address(BasicType type) {
switch (type) {
case T_BOOLEAN:
case T_BYTE: return (address)&_byte_arraycopy_cnt;
case T_BYTE: return (address)&_byte_arraycopy_stub_cnt;
case T_CHAR:
case T_SHORT: return (address)&_short_arraycopy_cnt;
case T_SHORT: return (address)&_short_arraycopy_stub_cnt;
case T_FLOAT:
case T_INT: return (address)&_int_arraycopy_cnt;
case T_INT: return (address)&_int_arraycopy_stub_cnt;
case T_DOUBLE:
case T_LONG: return (address)&_long_arraycopy_cnt;
case T_LONG: return (address)&_long_arraycopy_stub_cnt;
case T_ARRAY:
case T_OBJECT: return (address)&_oop_arraycopy_cnt;
case T_OBJECT: return (address)&_oop_arraycopy_stub_cnt;
default:
ShouldNotReachHere();
return NULL;
@ -1479,13 +1479,13 @@ void Runtime1::print_statistics() {
tty->print_cr(" _ic_miss_cnt: %d", SharedRuntime::_ic_miss_ctr);
tty->print_cr(" _generic_arraycopy_cnt: %d", _generic_arraycopy_cnt);
tty->print_cr(" _generic_arraycopystub_cnt: %d", _generic_arraycopystub_cnt);
tty->print_cr(" _byte_arraycopy_cnt: %d", _byte_arraycopy_cnt);
tty->print_cr(" _short_arraycopy_cnt: %d", _short_arraycopy_cnt);
tty->print_cr(" _int_arraycopy_cnt: %d", _int_arraycopy_cnt);
tty->print_cr(" _long_arraycopy_cnt: %d", _long_arraycopy_cnt);
tty->print_cr(" _byte_arraycopy_cnt: %d", _byte_arraycopy_stub_cnt);
tty->print_cr(" _short_arraycopy_cnt: %d", _short_arraycopy_stub_cnt);
tty->print_cr(" _int_arraycopy_cnt: %d", _int_arraycopy_stub_cnt);
tty->print_cr(" _long_arraycopy_cnt: %d", _long_arraycopy_stub_cnt);
tty->print_cr(" _primitive_arraycopy_cnt: %d", _primitive_arraycopy_cnt);
tty->print_cr(" _oop_arraycopy_cnt (C): %d", Runtime1::_oop_arraycopy_cnt);
tty->print_cr(" _oop_arraycopy_cnt (stub): %d", _oop_arraycopy_cnt);
tty->print_cr(" _oop_arraycopy_cnt (stub): %d", _oop_arraycopy_stub_cnt);
tty->print_cr(" _arraycopy_slowcase_cnt: %d", _arraycopy_slowcase_cnt);
tty->print_cr(" _arraycopy_checkcast_cnt: %d", _arraycopy_checkcast_cnt);
tty->print_cr(" _arraycopy_checkcast_attempt_cnt:%d", _arraycopy_checkcast_attempt_cnt);

20
hotspot/src/share/vm/classfile/vmSymbols.hpp
View File

@ -790,6 +790,26 @@
do_name( decrypt_name, "decrypt") \
do_signature(byteArray_int_int_byteArray_int_signature, "([BII[BI)I") \
\
/* support for sun.security.provider.SHA */ \
do_class(sun_security_provider_sha, "sun/security/provider/SHA") \
do_intrinsic(_sha_implCompress, sun_security_provider_sha, implCompress_name, implCompress_signature, F_R) \
do_name( implCompress_name, "implCompress") \
do_signature(implCompress_signature, "([BI)V") \
\
/* support for sun.security.provider.SHA2 */ \
do_class(sun_security_provider_sha2, "sun/security/provider/SHA2") \
do_intrinsic(_sha2_implCompress, sun_security_provider_sha2, implCompress_name, implCompress_signature, F_R) \
\
/* support for sun.security.provider.SHA5 */ \
do_class(sun_security_provider_sha5, "sun/security/provider/SHA5") \
do_intrinsic(_sha5_implCompress, sun_security_provider_sha5, implCompress_name, implCompress_signature, F_R) \
\
/* support for sun.security.provider.DigestBase */ \
do_class(sun_security_provider_digestbase, "sun/security/provider/DigestBase") \
do_intrinsic(_digestBase_implCompressMB, sun_security_provider_digestbase, implCompressMB_name, implCompressMB_signature, F_R) \
do_name( implCompressMB_name, "implCompressMultiBlock") \
do_signature(implCompressMB_signature, "([BII)I") \
\
/* support for java.util.zip */ \
do_class(java_util_zip_CRC32, "java/util/zip/CRC32") \
do_intrinsic(_updateCRC32, java_util_zip_CRC32, update_name, int2_int_signature, F_SN) \

12
hotspot/src/share/vm/code/relocInfo.cpp
View File

@ -877,11 +877,7 @@ address external_word_Relocation::target() {
void internal_word_Relocation::fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest) {
address target = _target;
if (target == NULL) {
if (addr_in_const()) {
target = new_addr_for(*(address*)addr(), src, dest);
} else {
target = new_addr_for(pd_get_address_from_code(), src, dest);
}
target = new_addr_for(this->target(), src, dest);
}
set_value(target);
}
@ -890,7 +886,11 @@ void internal_word_Relocation::fix_relocation_after_move(const CodeBuffer* src,
address internal_word_Relocation::target() {
address target = _target;
if (target == NULL) {
target = pd_get_address_from_code();
if (addr_in_const()) {
target = *(address*)addr();
} else {
target = pd_get_address_from_code();
}
}
return target;
}

11
hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.cpp
View File

@ -1341,13 +1341,14 @@ bool CMSAdaptiveSizePolicy::get_and_clear_first_after_collection() {
bool CMSAdaptiveSizePolicy::print_adaptive_size_policy_on(
outputStream* st) const {
if (!UseAdaptiveSizePolicy) return false;
if (!UseAdaptiveSizePolicy) {
return false;
}
GenCollectedHeap* gch = GenCollectedHeap::heap();
Generation* gen0 = gch->get_gen(0);
DefNewGeneration* def_new = gen0->as_DefNewGeneration();
return
AdaptiveSizePolicy::print_adaptive_size_policy_on(
Generation* young = gch->get_gen(0);
DefNewGeneration* def_new = young->as_DefNewGeneration();
return AdaptiveSizePolicy::print_adaptive_size_policy_on(
st,
def_new->tenuring_threshold());
}

10
hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.cpp
View File

@ -60,21 +60,21 @@ void ConcurrentMarkSweepPolicy::initialize_generations() {
if (UseParNewGC) {
if (UseAdaptiveSizePolicy) {
_generations[0] = new GenerationSpec(Generation::ASParNew,
_initial_gen0_size, _max_gen0_size);
_initial_young_size, _max_young_size);
} else {
_generations[0] = new GenerationSpec(Generation::ParNew,
_initial_gen0_size, _max_gen0_size);
_initial_young_size, _max_young_size);
}
} else {
_generations[0] = new GenerationSpec(Generation::DefNew,
_initial_gen0_size, _max_gen0_size);
_initial_young_size, _max_young_size);
}
if (UseAdaptiveSizePolicy) {
_generations[1] = new GenerationSpec(Generation::ASConcurrentMarkSweep,
_initial_gen1_size, _max_gen1_size);
_initial_old_size, _max_old_size);
} else {
_generations[1] = new GenerationSpec(Generation::ConcurrentMarkSweep,
_initial_gen1_size, _max_gen1_size);
_initial_old_size, _max_old_size);
}
if (_generations[0] == NULL || _generations[1] == NULL) {

4
hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp
View File

@ -1138,8 +1138,8 @@ static inline size_t percent_of_space(Space* space, HeapWord* addr)
void CMSCollector::icms_update_allocation_limits()
{
Generation* gen0 = GenCollectedHeap::heap()->get_gen(0);
EdenSpace* eden = gen0->as_DefNewGeneration()->eden();
Generation* young = GenCollectedHeap::heap()->get_gen(0);
EdenSpace* eden = young->as_DefNewGeneration()->eden();
const unsigned int duty_cycle = stats().icms_update_duty_cycle();
if (CMSTraceIncrementalPacing) {

5
hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp
View File

@ -1193,10 +1193,9 @@ class ConcurrentMarkSweepGeneration: public CardGeneration {
// Does a "full" (forced) collection invoked on this generation collect
// all younger generations as well? Note that the second conjunct is a
// hack to allow the collection of the younger gen first if the flag is
// set. This is better than using th policy's should_collect_gen0_first()
// since that causes us to do an extra unnecessary pair of restart-&-stop-world.
// set.
virtual bool full_collects_younger_generations() const {
return UseCMSCompactAtFullCollection && !CollectGen0First;
return UseCMSCompactAtFullCollection && !ScavengeBeforeFullGC;
}
void space_iterate(SpaceClosure* blk, bool usedOnly = false);

2
hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp
View File

@ -3622,7 +3622,7 @@ void G1CollectedHeap::gc_threads_do(ThreadClosure* tc) const {
void G1CollectedHeap::print_tracing_info() const {
// We'll overload this to mean "trace GC pause statistics."
if (TraceGen0Time || TraceGen1Time) {
if (TraceYoungGenTime || TraceOldGenTime) {
// The "G1CollectorPolicy" is keeping track of these stats, so delegate
// to that.
g1_policy()->print_tracing_info();

56
hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp
View File

@ -809,7 +809,7 @@ void G1CollectorPolicy::record_full_collection_end() {
double full_gc_time_sec = end_sec - _full_collection_start_sec;
double full_gc_time_ms = full_gc_time_sec * 1000.0;
_trace_gen1_time_data.record_full_collection(full_gc_time_ms);
_trace_old_gen_time_data.record_full_collection(full_gc_time_ms);
update_recent_gc_times(end_sec, full_gc_time_ms);
@ -851,7 +851,7 @@ void G1CollectorPolicy::record_collection_pause_start(double start_time_sec) {
_g1->used(), _g1->recalculate_used()));
double s_w_t_ms = (start_time_sec - _stop_world_start) * 1000.0;
_trace_gen0_time_data.record_start_collection(s_w_t_ms);
_trace_young_gen_time_data.record_start_collection(s_w_t_ms);
_stop_world_start = 0.0;
record_heap_size_info_at_start(false /* full */);
@ -906,7 +906,7 @@ void G1CollectorPolicy::record_concurrent_mark_cleanup_completed() {
void G1CollectorPolicy::record_concurrent_pause() {
if (_stop_world_start > 0.0) {
double yield_ms = (os::elapsedTime() - _stop_world_start) * 1000.0;
_trace_gen0_time_data.record_yield_time(yield_ms);
_trace_young_gen_time_data.record_yield_time(yield_ms);
}
}
@ -993,7 +993,7 @@ void G1CollectorPolicy::record_collection_pause_end(double pause_time_ms, Evacua
evacuation_info.set_bytes_copied(_bytes_copied_during_gc);
if (update_stats) {
_trace_gen0_time_data.record_end_collection(pause_time_ms, phase_times());
_trace_young_gen_time_data.record_end_collection(pause_time_ms, phase_times());
// this is where we update the allocation rate of the application
double app_time_ms =
(phase_times()->cur_collection_start_sec() * 1000.0 - _prev_collection_pause_end_ms);
@ -1415,8 +1415,8 @@ size_t G1CollectorPolicy::expansion_amount() {
}
void G1CollectorPolicy::print_tracing_info() const {
_trace_gen0_time_data.print();
_trace_gen1_time_data.print();
_trace_young_gen_time_data.print();
_trace_old_gen_time_data.print();
}
void G1CollectorPolicy::print_yg_surv_rate_info() const {
@ -1973,9 +1973,9 @@ void G1CollectorPolicy::finalize_cset(double target_pause_time_ms, EvacuationInf
_last_gc_was_young = gcs_are_young() ? true : false;
if (_last_gc_was_young) {
_trace_gen0_time_data.increment_young_collection_count();
_trace_young_gen_time_data.increment_young_collection_count();
} else {
_trace_gen0_time_data.increment_mixed_collection_count();
_trace_young_gen_time_data.increment_mixed_collection_count();
}
// The young list is laid with the survivor regions from the previous
@ -2156,20 +2156,20 @@ void G1CollectorPolicy::finalize_cset(double target_pause_time_ms, EvacuationInf
evacuation_info.set_collectionset_regions(cset_region_length());
}
void TraceGen0TimeData::record_start_collection(double time_to_stop_the_world_ms) {
if(TraceGen0Time) {
void TraceYoungGenTimeData::record_start_collection(double time_to_stop_the_world_ms) {
if(TraceYoungGenTime) {
_all_stop_world_times_ms.add(time_to_stop_the_world_ms);
}
}
void TraceGen0TimeData::record_yield_time(double yield_time_ms) {
if(TraceGen0Time) {
void TraceYoungGenTimeData::record_yield_time(double yield_time_ms) {
if(TraceYoungGenTime) {
_all_yield_times_ms.add(yield_time_ms);
}
}
void TraceGen0TimeData::record_end_collection(double pause_time_ms, G1GCPhaseTimes* phase_times) {
if(TraceGen0Time) {
void TraceYoungGenTimeData::record_end_collection(double pause_time_ms, G1GCPhaseTimes* phase_times) {
if(TraceYoungGenTime) {
_total.add(pause_time_ms);
_other.add(pause_time_ms - phase_times->accounted_time_ms());
_root_region_scan_wait.add(phase_times->root_region_scan_wait_time_ms());
@ -2194,34 +2194,34 @@ void TraceGen0TimeData::record_end_collection(double pause_time_ms, G1GCPhaseTim
}
}
void TraceGen0TimeData::increment_young_collection_count() {
if(TraceGen0Time) {
void TraceYoungGenTimeData::increment_young_collection_count() {
if(TraceYoungGenTime) {
++_young_pause_num;
}
}
void TraceGen0TimeData::increment_mixed_collection_count() {
if(TraceGen0Time) {
void TraceYoungGenTimeData::increment_mixed_collection_count() {
if(TraceYoungGenTime) {
++_mixed_pause_num;
}
}
void TraceGen0TimeData::print_summary(const char* str,
const NumberSeq* seq) const {
void TraceYoungGenTimeData::print_summary(const char* str,
const NumberSeq* seq) const {
double sum = seq->sum();
gclog_or_tty->print_cr("%-27s = %8.2lf s (avg = %8.2lf ms)",
str, sum / 1000.0, seq->avg());
}
void TraceGen0TimeData::print_summary_sd(const char* str,
const NumberSeq* seq) const {
void TraceYoungGenTimeData::print_summary_sd(const char* str,
const NumberSeq* seq) const {
print_summary(str, seq);
gclog_or_tty->print_cr("%+45s = %5d, std dev = %8.2lf ms, max = %8.2lf ms)",
"(num", seq->num(), seq->sd(), seq->maximum());
}
void TraceGen0TimeData::print() const {
if (!TraceGen0Time) {
void TraceYoungGenTimeData::print() const {
if (!TraceYoungGenTime) {
return;
}
@ -2258,14 +2258,14 @@ void TraceGen0TimeData::print() const {
print_summary_sd(" Yields", &_all_yield_times_ms);
}
void TraceGen1TimeData::record_full_collection(double full_gc_time_ms) {
if (TraceGen1Time) {
void TraceOldGenTimeData::record_full_collection(double full_gc_time_ms) {
if (TraceOldGenTime) {
_all_full_gc_times.add(full_gc_time_ms);
}
}
void TraceGen1TimeData::print() const {
if (!TraceGen1Time) {
void TraceOldGenTimeData::print() const {
if (!TraceOldGenTime) {
return;
}

30
hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp
View File

@ -38,10 +38,10 @@ class HeapRegion;
class CollectionSetChooser;
class G1GCPhaseTimes;
// TraceGen0Time collects data on _both_ young and mixed evacuation pauses
// TraceYoungGenTime collects data on _both_ young and mixed evacuation pauses
// (the latter may contain non-young regions - i.e. regions that are
// technically in Gen1) while TraceGen1Time collects data about full GCs.
class TraceGen0TimeData : public CHeapObj<mtGC> {
// technically in old) while TraceOldGenTime collects data about full GCs.
class TraceYoungGenTimeData : public CHeapObj<mtGC> {
private:
unsigned _young_pause_num;
unsigned _mixed_pause_num;
@ -66,7 +66,7 @@ class TraceGen0TimeData : public CHeapObj<mtGC> {
void print_summary_sd(const char* str, const NumberSeq* seq) const;
public:
TraceGen0TimeData() : _young_pause_num(0), _mixed_pause_num(0) {};
TraceYoungGenTimeData() : _young_pause_num(0), _mixed_pause_num(0) {};
void record_start_collection(double time_to_stop_the_world_ms);
void record_yield_time(double yield_time_ms);
void record_end_collection(double pause_time_ms, G1GCPhaseTimes* phase_times);
@ -75,7 +75,7 @@ public:
void print() const;
};
class TraceGen1TimeData : public CHeapObj<mtGC> {
class TraceOldGenTimeData : public CHeapObj<mtGC> {
private:
NumberSeq _all_full_gc_times;
@ -187,8 +187,8 @@ private:
TruncatedSeq* _concurrent_mark_remark_times_ms;
TruncatedSeq* _concurrent_mark_cleanup_times_ms;
TraceGen0TimeData _trace_gen0_time_data;
TraceGen1TimeData _trace_gen1_time_data;
TraceYoungGenTimeData _trace_young_gen_time_data;
TraceOldGenTimeData _trace_old_gen_time_data;
double _stop_world_start;
@ -202,20 +202,20 @@ private:
// locker is active. This should be >= _young_list_target_length;
uint _young_list_max_length;
bool _last_gc_was_young;
bool _last_gc_was_young;
bool _during_marking;
bool _in_marking_window;
bool _in_marking_window_im;
bool _during_marking;
bool _in_marking_window;
bool _in_marking_window_im;
SurvRateGroup* _short_lived_surv_rate_group;
SurvRateGroup* _survivor_surv_rate_group;
SurvRateGroup* _short_lived_surv_rate_group;
SurvRateGroup* _survivor_surv_rate_group;
// add here any more surv rate groups
double _gc_overhead_perc;
double _gc_overhead_perc;
double _reserve_factor;
uint _reserve_regions;
uint _reserve_regions;
bool during_marking() {
return _during_marking;

16
hotspot/src/share/vm/gc_implementation/parallelScavenge/adjoiningGenerations.cpp
View File

@ -35,14 +35,14 @@
AdjoiningGenerations::AdjoiningGenerations(ReservedSpace old_young_rs,
GenerationSizer* policy,
size_t alignment) :
_virtual_spaces(old_young_rs, policy->min_gen1_size(),
policy->min_gen0_size(), alignment) {
size_t init_low_byte_size = policy->initial_gen1_size();
size_t min_low_byte_size = policy->min_gen1_size();
size_t max_low_byte_size = policy->max_gen1_size();
size_t init_high_byte_size = policy->initial_gen0_size();
size_t min_high_byte_size = policy->min_gen0_size();
size_t max_high_byte_size = policy->max_gen0_size();
_virtual_spaces(old_young_rs, policy->min_old_size(),
policy->min_young_size(), alignment) {
size_t init_low_byte_size = policy->initial_old_size();
size_t min_low_byte_size = policy->min_old_size();
size_t max_low_byte_size = policy->max_old_size();
size_t init_high_byte_size = policy->initial_young_size();
size_t min_high_byte_size = policy->min_young_size();
size_t max_high_byte_size = policy->max_young_size();
assert(min_low_byte_size <= init_low_byte_size &&
init_low_byte_size <= max_low_byte_size, "Parameter check");

4
hotspot/src/share/vm/gc_implementation/parallelScavenge/generationSizer.cpp
View File

@ -32,8 +32,8 @@ void GenerationSizer::trace_gen_sizes(const char* const str) {
SIZE_FORMAT "," SIZE_FORMAT " "
SIZE_FORMAT,
str,
_min_gen1_size / K, _max_gen1_size / K,
_min_gen0_size / K, _max_gen0_size / K,
_min_old_size / K, _max_old_size / K,
_min_young_size / K, _max_young_size / K,
_max_heap_byte_size / K);
}
}

4
hotspot/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp
View File

@ -623,11 +623,11 @@ void ParallelScavengeHeap::print_gc_threads_on(outputStream* st) const {
}
void ParallelScavengeHeap::print_tracing_info() const {
if (TraceGen0Time) {
if (TraceYoungGenTime) {
double time = PSScavenge::accumulated_time()->seconds();
tty->print_cr("[Accumulated GC generation 0 time %3.7f secs]", time);
}
if (TraceGen1Time) {
if (TraceOldGenTime) {
double time = UseParallelOldGC ? PSParallelCompact::accumulated_time()->seconds() : PSMarkSweep::accumulated_time()->seconds();
tty->print_cr("[Accumulated GC generation 1 time %3.7f secs]", time);
}

4
hotspot/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp
View File

@ -174,7 +174,7 @@ bool PSMarkSweep::invoke_no_policy(bool clear_all_softrefs) {
TraceCollectorStats tcs(counters());
TraceMemoryManagerStats tms(true /* Full GC */,gc_cause);
if (TraceGen1Time) accumulated_time()->start();
if (TraceOldGenTime) accumulated_time()->start();
// Let the size policy know we're starting
size_policy->major_collection_begin();
@ -354,7 +354,7 @@ bool PSMarkSweep::invoke_no_policy(bool clear_all_softrefs) {
// We collected the heap, recalculate the metaspace capacity
MetaspaceGC::compute_new_size();
if (TraceGen1Time) accumulated_time()->stop();
if (TraceOldGenTime) accumulated_time()->stop();
if (PrintGC) {
if (PrintGCDetails) {

4
hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp
View File

@ -2061,7 +2061,7 @@ bool PSParallelCompact::invoke_no_policy(bool maximum_heap_compaction) {
TraceCollectorStats tcs(counters());
TraceMemoryManagerStats tms(true /* Full GC */,gc_cause);
if (TraceGen1Time) accumulated_time()->start();
if (TraceOldGenTime) accumulated_time()->start();
// Let the size policy know we're starting
size_policy->major_collection_begin();
@ -2188,7 +2188,7 @@ bool PSParallelCompact::invoke_no_policy(bool maximum_heap_compaction) {
// Resize the metaspace capacity after a collection
MetaspaceGC::compute_new_size();
if (TraceGen1Time) accumulated_time()->stop();
if (TraceOldGenTime) accumulated_time()->stop();
if (PrintGC) {
if (PrintGCDetails) {

4
hotspot/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp
View File

@ -336,7 +336,7 @@ bool PSScavenge::invoke_no_policy() {
TraceCollectorStats tcs(counters());
TraceMemoryManagerStats tms(false /* not full GC */,gc_cause);
if (TraceGen0Time) accumulated_time()->start();
if (TraceYoungGenTime) accumulated_time()->start();
// Let the size policy know we're starting
size_policy->minor_collection_begin();
@ -660,7 +660,7 @@ bool PSScavenge::invoke_no_policy() {
CardTableExtension::verify_all_young_refs_imprecise();
}
if (TraceGen0Time) accumulated_time()->stop();
if (TraceYoungGenTime) accumulated_time()->stop();
if (PrintGC) {
if (PrintGCDetails) {

267
hotspot/src/share/vm/memory/collectorPolicy.cpp
View File

@ -196,13 +196,13 @@ size_t CollectorPolicy::compute_heap_alignment() {
// GenCollectorPolicy methods
GenCollectorPolicy::GenCollectorPolicy() :
_min_gen0_size(0),
_initial_gen0_size(0),
_max_gen0_size(0),
_min_young_size(0),
_initial_young_size(0),
_max_young_size(0),
_gen_alignment(0),
_min_gen1_size(0),
_initial_gen1_size(0),
_max_gen1_size(0),
_min_old_size(0),
_initial_old_size(0),
_max_old_size(0),
_generations(NULL)
{}
@ -236,7 +236,7 @@ size_t GenCollectorPolicy::young_gen_size_lower_bound() {
#ifdef ASSERT
void GenCollectorPolicy::assert_flags() {
CollectorPolicy::assert_flags();
assert(NewSize >= _min_gen0_size, "Ergonomics decided on a too small young gen size");
assert(NewSize >= _min_young_size, "Ergonomics decided on a too small young gen size");
assert(NewSize <= MaxNewSize, "Ergonomics decided on incompatible initial and maximum young gen sizes");
assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize, "Ergonomics decided on incompatible maximum young gen and heap sizes");
assert(NewSize % _gen_alignment == 0, "NewSize alignment");
@ -249,28 +249,28 @@ void GenCollectorPolicy::assert_size_info() {
CollectorPolicy::assert_size_info();
// GenCollectorPolicy::initialize_size_info may update the MaxNewSize
assert(MaxNewSize < MaxHeapSize, "Ergonomics decided on incompatible maximum young and heap sizes");
assert(NewSize == _initial_gen0_size, "Discrepancy between NewSize flag and local storage");
assert(MaxNewSize == _max_gen0_size, "Discrepancy between MaxNewSize flag and local storage");
assert(OldSize == _initial_gen1_size, "Discrepancy between OldSize flag and local storage");
assert(_min_gen0_size <= _initial_gen0_size, "Ergonomics decided on incompatible minimum and initial young gen sizes");
assert(_initial_gen0_size <= _max_gen0_size, "Ergonomics decided on incompatible initial and maximum young gen sizes");
assert(_min_gen0_size % _gen_alignment == 0, "_min_gen0_size alignment");
assert(_initial_gen0_size % _gen_alignment == 0, "_initial_gen0_size alignment");
assert(_max_gen0_size % _gen_alignment == 0, "_max_gen0_size alignment");
assert(_min_gen0_size <= bound_minus_alignment(_min_gen0_size, _min_heap_byte_size),
assert(NewSize == _initial_young_size, "Discrepancy between NewSize flag and local storage");
assert(MaxNewSize == _max_young_size, "Discrepancy between MaxNewSize flag and local storage");
assert(OldSize == _initial_old_size, "Discrepancy between OldSize flag and local storage");
assert(_min_young_size <= _initial_young_size, "Ergonomics decided on incompatible minimum and initial young gen sizes");
assert(_initial_young_size <= _max_young_size, "Ergonomics decided on incompatible initial and maximum young gen sizes");
assert(_min_young_size % _gen_alignment == 0, "_min_young_size alignment");
assert(_initial_young_size % _gen_alignment == 0, "_initial_young_size alignment");
assert(_max_young_size % _gen_alignment == 0, "_max_young_size alignment");
assert(_min_young_size <= bound_minus_alignment(_min_young_size, _min_heap_byte_size),
"Ergonomics made minimum young generation larger than minimum heap");
assert(_initial_gen0_size <= bound_minus_alignment(_initial_gen0_size, _initial_heap_byte_size),
assert(_initial_young_size <= bound_minus_alignment(_initial_young_size, _initial_heap_byte_size),
"Ergonomics made initial young generation larger than initial heap");
assert(_max_gen0_size <= bound_minus_alignment(_max_gen0_size, _max_heap_byte_size),
assert(_max_young_size <= bound_minus_alignment(_max_young_size, _max_heap_byte_size),
"Ergonomics made maximum young generation lager than maximum heap");
assert(_min_gen1_size <= _initial_gen1_size, "Ergonomics decided on incompatible minimum and initial old gen sizes");
assert(_initial_gen1_size <= _max_gen1_size, "Ergonomics decided on incompatible initial and maximum old gen sizes");
assert(_max_gen1_size % _gen_alignment == 0, "_max_gen1_size alignment");
assert(_initial_gen1_size % _gen_alignment == 0, "_initial_gen1_size alignment");
assert(_max_heap_byte_size <= (_max_gen0_size + _max_gen1_size), "Total maximum heap sizes must be sum of generation maximum sizes");
assert(_min_gen0_size + _min_gen1_size <= _min_heap_byte_size, "Minimum generation sizes exceed minimum heap size");
assert(_initial_gen0_size + _initial_gen1_size == _initial_heap_byte_size, "Initial generation sizes should match initial heap size");
assert(_max_gen0_size + _max_gen1_size == _max_heap_byte_size, "Maximum generation sizes should match maximum heap size");
assert(_min_old_size <= _initial_old_size, "Ergonomics decided on incompatible minimum and initial old gen sizes");
assert(_initial_old_size <= _max_old_size, "Ergonomics decided on incompatible initial and maximum old gen sizes");
assert(_max_old_size % _gen_alignment == 0, "_max_old_size alignment");
assert(_initial_old_size % _gen_alignment == 0, "_initial_old_size alignment");
assert(_max_heap_byte_size <= (_max_young_size + _max_old_size), "Total maximum heap sizes must be sum of generation maximum sizes");
assert(_min_young_size + _min_old_size <= _min_heap_byte_size, "Minimum generation sizes exceed minimum heap size");
assert(_initial_young_size + _initial_old_size == _initial_heap_byte_size, "Initial generation sizes should match initial heap size");
assert(_max_young_size + _max_old_size == _max_heap_byte_size, "Maximum generation sizes should match maximum heap size");
}
#endif // ASSERT
@ -323,8 +323,8 @@ void GenCollectorPolicy::initialize_flags() {
// later when setting the initial and minimum young generation size.
NewSize = bounded_new_size;
}
_min_gen0_size = smallest_new_size;
_initial_gen0_size = NewSize;
_min_young_size = smallest_new_size;
_initial_young_size = NewSize;
if (!FLAG_IS_DEFAULT(MaxNewSize)) {
if (MaxNewSize >= MaxHeapSize) {
@ -338,14 +338,14 @@ void GenCollectorPolicy::initialize_flags() {
FLAG_SET_ERGO(uintx, MaxNewSize, smaller_max_new_size);
if (NewSize > MaxNewSize) {
FLAG_SET_ERGO(uintx, NewSize, MaxNewSize);
_initial_gen0_size = NewSize;
_initial_young_size = NewSize;
}
} else if (MaxNewSize < _initial_gen0_size) {
FLAG_SET_ERGO(uintx, MaxNewSize, _initial_gen0_size);
} else if (MaxNewSize < _initial_young_size) {
FLAG_SET_ERGO(uintx, MaxNewSize, _initial_young_size);
} else if (!is_size_aligned(MaxNewSize, _gen_alignment)) {
FLAG_SET_ERGO(uintx, MaxNewSize, align_size_down(MaxNewSize, _gen_alignment));
}
_max_gen0_size = MaxNewSize;
_max_young_size = MaxNewSize;
}
if (NewSize > MaxNewSize) {
@ -357,7 +357,7 @@ void GenCollectorPolicy::initialize_flags() {
NewSize/K, MaxNewSize/K, NewSize/K);
}
FLAG_SET_ERGO(uintx, MaxNewSize, NewSize);
_max_gen0_size = MaxNewSize;
_max_young_size = MaxNewSize;
}
if (SurvivorRatio < 1 || NewRatio < 1) {
@ -393,7 +393,7 @@ void GenCollectorPolicy::initialize_flags() {
double shrink_factor = (double) MaxHeapSize / calculated_size;
uintx smaller_new_size = align_size_down((uintx)(NewSize * shrink_factor), _gen_alignment);
FLAG_SET_ERGO(uintx, NewSize, MAX2(young_gen_size_lower_bound(), smaller_new_size));
_initial_gen0_size = NewSize;
_initial_young_size = NewSize;
// OldSize is already aligned because above we aligned MaxHeapSize to
// _heap_alignment, and we just made sure that NewSize is aligned to
@ -406,16 +406,16 @@ void GenCollectorPolicy::initialize_flags() {
}
}
// Update NewSize, if possible, to avoid sizing gen0 to small when only
// Update NewSize, if possible, to avoid sizing the young gen too small when only
// OldSize is set on the command line.
if (FLAG_IS_CMDLINE(OldSize) && !FLAG_IS_CMDLINE(NewSize)) {
if (OldSize < _initial_heap_byte_size) {
size_t new_size = _initial_heap_byte_size - OldSize;
// Need to compare against the flag value for max since _max_gen0_size
// Need to compare against the flag value for max since _max_young_size
// might not have been set yet.
if (new_size >= _min_gen0_size && new_size <= MaxNewSize) {
if (new_size >= _min_young_size && new_size <= MaxNewSize) {
FLAG_SET_ERGO(uintx, NewSize, new_size);
_initial_gen0_size = NewSize;
_initial_young_size = NewSize;
}
}
}
@ -444,97 +444,77 @@ void GenCollectorPolicy::initialize_flags() {
void GenCollectorPolicy::initialize_size_info() {
CollectorPolicy::initialize_size_info();
// _space_alignment is used for alignment within a generation.
// There is additional alignment done down stream for some
// collectors that sometimes causes unwanted rounding up of
// generations sizes.
_initial_young_size = NewSize;
_max_young_size = MaxNewSize;
_initial_old_size = OldSize;
// Determine maximum size of gen0
// Determine maximum size of the young generation.
size_t max_new_size = 0;
if (!FLAG_IS_DEFAULT(MaxNewSize)) {
max_new_size = MaxNewSize;
} else {
max_new_size = scale_by_NewRatio_aligned(_max_heap_byte_size);
if (FLAG_IS_DEFAULT(MaxNewSize)) {
_max_young_size = scale_by_NewRatio_aligned(_max_heap_byte_size);
// Bound the maximum size by NewSize below (since it historically
// would have been NewSize and because the NewRatio calculation could
// yield a size that is too small) and bound it by MaxNewSize above.
// Ergonomics plays here by previously calculating the desired
// NewSize and MaxNewSize.
max_new_size = MIN2(MAX2(max_new_size, NewSize), MaxNewSize);
_max_young_size = MIN2(MAX2(_max_young_size, _initial_young_size), MaxNewSize);
}
assert(max_new_size > 0, "All paths should set max_new_size");
// Given the maximum gen0 size, determine the initial and
// minimum gen0 sizes.
// Given the maximum young size, determine the initial and
// minimum young sizes.
if (_max_heap_byte_size == _initial_heap_byte_size) {
// The maxium and initial heap sizes are the same so the generation's
// The maximum and initial heap sizes are the same so the generation's
// initial size must be the same as it maximum size. Use NewSize as the
// size if set on command line.
size_t fixed_young_size = FLAG_IS_CMDLINE(NewSize) ? NewSize : max_new_size;
_initial_gen0_size = fixed_young_size;
_max_gen0_size = fixed_young_size;
_max_young_size = FLAG_IS_CMDLINE(NewSize) ? NewSize : _max_young_size;
_initial_young_size = _max_young_size;
// Also update the minimum size if min == initial == max.
if (_max_heap_byte_size == _min_heap_byte_size) {
_min_gen0_size = fixed_young_size;
_min_young_size = _max_young_size;
}
} else {
size_t desired_new_size = 0;
if (FLAG_IS_CMDLINE(NewSize)) {
// If NewSize is set on the command line, we should use it as
// the initial size, but make sure it is within the heap bounds.
desired_new_size =
MIN2(max_new_size, bound_minus_alignment(NewSize, _initial_heap_byte_size));
_min_gen0_size = bound_minus_alignment(desired_new_size, _min_heap_byte_size);
_initial_young_size =
MIN2(_max_young_size, bound_minus_alignment(NewSize, _initial_heap_byte_size));
_min_young_size = bound_minus_alignment(_initial_young_size, _min_heap_byte_size);
} else {
// For the case where NewSize is not set on the command line, use
// NewRatio to size the initial generation size. Use the current
// NewSize as the floor, because if NewRatio is overly large, the resulting
// size can be too small.
desired_new_size =
MIN2(max_new_size, MAX2(scale_by_NewRatio_aligned(_initial_heap_byte_size), NewSize));
_initial_young_size =
MIN2(_max_young_size, MAX2(scale_by_NewRatio_aligned(_initial_heap_byte_size), NewSize));
}
_initial_gen0_size = desired_new_size;
_max_gen0_size = max_new_size;
}
// Write back to flags if necessary.
if (NewSize != _initial_gen0_size) {
FLAG_SET_ERGO(uintx, NewSize, _initial_gen0_size);
}
if (MaxNewSize != _max_gen0_size) {
FLAG_SET_ERGO(uintx, MaxNewSize, _max_gen0_size);
}
if (PrintGCDetails && Verbose) {
gclog_or_tty->print_cr("1: Minimum gen0 " SIZE_FORMAT " Initial gen0 "
SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT,
_min_gen0_size, _initial_gen0_size, _max_gen0_size);
gclog_or_tty->print_cr("1: Minimum young " SIZE_FORMAT " Initial young "
SIZE_FORMAT " Maximum young " SIZE_FORMAT,
_min_young_size, _initial_young_size, _max_young_size);
}
// At this point the minimum, initial and maximum sizes
// of the overall heap and of gen0 have been determined.
// The maximum gen1 size can be determined from the maximum gen0
// of the overall heap and of the young generation have been determined.
// The maximum old size can be determined from the maximum young
// and maximum heap size since no explicit flags exist
// for setting the gen1 maximum.
_max_gen1_size = MAX2(_max_heap_byte_size - _max_gen0_size, _gen_alignment);
// for setting the old generation maximum.
_max_old_size = MAX2(_max_heap_byte_size - _max_young_size, _gen_alignment);
// If no explicit command line flag has been set for the
// gen1 size, use what is left for gen1
// old generation size, use what is left.
if (!FLAG_IS_CMDLINE(OldSize)) {
// The user has not specified any value but the ergonomics
// may have chosen a value (which may or may not be consistent
// with the overall heap size). In either case make
// the minimum, maximum and initial sizes consistent
// with the gen0 sizes and the overall heap sizes.
_min_gen1_size = _gen_alignment;
_initial_gen1_size = MIN2(_max_gen1_size, MAX2(_initial_heap_byte_size - _initial_gen0_size, _min_gen1_size));
// _max_gen1_size has already been made consistent above
FLAG_SET_ERGO(uintx, OldSize, _initial_gen1_size);
// with the young sizes and the overall heap sizes.
_min_old_size = _gen_alignment;
_initial_old_size = MIN2(_max_old_size, MAX2(_initial_heap_byte_size - _initial_young_size, _min_old_size));
// _max_old_size has already been made consistent above.
} else {
// OldSize has been explicitly set on the command line. Use it
// for the initial size but make sure the minimum allow a young
@ -543,69 +523,68 @@ void GenCollectorPolicy::initialize_size_info() {
// with other command line flags, issue a warning.
// The generation minimums and the overall heap minimum should
// be within one generation alignment.
if (OldSize > _max_gen1_size) {
if (_initial_old_size > _max_old_size) {
warning("Inconsistency between maximum heap size and maximum "
"generation sizes: using maximum heap = " SIZE_FORMAT
" -XX:OldSize flag is being ignored",
_max_heap_byte_size);
FLAG_SET_ERGO(uintx, OldSize, _max_gen1_size);
_initial_old_size = _max_old_size;
}
_min_gen1_size = MIN2(OldSize, _min_heap_byte_size - _min_gen0_size);
_initial_gen1_size = OldSize;
_min_old_size = MIN2(_initial_old_size, _min_heap_byte_size - _min_young_size);
}
// The initial generation sizes should match the initial heap size,
// if not issue a warning and resize the generations. This behavior
// differs from JDK8 where the generation sizes have higher priority
// than the initial heap size.
if ((_initial_gen1_size + _initial_gen0_size) != _initial_heap_byte_size) {
if ((_initial_old_size + _initial_young_size) != _initial_heap_byte_size) {
warning("Inconsistency between generation sizes and heap size, resizing "
"the generations to fit the heap.");
size_t desired_gen0_size = _initial_heap_byte_size - _initial_gen1_size;
if (_initial_heap_byte_size < _initial_gen1_size) {
size_t desired_young_size = _initial_heap_byte_size - _initial_old_size;
if (_initial_heap_byte_size < _initial_old_size) {
// Old want all memory, use minimum for young and rest for old
_initial_gen0_size = _min_gen0_size;
_initial_gen1_size = _initial_heap_byte_size - _min_gen0_size;
} else if (desired_gen0_size > _max_gen0_size) {
_initial_young_size = _min_young_size;
_initial_old_size = _initial_heap_byte_size - _min_young_size;
} else if (desired_young_size > _max_young_size) {
// Need to increase both young and old generation
_initial_gen0_size = _max_gen0_size;
_initial_gen1_size = _initial_heap_byte_size - _max_gen0_size;
} else if (desired_gen0_size < _min_gen0_size) {
_initial_young_size = _max_young_size;
_initial_old_size = _initial_heap_byte_size - _max_young_size;
} else if (desired_young_size < _min_young_size) {
// Need to decrease both young and old generation
_initial_gen0_size = _min_gen0_size;
_initial_gen1_size = _initial_heap_byte_size - _min_gen0_size;
_initial_young_size = _min_young_size;
_initial_old_size = _initial_heap_byte_size - _min_young_size;
} else {
// The young generation boundaries allow us to only update the
// young generation.
_initial_gen0_size = desired_gen0_size;
_initial_young_size = desired_young_size;
}
if (PrintGCDetails && Verbose) {
gclog_or_tty->print_cr("2: Minimum gen0 " SIZE_FORMAT " Initial gen0 "
SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT,
_min_gen0_size, _initial_gen0_size, _max_gen0_size);
gclog_or_tty->print_cr("2: Minimum young " SIZE_FORMAT " Initial young "
SIZE_FORMAT " Maximum young " SIZE_FORMAT,
_min_young_size, _initial_young_size, _max_young_size);
}
}
// Write back to flags if necessary
if (NewSize != _initial_gen0_size) {
FLAG_SET_ERGO(uintx, NewSize, _initial_gen0_size);
// Write back to flags if necessary.
if (NewSize != _initial_young_size) {
FLAG_SET_ERGO(uintx, NewSize, _initial_young_size);
}
if (MaxNewSize != _max_gen0_size) {
FLAG_SET_ERGO(uintx, MaxNewSize, _max_gen0_size);
if (MaxNewSize != _max_young_size) {
FLAG_SET_ERGO(uintx, MaxNewSize, _max_young_size);
}
if (OldSize != _initial_gen1_size) {
FLAG_SET_ERGO(uintx, OldSize, _initial_gen1_size);
if (OldSize != _initial_old_size) {
FLAG_SET_ERGO(uintx, OldSize, _initial_old_size);
}
if (PrintGCDetails && Verbose) {
gclog_or_tty->print_cr("Minimum gen1 " SIZE_FORMAT " Initial gen1 "
SIZE_FORMAT " Maximum gen1 " SIZE_FORMAT,
_min_gen1_size, _initial_gen1_size, _max_gen1_size);
gclog_or_tty->print_cr("Minimum old " SIZE_FORMAT " Initial old "
SIZE_FORMAT " Maximum old " SIZE_FORMAT,
_min_old_size, _initial_old_size, _max_old_size);
}
DEBUG_ONLY(GenCollectorPolicy::assert_size_info();)
@ -631,11 +610,11 @@ HeapWord* GenCollectorPolicy::mem_allocate_work(size_t size,
HandleMark hm; // Discard any handles allocated in each iteration.
// First allocation attempt is lock-free.
Generation *gen0 = gch->get_gen(0);
assert(gen0->supports_inline_contig_alloc(),
Generation *young = gch->get_gen(0);
assert(young->supports_inline_contig_alloc(),
"Otherwise, must do alloc within heap lock");
if (gen0->should_allocate(size, is_tlab)) {
result = gen0->par_allocate(size, is_tlab);
if (young->should_allocate(size, is_tlab)) {
result = young->par_allocate(size, is_tlab);
if (result != NULL) {
assert(gch->is_in_reserved(result), "result not in heap");
return result;
@ -917,8 +896,8 @@ MetaWord* CollectorPolicy::satisfy_failed_metadata_allocation(
bool GenCollectorPolicy::should_try_older_generation_allocation(
size_t word_size) const {
GenCollectedHeap* gch = GenCollectedHeap::heap();
size_t gen0_capacity = gch->get_gen(0)->capacity_before_gc();
return (word_size > heap_word_size(gen0_capacity))
size_t young_capacity = gch->get_gen(0)->capacity_before_gc();
return (word_size > heap_word_size(young_capacity))
|| GC_locker::is_active_and_needs_gc()
|| gch->incremental_collection_failed();
}
@ -940,11 +919,11 @@ void MarkSweepPolicy::initialize_generations() {
}
if (UseParNewGC) {
_generations[0] = new GenerationSpec(Generation::ParNew, _initial_gen0_size, _max_gen0_size);
_generations[0] = new GenerationSpec(Generation::ParNew, _initial_young_size, _max_young_size);
} else {
_generations[0] = new GenerationSpec(Generation::DefNew, _initial_gen0_size, _max_gen0_size);
_generations[0] = new GenerationSpec(Generation::DefNew, _initial_young_size, _max_young_size);
}
_generations[1] = new GenerationSpec(Generation::MarkSweepCompact, _initial_gen1_size, _max_gen1_size);
_generations[1] = new GenerationSpec(Generation::MarkSweepCompact, _initial_old_size, _max_old_size);
if (_generations[0] == NULL || _generations[1] == NULL) {
vm_exit_during_initialization("Unable to allocate gen spec");
@ -978,18 +957,18 @@ public:
flag_value = 20 * M;
set_basic_flag_values();
FLAG_SET_CMDLINE(uintx, NewSize, flag_value);
verify_gen0_min(flag_value);
verify_young_min(flag_value);
set_basic_flag_values();
FLAG_SET_CMDLINE(uintx, NewSize, flag_value);
verify_gen0_initial(flag_value);
verify_young_initial(flag_value);
// If NewSize is set on command line, but is larger than the min
// heap size, it should only be used for initial young size.
flag_value = 80 * M;
set_basic_flag_values();
FLAG_SET_CMDLINE(uintx, NewSize, flag_value);
verify_gen0_initial(flag_value);
verify_young_initial(flag_value);
// If NewSize has been ergonomically set, the collector policy
// should use it for min but calculate the initial young size
@ -997,11 +976,11 @@ public:
flag_value = 20 * M;
set_basic_flag_values();
FLAG_SET_ERGO(uintx, NewSize, flag_value);
verify_gen0_min(flag_value);
verify_young_min(flag_value);
set_basic_flag_values();
FLAG_SET_ERGO(uintx, NewSize, flag_value);
verify_scaled_gen0_initial(InitialHeapSize);
verify_scaled_young_initial(InitialHeapSize);
restore_flags();
}
@ -1016,11 +995,11 @@ public:
flag_value = 20 * M;
set_basic_flag_values();
FLAG_SET_CMDLINE(uintx, OldSize, flag_value);
verify_gen1_min(flag_value);
verify_old_min(flag_value);
set_basic_flag_values();
FLAG_SET_CMDLINE(uintx, OldSize, flag_value);
verify_gen1_initial(flag_value);
verify_old_initial(flag_value);
// If MaxNewSize is large, the maximum OldSize will be less than
// what's requested on the command line and it should be reset
@ -1031,46 +1010,46 @@ public:
FLAG_SET_CMDLINE(uintx, MaxNewSize, 170*M);
// Calculate what we expect the flag to be.
flag_value = MaxHeapSize - MaxNewSize;
verify_gen1_initial(flag_value);
verify_old_initial(flag_value);
}
static void verify_gen0_min(size_t expected) {
static void verify_young_min(size_t expected) {
MarkSweepPolicy msp;
msp.initialize_all();
assert(msp.min_gen0_size() <= expected, err_msg("%zu > %zu", msp.min_gen0_size(), expected));
assert(msp.min_young_size() <= expected, err_msg("%zu > %zu", msp.min_young_size(), expected));
}
static void verify_gen0_initial(size_t expected) {
static void verify_young_initial(size_t expected) {
MarkSweepPolicy msp;
msp.initialize_all();
assert(msp.initial_gen0_size() == expected, err_msg("%zu != %zu", msp.initial_gen0_size(), expected));
assert(msp.initial_young_size() == expected, err_msg("%zu != %zu", msp.initial_young_size(), expected));
}
static void verify_scaled_gen0_initial(size_t initial_heap_size) {
static void verify_scaled_young_initial(size_t initial_heap_size) {
MarkSweepPolicy msp;
msp.initialize_all();
size_t expected = msp.scale_by_NewRatio_aligned(initial_heap_size);
assert(msp.initial_gen0_size() == expected, err_msg("%zu != %zu", msp.initial_gen0_size(), expected));
assert(msp.initial_young_size() == expected, err_msg("%zu != %zu", msp.initial_young_size(), expected));
assert(FLAG_IS_ERGO(NewSize) && NewSize == expected,
err_msg("NewSize should have been set ergonomically to %zu, but was %zu", expected, NewSize));
}
static void verify_gen1_min(size_t expected) {
static void verify_old_min(size_t expected) {
MarkSweepPolicy msp;
msp.initialize_all();
assert(msp.min_gen1_size() <= expected, err_msg("%zu > %zu", msp.min_gen1_size(), expected));
assert(msp.min_old_size() <= expected, err_msg("%zu > %zu", msp.min_old_size(), expected));
}
static void verify_gen1_initial(size_t expected) {
static void verify_old_initial(size_t expected) {
MarkSweepPolicy msp;
msp.initialize_all();
assert(msp.initial_gen1_size() == expected, err_msg("%zu != %zu", msp.initial_gen1_size(), expected));
assert(msp.initial_old_size() == expected, err_msg("%zu != %zu", msp.initial_old_size(), expected));
}

28
hotspot/src/share/vm/memory/collectorPolicy.hpp
View File

@ -219,12 +219,12 @@ class ClearedAllSoftRefs : public StackObj {
class GenCollectorPolicy : public CollectorPolicy {
friend class TestGenCollectorPolicy;
protected:
size_t _min_gen0_size;
size_t _initial_gen0_size;
size_t _max_gen0_size;
size_t _min_gen1_size;
size_t _initial_gen1_size;
size_t _max_gen1_size;
size_t _min_young_size;
size_t _initial_young_size;
size_t _max_young_size;
size_t _min_old_size;
size_t _initial_old_size;
size_t _max_old_size;
// _gen_alignment and _space_alignment will have the same value most of the
// time. When using large pages they can differ.
@ -260,13 +260,13 @@ friend class TestGenCollectorPolicy;
GenCollectorPolicy();
// Accessors
size_t min_gen0_size() { return _min_gen0_size; }
size_t initial_gen0_size() { return _initial_gen0_size; }
size_t max_gen0_size() { return _max_gen0_size; }
size_t gen_alignment() { return _gen_alignment; }
size_t min_gen1_size() { return _min_gen1_size; }
size_t initial_gen1_size() { return _initial_gen1_size; }
size_t max_gen1_size() { return _max_gen1_size; }
size_t min_young_size() { return _min_young_size; }
size_t initial_young_size() { return _initial_young_size; }
size_t max_young_size() { return _max_young_size; }
size_t gen_alignment() { return _gen_alignment; }
size_t min_old_size() { return _min_old_size; }
size_t initial_old_size() { return _initial_old_size; }
size_t max_old_size() { return _max_old_size; }
int number_of_generations() { return 2; }
@ -298,7 +298,7 @@ friend class TestGenCollectorPolicy;
size_t init_survivor_size);
virtual void post_heap_initialize() {
assert(_max_gen0_size == MaxNewSize, "Should be taken care of by initialize_size_info");
assert(_max_young_size == MaxNewSize, "Should be taken care of by initialize_size_info");
}
BarrierSet::Name barrier_set_name() { return BarrierSet::CardTableModRef; }

4
hotspot/src/share/vm/memory/genCollectedHeap.cpp
View File

@ -1119,10 +1119,10 @@ void GenCollectedHeap::print_on_error(outputStream* st) const {
}
void GenCollectedHeap::print_tracing_info() const {
if (TraceGen0Time) {
if (TraceYoungGenTime) {
get_gen(0)->print_summary_info();
}
if (TraceGen1Time) {
if (TraceOldGenTime) {
get_gen(1)->print_summary_info();
}
}

5
hotspot/src/share/vm/memory/tenuredGeneration.hpp
View File

@ -67,10 +67,9 @@ class TenuredGeneration: public OneContigSpaceCardGeneration {
// Does a "full" (forced) collection invoked on this generation collect
// all younger generations as well? Note that this is a
// hack to allow the collection of the younger gen first if the flag is
// set. This is better than using th policy's should_collect_gen0_first()
// since that causes us to do an extra unnecessary pair of restart-&-stop-world.
// set.
virtual bool full_collects_younger_generations() const {
return !CollectGen0First;
return !ScavengeBeforeFullGC;
}
virtual void gc_prologue(bool full);

4
hotspot/src/share/vm/oops/cpCache.cpp
View File

@ -407,7 +407,7 @@ Method* ConstantPoolCacheEntry::method_if_resolved(constantPoolHandle cpool) {
oop ConstantPoolCacheEntry::appendix_if_resolved(constantPoolHandle cpool) {
if (is_f1_null() || !has_appendix())
if (!has_appendix())
return NULL;
const int ref_index = f2_as_index() + _indy_resolved_references_appendix_offset;
objArrayOop resolved_references = cpool->resolved_references();
@ -416,7 +416,7 @@ oop ConstantPoolCacheEntry::appendix_if_resolved(constantPoolHandle cpool) {
oop ConstantPoolCacheEntry::method_type_if_resolved(constantPoolHandle cpool) {
if (is_f1_null() || !has_method_type())
if (!has_method_type())
return NULL;
const int ref_index = f2_as_index() + _indy_resolved_references_method_type_offset;
objArrayOop resolved_references = cpool->resolved_references();

4
hotspot/src/share/vm/oops/cpCache.hpp
View File

@ -348,8 +348,8 @@ class ConstantPoolCacheEntry VALUE_OBJ_CLASS_SPEC {
bool is_final() const { return (_flags & (1 << is_final_shift)) != 0; }
bool is_forced_virtual() const { return (_flags & (1 << is_forced_virtual_shift)) != 0; }
bool is_vfinal() const { return (_flags & (1 << is_vfinal_shift)) != 0; }
bool has_appendix() const { return (_flags & (1 << has_appendix_shift)) != 0; }
bool has_method_type() const { return (_flags & (1 << has_method_type_shift)) != 0; }
bool has_appendix() const { return (!is_f1_null()) && (_flags & (1 << has_appendix_shift)) != 0; }
bool has_method_type() const { return (!is_f1_null()) && (_flags & (1 << has_method_type_shift)) != 0; }
bool is_method_entry() const { return (_flags & (1 << is_field_entry_shift)) == 0; }
bool is_field_entry() const { return (_flags & (1 << is_field_entry_shift)) != 0; }
bool is_byte() const { return flag_state() == btos; }

2
hotspot/src/share/vm/oops/methodData.hpp
View File

@ -2053,7 +2053,7 @@ public:
// Whole-method sticky bits and flags
enum {
_trap_hist_limit = 20, // decoupled from Deoptimization::Reason_LIMIT
_trap_hist_limit = 21, // decoupled from Deoptimization::Reason_LIMIT
_trap_hist_mask = max_jubyte,
_extra_data_count = 4 // extra DataLayout headers, for trap history
}; // Public flag values

64
hotspot/src/share/vm/opto/addnode.cpp
View File

@ -254,47 +254,46 @@ Node *AddINode::Ideal(PhaseGVN *phase, bool can_reshape) {
const Type *t_sub1 = phase->type( in1->in(1) );
const Type *t_2 = phase->type( in2 );
if( t_sub1->singleton() && t_2->singleton() && t_sub1 != Type::TOP && t_2 != Type::TOP )
return new (phase->C) SubINode(phase->makecon( add_ring( t_sub1, t_2 ) ),
in1->in(2) );
return new SubINode(phase->makecon( add_ring( t_sub1, t_2 ) ), in1->in(2) );
// Convert "(a-b)+(c-d)" into "(a+c)-(b+d)"
if( op2 == Op_SubI ) {
// Check for dead cycle: d = (a-b)+(c-d)
assert( in1->in(2) != this && in2->in(2) != this,
"dead loop in AddINode::Ideal" );
Node *sub = new (phase->C) SubINode(NULL, NULL);
sub->init_req(1, phase->transform(new (phase->C) AddINode(in1->in(1), in2->in(1) ) ));
sub->init_req(2, phase->transform(new (phase->C) AddINode(in1->in(2), in2->in(2) ) ));
Node *sub = new SubINode(NULL, NULL);
sub->init_req(1, phase->transform(new AddINode(in1->in(1), in2->in(1) ) ));
sub->init_req(2, phase->transform(new AddINode(in1->in(2), in2->in(2) ) ));
return sub;
}
// Convert "(a-b)+(b+c)" into "(a+c)"
if( op2 == Op_AddI && in1->in(2) == in2->in(1) ) {
assert(in1->in(1) != this && in2->in(2) != this,"dead loop in AddINode::Ideal");
return new (phase->C) AddINode(in1->in(1), in2->in(2));
return new AddINode(in1->in(1), in2->in(2));
}
// Convert "(a-b)+(c+b)" into "(a+c)"
if( op2 == Op_AddI && in1->in(2) == in2->in(2) ) {
assert(in1->in(1) != this && in2->in(1) != this,"dead loop in AddINode::Ideal");
return new (phase->C) AddINode(in1->in(1), in2->in(1));
return new AddINode(in1->in(1), in2->in(1));
}
// Convert "(a-b)+(b-c)" into "(a-c)"
if( op2 == Op_SubI && in1->in(2) == in2->in(1) ) {
assert(in1->in(1) != this && in2->in(2) != this,"dead loop in AddINode::Ideal");
return new (phase->C) SubINode(in1->in(1), in2->in(2));
return new SubINode(in1->in(1), in2->in(2));
}
// Convert "(a-b)+(c-a)" into "(c-b)"
if( op2 == Op_SubI && in1->in(1) == in2->in(2) ) {
assert(in1->in(2) != this && in2->in(1) != this,"dead loop in AddINode::Ideal");
return new (phase->C) SubINode(in2->in(1), in1->in(2));
return new SubINode(in2->in(1), in1->in(2));
}
}
// Convert "x+(0-y)" into "(x-y)"
if( op2 == Op_SubI && phase->type(in2->in(1)) == TypeInt::ZERO )
return new (phase->C) SubINode(in1, in2->in(2) );
return new SubINode(in1, in2->in(2) );
// Convert "(0-y)+x" into "(x-y)"
if( op1 == Op_SubI && phase->type(in1->in(1)) == TypeInt::ZERO )
return new (phase->C) SubINode( in2, in1->in(2) );
return new SubINode( in2, in1->in(2) );
// Convert (x>>>z)+y into (x+(y<<z))>>>z for small constant z and y.
// Helps with array allocation math constant folding
@ -315,8 +314,8 @@ Node *AddINode::Ideal(PhaseGVN *phase, bool can_reshape) {
if( z < 5 && -5 < y && y < 0 ) {
const Type *t_in11 = phase->type(in1->in(1));
if( t_in11 != Type::TOP && (t_in11->is_int()->_lo >= -(y << z)) ) {
Node *a = phase->transform( new (phase->C) AddINode( in1->in(1), phase->intcon(y<<z) ) );
return new (phase->C) URShiftINode( a, in1->in(2) );
Node *a = phase->transform( new AddINode( in1->in(1), phase->intcon(y<<z) ) );
return new URShiftINode( a, in1->in(2) );
}
}
}
@ -387,47 +386,46 @@ Node *AddLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
const Type *t_sub1 = phase->type( in1->in(1) );
const Type *t_2 = phase->type( in2 );
if( t_sub1->singleton() && t_2->singleton() && t_sub1 != Type::TOP && t_2 != Type::TOP )
return new (phase->C) SubLNode(phase->makecon( add_ring( t_sub1, t_2 ) ),
in1->in(2) );
return new SubLNode(phase->makecon( add_ring( t_sub1, t_2 ) ), in1->in(2) );
// Convert "(a-b)+(c-d)" into "(a+c)-(b+d)"
if( op2 == Op_SubL ) {
// Check for dead cycle: d = (a-b)+(c-d)
assert( in1->in(2) != this && in2->in(2) != this,
"dead loop in AddLNode::Ideal" );
Node *sub = new (phase->C) SubLNode(NULL, NULL);
sub->init_req(1, phase->transform(new (phase->C) AddLNode(in1->in(1), in2->in(1) ) ));
sub->init_req(2, phase->transform(new (phase->C) AddLNode(in1->in(2), in2->in(2) ) ));
Node *sub = new SubLNode(NULL, NULL);
sub->init_req(1, phase->transform(new AddLNode(in1->in(1), in2->in(1) ) ));
sub->init_req(2, phase->transform(new AddLNode(in1->in(2), in2->in(2) ) ));
return sub;
}
// Convert "(a-b)+(b+c)" into "(a+c)"
if( op2 == Op_AddL && in1->in(2) == in2->in(1) ) {
assert(in1->in(1) != this && in2->in(2) != this,"dead loop in AddLNode::Ideal");
return new (phase->C) AddLNode(in1->in(1), in2->in(2));
return new AddLNode(in1->in(1), in2->in(2));
}
// Convert "(a-b)+(c+b)" into "(a+c)"
if( op2 == Op_AddL && in1->in(2) == in2->in(2) ) {
assert(in1->in(1) != this && in2->in(1) != this,"dead loop in AddLNode::Ideal");
return new (phase->C) AddLNode(in1->in(1), in2->in(1));
return new AddLNode(in1->in(1), in2->in(1));
}
// Convert "(a-b)+(b-c)" into "(a-c)"
if( op2 == Op_SubL && in1->in(2) == in2->in(1) ) {
assert(in1->in(1) != this && in2->in(2) != this,"dead loop in AddLNode::Ideal");
return new (phase->C) SubLNode(in1->in(1), in2->in(2));
return new SubLNode(in1->in(1), in2->in(2));
}
// Convert "(a-b)+(c-a)" into "(c-b)"
if( op2 == Op_SubL && in1->in(1) == in1->in(2) ) {
assert(in1->in(2) != this && in2->in(1) != this,"dead loop in AddLNode::Ideal");
return new (phase->C) SubLNode(in2->in(1), in1->in(2));
return new SubLNode(in2->in(1), in1->in(2));
}
}
// Convert "x+(0-y)" into "(x-y)"
if( op2 == Op_SubL && phase->type(in2->in(1)) == TypeLong::ZERO )
return new (phase->C) SubLNode( in1, in2->in(2) );
return new SubLNode( in1, in2->in(2) );
// Convert "(0-y)+x" into "(x-y)"
if( op1 == Op_SubL && phase->type(in1->in(1)) == TypeInt::ZERO )
return new (phase->C) SubLNode( in2, in1->in(2) );
return new SubLNode( in2, in1->in(2) );
// Convert "X+X+X+X+X...+X+Y" into "k*X+Y" or really convert "X+(X+Y)"
// into "(X<<1)+Y" and let shift-folding happen.
@ -435,8 +433,8 @@ Node *AddLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
in2->in(1) == in1 &&
op1 != Op_ConL &&
0 ) {
Node *shift = phase->transform(new (phase->C) LShiftLNode(in1,phase->intcon(1)));
return new (phase->C) AddLNode(shift,in2->in(2));
Node *shift = phase->transform(new LShiftLNode(in1,phase->intcon(1)));
return new AddLNode(shift,in2->in(2));
}
return AddNode::Ideal(phase, can_reshape);
@ -596,7 +594,7 @@ Node *AddPNode::Ideal(PhaseGVN *phase, bool can_reshape) {
offset = phase->MakeConX(t2->get_con() + t12->get_con());
} else {
// Else move the constant to the right. ((A+con)+B) into ((A+B)+con)
address = phase->transform(new (phase->C) AddPNode(in(Base),addp->in(Address),in(Offset)));
address = phase->transform(new AddPNode(in(Base),addp->in(Address),in(Offset)));
offset = addp->in(Offset);
}
PhaseIterGVN *igvn = phase->is_IterGVN();
@ -616,7 +614,7 @@ Node *AddPNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// If this is a NULL+long form (from unsafe accesses), switch to a rawptr.
if (phase->type(in(Address)) == TypePtr::NULL_PTR) {
Node* offset = in(Offset);
return new (phase->C) CastX2PNode(offset);
return new CastX2PNode(offset);
}
}
@ -628,7 +626,7 @@ Node *AddPNode::Ideal(PhaseGVN *phase, bool can_reshape) {
if( add->Opcode() == Op_AddX && add->in(1) != add ) {
const Type *t22 = phase->type( add->in(2) );
if( t22->singleton() && (t22 != Type::TOP) ) { // Right input is an add of a constant?
set_req(Address, phase->transform(new (phase->C) AddPNode(in(Base),in(Address),add->in(1))));
set_req(Address, phase->transform(new AddPNode(in(Base),in(Address),add->in(1))));
set_req(Offset, add->in(2));
PhaseIterGVN *igvn = phase->is_IterGVN();
if (add->outcnt() == 0 && igvn) {
@ -858,7 +856,7 @@ Node *MinINode::Ideal(PhaseGVN *phase, bool can_reshape) {
// to force a right-spline graph for the rest of MinINode::Ideal().
if( l->Opcode() == Op_MinI ) {
assert( l != l->in(1), "dead loop in MinINode::Ideal" );
r = phase->transform(new (phase->C) MinINode(l->in(2),r));
r = phase->transform(new MinINode(l->in(2),r));
l = l->in(1);
set_req(1, l);
set_req(2, r);
@ -906,18 +904,18 @@ Node *MinINode::Ideal(PhaseGVN *phase, bool can_reshape) {
}
if( x->_idx > y->_idx )
return new (phase->C) MinINode(r->in(1),phase->transform(new (phase->C) MinINode(l,r->in(2))));
return new MinINode(r->in(1),phase->transform(new MinINode(l,r->in(2))));
// See if covers: MIN2(x+c0,MIN2(y+c1,z))
if( !phase->eqv(x,y) ) return NULL;
// If (y == x) transform MIN2(x+c0, MIN2(x+c1,z)) into
// MIN2(x+c0 or x+c1 which less, z).
return new (phase->C) MinINode(phase->transform(new (phase->C) AddINode(x,phase->intcon(MIN2(x_off,y_off)))),r->in(2));
return new MinINode(phase->transform(new AddINode(x,phase->intcon(MIN2(x_off,y_off)))),r->in(2));
} else {
// See if covers: MIN2(x+c0,y+c1)
if( !phase->eqv(x,y) ) return NULL;
// If (y == x) transform MIN2(x+c0,x+c1) into x+c0 or x+c1 which less.
return new (phase->C) AddINode(x,phase->intcon(MIN2(x_off,y_off)));
return new AddINode(x,phase->intcon(MIN2(x_off,y_off)));
}
}

6
hotspot/src/share/vm/opto/block.cpp
View File

@ -373,7 +373,7 @@ PhaseCFG::PhaseCFG(Arena* arena, RootNode* root, Matcher& matcher)
// I'll need a few machine-specific GotoNodes. Make an Ideal GotoNode,
// then Match it into a machine-specific Node. Then clone the machine
// Node on demand.
Node *x = new (C) GotoNode(NULL);
Node *x = new GotoNode(NULL);
x->init_req(0, x);
_goto = matcher.match_tree(x);
assert(_goto != NULL, "");
@ -426,7 +426,7 @@ uint PhaseCFG::build_cfg() {
!p->is_block_start() );
// Make the block begin with one of Region or StartNode.
if( !p->is_block_start() ) {
RegionNode *r = new (C) RegionNode( 2 );
RegionNode *r = new RegionNode( 2 );
r->init_req(1, p); // Insert RegionNode in the way
proj->set_req(0, r); // Insert RegionNode in the way
p = r;
@ -501,7 +501,7 @@ void PhaseCFG::insert_goto_at(uint block_no, uint succ_no) {
// get ProjNode corresponding to the succ_no'th successor of the in block
ProjNode* proj = in->get_node(in->number_of_nodes() - in->_num_succs + succ_no)->as_Proj();
// create region for basic block
RegionNode* region = new (C) RegionNode(2);
RegionNode* region = new RegionNode(2);
region->init_req(1, proj);
// setup corresponding basic block
Block* block = new (_block_arena) Block(_block_arena, region);

11
hotspot/src/share/vm/opto/bytecodeInfo.cpp
View File

@ -361,11 +361,14 @@ bool InlineTree::try_to_inline(ciMethod* callee_method, ciMethod* caller_method,
set_msg("not an accessor");
return false;
}
// Limit inlining depth in case inlining is forced or
// _max_inline_level was increased to compensate for lambda forms.
if (inline_level() > MaxForceInlineLevel) {
set_msg("MaxForceInlineLevel");
return false;
}
if (inline_level() > _max_inline_level) {
if (callee_method->force_inline() && inline_level() > MaxForceInlineLevel) {
set_msg("MaxForceInlineLevel");
return false;
}
if (!callee_method->force_inline() || !IncrementalInline) {
set_msg("inlining too deep");
return false;

3
hotspot/src/share/vm/opto/c2_globals.hpp
View File

@ -650,9 +650,6 @@
product(bool, UseMathExactIntrinsics, true, \
"Enables intrinsification of various java.lang.Math functions") \
\
experimental(bool, ReplaceInParentMaps, false, \
"Propagate type improvements in callers of inlinee if possible") \
\
product(bool, UseTypeSpeculation, true, \
"Speculatively propagate types from profiles") \
\

304
hotspot/src/share/vm/opto/callGenerator.cpp
View File

@ -63,12 +63,12 @@ public:
}
virtual bool is_parse() const { return true; }
virtual JVMState* generate(JVMState* jvms, Parse* parent_parser);
virtual JVMState* generate(JVMState* jvms);
int is_osr() { return _is_osr; }
};
JVMState* ParseGenerator::generate(JVMState* jvms, Parse* parent_parser) {
JVMState* ParseGenerator::generate(JVMState* jvms) {
Compile* C = Compile::current();
C->print_inlining_update(this);
@ -81,7 +81,7 @@ JVMState* ParseGenerator::generate(JVMState* jvms, Parse* parent_parser) {
return NULL; // bailing out of the compile; do not try to parse
}
Parse parser(jvms, method(), _expected_uses, parent_parser);
Parse parser(jvms, method(), _expected_uses);
// Grab signature for matching/allocation
#ifdef ASSERT
if (parser.tf() != (parser.depth() == 1 ? C->tf() : tf())) {
@ -120,12 +120,12 @@ class DirectCallGenerator : public CallGenerator {
_separate_io_proj(separate_io_proj)
{
}
virtual JVMState* generate(JVMState* jvms, Parse* parent_parser);
virtual JVMState* generate(JVMState* jvms);
CallStaticJavaNode* call_node() const { return _call_node; }
};
JVMState* DirectCallGenerator::generate(JVMState* jvms, Parse* parent_parser) {
JVMState* DirectCallGenerator::generate(JVMState* jvms) {
GraphKit kit(jvms);
kit.C->print_inlining_update(this);
bool is_static = method()->is_static();
@ -136,7 +136,7 @@ JVMState* DirectCallGenerator::generate(JVMState* jvms, Parse* parent_parser) {
kit.C->log()->elem("direct_call bci='%d'", jvms->bci());
}
CallStaticJavaNode *call = new (kit.C) CallStaticJavaNode(kit.C, tf(), target, method(), kit.bci());
CallStaticJavaNode *call = new 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.
@ -173,10 +173,10 @@ public:
vtable_index >= 0, "either invalid or usable");
}
virtual bool is_virtual() const { return true; }
virtual JVMState* generate(JVMState* jvms, Parse* parent_parser);
virtual JVMState* generate(JVMState* jvms);
};
JVMState* VirtualCallGenerator::generate(JVMState* jvms, Parse* parent_parser) {
JVMState* VirtualCallGenerator::generate(JVMState* jvms) {
GraphKit kit(jvms);
Node* receiver = kit.argument(0);
@ -225,7 +225,7 @@ JVMState* VirtualCallGenerator::generate(JVMState* jvms, Parse* parent_parser) {
"no vtable calls if +UseInlineCaches ");
address target = SharedRuntime::get_resolve_virtual_call_stub();
// Normal inline cache used for call
CallDynamicJavaNode *call = new (kit.C) CallDynamicJavaNode(tf(), target, method(), _vtable_index, kit.bci());
CallDynamicJavaNode *call = new CallDynamicJavaNode(tf(), target, method(), _vtable_index, kit.bci());
kit.set_arguments_for_java_call(call);
kit.set_edges_for_java_call(call);
Node* ret = kit.set_results_for_java_call(call);
@ -283,7 +283,7 @@ class LateInlineCallGenerator : public DirectCallGenerator {
// Convert the CallStaticJava into an inline
virtual void do_late_inline();
virtual JVMState* generate(JVMState* jvms, Parse* parent_parser) {
virtual JVMState* generate(JVMState* jvms) {
Compile *C = Compile::current();
C->log_inline_id(this);
@ -298,7 +298,7 @@ class LateInlineCallGenerator : public DirectCallGenerator {
// that the late inlining logic can distinguish between fall
// through and exceptional uses of the memory and io projections
// as is done for allocations and macro expansion.
return DirectCallGenerator::generate(jvms, parent_parser);
return DirectCallGenerator::generate(jvms);
}
virtual void print_inlining_late(const char* msg) {
@ -350,7 +350,7 @@ void LateInlineCallGenerator::do_late_inline() {
JVMState* old_jvms = call->jvms();
JVMState* jvms = old_jvms->clone_shallow(C);
uint size = call->req();
SafePointNode* map = new (C) SafePointNode(size, jvms);
SafePointNode* map = new SafePointNode(size, jvms);
for (uint i1 = 0; i1 < size; i1++) {
map->init_req(i1, call->in(i1));
}
@ -399,7 +399,7 @@ void LateInlineCallGenerator::do_late_inline() {
}
// Now perform the inlining using the synthesized JVMState
JVMState* new_jvms = _inline_cg->generate(jvms, NULL);
JVMState* new_jvms = _inline_cg->generate(jvms);
if (new_jvms == NULL) return; // no change
if (C->failing()) return;
@ -417,7 +417,7 @@ void LateInlineCallGenerator::do_late_inline() {
C->env()->notice_inlined_method(_inline_cg->method());
C->set_inlining_progress(true);
kit.replace_call(call, result);
kit.replace_call(call, result, true);
}
@ -439,8 +439,8 @@ class LateInlineMHCallGenerator : public LateInlineCallGenerator {
virtual bool is_mh_late_inline() const { return true; }
virtual JVMState* generate(JVMState* jvms, Parse* parent_parser) {
JVMState* new_jvms = LateInlineCallGenerator::generate(jvms, parent_parser);
virtual JVMState* generate(JVMState* jvms) {
JVMState* new_jvms = LateInlineCallGenerator::generate(jvms);
Compile* C = Compile::current();
if (_input_not_const) {
@ -486,14 +486,14 @@ class LateInlineStringCallGenerator : public LateInlineCallGenerator {
LateInlineStringCallGenerator(ciMethod* method, CallGenerator* inline_cg) :
LateInlineCallGenerator(method, inline_cg) {}
virtual JVMState* generate(JVMState* jvms, Parse* parent_parser) {
virtual JVMState* generate(JVMState* jvms) {
Compile *C = Compile::current();
C->log_inline_id(this);
C->add_string_late_inline(this);
JVMState* new_jvms = DirectCallGenerator::generate(jvms, parent_parser);
JVMState* new_jvms = DirectCallGenerator::generate(jvms);
return new_jvms;
}
@ -510,14 +510,14 @@ class LateInlineBoxingCallGenerator : public LateInlineCallGenerator {
LateInlineBoxingCallGenerator(ciMethod* method, CallGenerator* inline_cg) :
LateInlineCallGenerator(method, inline_cg) {}
virtual JVMState* generate(JVMState* jvms, Parse* parent_parser) {
virtual JVMState* generate(JVMState* jvms) {
Compile *C = Compile::current();
C->log_inline_id(this);
C->add_boxing_late_inline(this);
JVMState* new_jvms = DirectCallGenerator::generate(jvms, parent_parser);
JVMState* new_jvms = DirectCallGenerator::generate(jvms);
return new_jvms;
}
};
@ -553,7 +553,7 @@ public:
virtual bool is_virtual() const { return _is_virtual; }
virtual bool is_deferred() const { return true; }
virtual JVMState* generate(JVMState* jvms, Parse* parent_parser);
virtual JVMState* generate(JVMState* jvms);
};
@ -563,14 +563,14 @@ CallGenerator* CallGenerator::for_warm_call(WarmCallInfo* ci,
return new WarmCallGenerator(ci, if_cold, if_hot);
}
JVMState* WarmCallGenerator::generate(JVMState* jvms, Parse* parent_parser) {
JVMState* WarmCallGenerator::generate(JVMState* jvms) {
Compile* C = Compile::current();
C->print_inlining_update(this);
if (C->log() != NULL) {
C->log()->elem("warm_call bci='%d'", jvms->bci());
}
jvms = _if_cold->generate(jvms, parent_parser);
jvms = _if_cold->generate(jvms);
if (jvms != NULL) {
Node* m = jvms->map()->control();
if (m->is_CatchProj()) m = m->in(0); else m = C->top();
@ -631,7 +631,7 @@ public:
virtual bool is_inline() const { return _if_hit->is_inline(); }
virtual bool is_deferred() const { return _if_hit->is_deferred(); }
virtual JVMState* generate(JVMState* jvms, Parse* parent_parser);
virtual JVMState* generate(JVMState* jvms);
};
@ -643,14 +643,13 @@ CallGenerator* CallGenerator::for_predicted_call(ciKlass* predicted_receiver,
}
JVMState* PredictedCallGenerator::generate(JVMState* jvms, Parse* parent_parser) {
JVMState* PredictedCallGenerator::generate(JVMState* jvms) {
GraphKit kit(jvms);
kit.C->print_inlining_update(this);
PhaseGVN& gvn = kit.gvn();
// We need an explicit receiver null_check before checking its type.
// We share a map with the caller, so his JVMS gets adjusted.
Node* receiver = kit.argument(0);
CompileLog* log = kit.C->log();
if (log != NULL) {
log->elem("predicted_call bci='%d' klass='%d'",
@ -662,6 +661,10 @@ JVMState* PredictedCallGenerator::generate(JVMState* jvms, Parse* parent_parser)
return kit.transfer_exceptions_into_jvms();
}
// Make a copy of the replaced nodes in case we need to restore them
ReplacedNodes replaced_nodes = kit.map()->replaced_nodes();
replaced_nodes.clone();
Node* exact_receiver = receiver; // will get updated in place...
Node* slow_ctl = kit.type_check_receiver(receiver,
_predicted_receiver, _hit_prob,
@ -672,7 +675,7 @@ JVMState* PredictedCallGenerator::generate(JVMState* jvms, Parse* parent_parser)
{ PreserveJVMState pjvms(&kit);
kit.set_control(slow_ctl);
if (!kit.stopped()) {
slow_jvms = _if_missed->generate(kit.sync_jvms(), parent_parser);
slow_jvms = _if_missed->generate(kit.sync_jvms());
if (kit.failing())
return NULL; // might happen because of NodeCountInliningCutoff
assert(slow_jvms != NULL, "must be");
@ -693,12 +696,12 @@ JVMState* PredictedCallGenerator::generate(JVMState* jvms, Parse* parent_parser)
kit.replace_in_map(receiver, exact_receiver);
// Make the hot call:
JVMState* new_jvms = _if_hit->generate(kit.sync_jvms(), parent_parser);
JVMState* new_jvms = _if_hit->generate(kit.sync_jvms());
if (new_jvms == NULL) {
// Inline failed, so make a direct call.
assert(_if_hit->is_inline(), "must have been a failed inline");
CallGenerator* cg = CallGenerator::for_direct_call(_if_hit->method());
new_jvms = cg->generate(kit.sync_jvms(), parent_parser);
new_jvms = cg->generate(kit.sync_jvms());
}
kit.add_exception_states_from(new_jvms);
kit.set_jvms(new_jvms);
@ -715,16 +718,29 @@ JVMState* PredictedCallGenerator::generate(JVMState* jvms, Parse* parent_parser)
return kit.transfer_exceptions_into_jvms();
}
// There are 2 branches and the replaced nodes are only valid on
// one: restore the replaced nodes to what they were before the
// branch.
kit.map()->set_replaced_nodes(replaced_nodes);
// Finish the diamond.
kit.C->set_has_split_ifs(true); // Has chance for split-if optimization
RegionNode* region = new (kit.C) RegionNode(3);
RegionNode* region = new RegionNode(3);
region->init_req(1, kit.control());
region->init_req(2, slow_map->control());
kit.set_control(gvn.transform(region));
Node* iophi = PhiNode::make(region, kit.i_o(), Type::ABIO);
iophi->set_req(2, slow_map->i_o());
kit.set_i_o(gvn.transform(iophi));
// Merge memory
kit.merge_memory(slow_map->merged_memory(), region, 2);
// Transform new memory Phis.
for (MergeMemStream mms(kit.merged_memory()); mms.next_non_empty();) {
Node* phi = mms.memory();
if (phi->is_Phi() && phi->in(0) == region) {
mms.set_memory(gvn.transform(phi));
}
}
uint tos = kit.jvms()->stkoff() + kit.sp();
uint limit = slow_map->req();
for (uint i = TypeFunc::Parms; i < limit; i++) {
@ -825,7 +841,7 @@ CallGenerator* CallGenerator::for_method_handle_inline(JVMState* jvms, ciMethod*
const TypeOopPtr* arg_type = arg->bottom_type()->isa_oopptr();
const Type* sig_type = TypeOopPtr::make_from_klass(signature->accessing_klass());
if (arg_type != NULL && !arg_type->higher_equal(sig_type)) {
Node* cast_obj = gvn.transform(new (C) CheckCastPPNode(kit.control(), arg, sig_type));
Node* cast_obj = gvn.transform(new CheckCastPPNode(kit.control(), arg, sig_type));
kit.set_argument(0, cast_obj);
}
}
@ -837,7 +853,7 @@ CallGenerator* CallGenerator::for_method_handle_inline(JVMState* jvms, ciMethod*
const TypeOopPtr* arg_type = arg->bottom_type()->isa_oopptr();
const Type* sig_type = TypeOopPtr::make_from_klass(t->as_klass());
if (arg_type != NULL && !arg_type->higher_equal(sig_type)) {
Node* cast_obj = gvn.transform(new (C) CheckCastPPNode(kit.control(), arg, sig_type));
Node* cast_obj = gvn.transform(new CheckCastPPNode(kit.control(), arg, sig_type));
kit.set_argument(receiver_skip + i, cast_obj);
}
}
@ -882,15 +898,15 @@ CallGenerator* CallGenerator::for_method_handle_inline(JVMState* jvms, ciMethod*
}
//------------------------PredictedIntrinsicGenerator------------------------------
// Internal class which handles all predicted Intrinsic calls.
class PredictedIntrinsicGenerator : public CallGenerator {
//------------------------PredicatedIntrinsicGenerator------------------------------
// Internal class which handles all predicated Intrinsic calls.
class PredicatedIntrinsicGenerator : public CallGenerator {
CallGenerator* _intrinsic;
CallGenerator* _cg;
public:
PredictedIntrinsicGenerator(CallGenerator* intrinsic,
CallGenerator* cg)
PredicatedIntrinsicGenerator(CallGenerator* intrinsic,
CallGenerator* cg)
: CallGenerator(cg->method())
{
_intrinsic = intrinsic;
@ -901,108 +917,186 @@ public:
virtual bool is_inlined() const { return true; }
virtual bool is_intrinsic() const { return true; }
virtual JVMState* generate(JVMState* jvms, Parse* parent_parser);
virtual JVMState* generate(JVMState* jvms);
};
CallGenerator* CallGenerator::for_predicted_intrinsic(CallGenerator* intrinsic,
CallGenerator* cg) {
return new PredictedIntrinsicGenerator(intrinsic, cg);
CallGenerator* CallGenerator::for_predicated_intrinsic(CallGenerator* intrinsic,
CallGenerator* cg) {
return new PredicatedIntrinsicGenerator(intrinsic, cg);
}
JVMState* PredictedIntrinsicGenerator::generate(JVMState* jvms, Parse* parent_parser) {
JVMState* PredicatedIntrinsicGenerator::generate(JVMState* jvms) {
// The code we want to generate here is:
// if (receiver == NULL)
// uncommon_Trap
// if (predicate(0))
// do_intrinsic(0)
// else
// if (predicate(1))
// do_intrinsic(1)
// ...
// else
// do_java_comp
GraphKit kit(jvms);
PhaseGVN& gvn = kit.gvn();
CompileLog* log = kit.C->log();
if (log != NULL) {
log->elem("predicted_intrinsic bci='%d' method='%d'",
log->elem("predicated_intrinsic bci='%d' method='%d'",
jvms->bci(), log->identify(method()));
}
Node* slow_ctl = _intrinsic->generate_predicate(kit.sync_jvms());
if (kit.failing())
return NULL; // might happen because of NodeCountInliningCutoff
kit.C->print_inlining_update(this);
SafePointNode* slow_map = NULL;
JVMState* slow_jvms;
if (slow_ctl != NULL) {
PreserveJVMState pjvms(&kit);
kit.set_control(slow_ctl);
if (!kit.stopped()) {
slow_jvms = _cg->generate(kit.sync_jvms(), parent_parser);
if (kit.failing())
return NULL; // might happen because of NodeCountInliningCutoff
assert(slow_jvms != NULL, "must be");
kit.add_exception_states_from(slow_jvms);
kit.set_map(slow_jvms->map());
if (!kit.stopped())
slow_map = kit.stop();
}
}
if (kit.stopped()) {
// Predicate is always false.
kit.set_jvms(slow_jvms);
return kit.transfer_exceptions_into_jvms();
}
// Generate intrinsic code:
JVMState* new_jvms = _intrinsic->generate(kit.sync_jvms(), parent_parser);
if (new_jvms == NULL) {
// Intrinsic failed, so use slow code or make a direct call.
if (slow_map == NULL) {
CallGenerator* cg = CallGenerator::for_direct_call(method());
new_jvms = cg->generate(kit.sync_jvms(), parent_parser);
} else {
kit.set_jvms(slow_jvms);
if (!method()->is_static()) {
// We need an explicit receiver null_check before checking its type in predicate.
// We share a map with the caller, so his JVMS gets adjusted.
Node* receiver = kit.null_check_receiver_before_call(method());
if (kit.stopped()) {
return kit.transfer_exceptions_into_jvms();
}
}
kit.add_exception_states_from(new_jvms);
kit.set_jvms(new_jvms);
// Need to merge slow and fast?
if (slow_map == NULL) {
// The fast path is the only path remaining.
int n_predicates = _intrinsic->predicates_count();
assert(n_predicates > 0, "sanity");
JVMState** result_jvms = NEW_RESOURCE_ARRAY(JVMState*, (n_predicates+1));
// Region for normal compilation code if intrinsic failed.
Node* slow_region = new RegionNode(1);
int results = 0;
for (int predicate = 0; (predicate < n_predicates) && !kit.stopped(); predicate++) {
#ifdef ASSERT
JVMState* old_jvms = kit.jvms();
SafePointNode* old_map = kit.map();
Node* old_io = old_map->i_o();
Node* old_mem = old_map->memory();
Node* old_exc = old_map->next_exception();
#endif
Node* else_ctrl = _intrinsic->generate_predicate(kit.sync_jvms(), predicate);
#ifdef ASSERT
// Assert(no_new_memory && no_new_io && no_new_exceptions) after generate_predicate.
assert(old_jvms == kit.jvms(), "generate_predicate should not change jvm state");
SafePointNode* new_map = kit.map();
assert(old_io == new_map->i_o(), "generate_predicate should not change i_o");
assert(old_mem == new_map->memory(), "generate_predicate should not change memory");
assert(old_exc == new_map->next_exception(), "generate_predicate should not add exceptions");
#endif
if (!kit.stopped()) {
PreserveJVMState pjvms(&kit);
// Generate intrinsic code:
JVMState* new_jvms = _intrinsic->generate(kit.sync_jvms());
if (new_jvms == NULL) {
// Intrinsic failed, use normal compilation path for this predicate.
slow_region->add_req(kit.control());
} else {
kit.add_exception_states_from(new_jvms);
kit.set_jvms(new_jvms);
if (!kit.stopped()) {
result_jvms[results++] = kit.jvms();
}
}
}
if (else_ctrl == NULL) {
else_ctrl = kit.C->top();
}
kit.set_control(else_ctrl);
}
if (!kit.stopped()) {
// Final 'else' after predicates.
slow_region->add_req(kit.control());
}
if (slow_region->req() > 1) {
PreserveJVMState pjvms(&kit);
// Generate normal compilation code:
kit.set_control(gvn.transform(slow_region));
JVMState* new_jvms = _cg->generate(kit.sync_jvms());
if (kit.failing())
return NULL; // might happen because of NodeCountInliningCutoff
assert(new_jvms != NULL, "must be");
kit.add_exception_states_from(new_jvms);
kit.set_jvms(new_jvms);
if (!kit.stopped()) {
result_jvms[results++] = kit.jvms();
}
}
if (results == 0) {
// All paths ended in uncommon traps.
(void) kit.stop();
return kit.transfer_exceptions_into_jvms();
}
if (kit.stopped()) {
// Intrinsic method threw an exception, so it's just the slow path after all.
kit.set_jvms(slow_jvms);
if (results == 1) { // Only one path
kit.set_jvms(result_jvms[0]);
return kit.transfer_exceptions_into_jvms();
}
// Finish the diamond.
// Merge all paths.
kit.C->set_has_split_ifs(true); // Has chance for split-if optimization
RegionNode* region = new (kit.C) RegionNode(3);
region->init_req(1, kit.control());
region->init_req(2, slow_map->control());
kit.set_control(gvn.transform(region));
RegionNode* region = new RegionNode(results + 1);
Node* iophi = PhiNode::make(region, kit.i_o(), Type::ABIO);
iophi->set_req(2, slow_map->i_o());
for (int i = 0; i < results; i++) {
JVMState* jvms = result_jvms[i];
int path = i + 1;
SafePointNode* map = jvms->map();
region->init_req(path, map->control());
iophi->set_req(path, map->i_o());
if (i == 0) {
kit.set_jvms(jvms);
} else {
kit.merge_memory(map->merged_memory(), region, path);
}
}
kit.set_control(gvn.transform(region));
kit.set_i_o(gvn.transform(iophi));
kit.merge_memory(slow_map->merged_memory(), region, 2);
// Transform new memory Phis.
for (MergeMemStream mms(kit.merged_memory()); mms.next_non_empty();) {
Node* phi = mms.memory();
if (phi->is_Phi() && phi->in(0) == region) {
mms.set_memory(gvn.transform(phi));
}
}
// Merge debug info.
Node** ins = NEW_RESOURCE_ARRAY(Node*, results);
uint tos = kit.jvms()->stkoff() + kit.sp();
uint limit = slow_map->req();
Node* map = kit.map();
uint limit = map->req();
for (uint i = TypeFunc::Parms; i < limit; i++) {
// Skip unused stack slots; fast forward to monoff();
if (i == tos) {
i = kit.jvms()->monoff();
if( i >= limit ) break;
}
Node* m = kit.map()->in(i);
Node* n = slow_map->in(i);
if (m != n) {
const Type* t = gvn.type(m)->meet_speculative(gvn.type(n));
Node* phi = PhiNode::make(region, m, t);
phi->set_req(2, n);
kit.map()->set_req(i, gvn.transform(phi));
Node* n = map->in(i);
ins[0] = n;
const Type* t = gvn.type(n);
bool needs_phi = false;
for (int j = 1; j < results; j++) {
JVMState* jvms = result_jvms[j];
Node* jmap = jvms->map();
Node* m = NULL;
if (jmap->req() > i) {
m = jmap->in(i);
if (m != n) {
needs_phi = true;
t = t->meet_speculative(gvn.type(m));
}
}
ins[j] = m;
}
if (needs_phi) {
Node* phi = PhiNode::make(region, n, t);
for (int j = 1; j < results; j++) {
phi->set_req(j + 1, ins[j]);
}
map->set_req(i, gvn.transform(phi));
}
}
return kit.transfer_exceptions_into_jvms();
}
@ -1025,7 +1119,7 @@ public:
virtual bool is_virtual() const { ShouldNotReachHere(); return false; }
virtual bool is_trap() const { return true; }
virtual JVMState* generate(JVMState* jvms, Parse* parent_parser);
virtual JVMState* generate(JVMState* jvms);
};
@ -1037,7 +1131,7 @@ CallGenerator::for_uncommon_trap(ciMethod* m,
}
JVMState* UncommonTrapCallGenerator::generate(JVMState* jvms, Parse* parent_parser) {
JVMState* UncommonTrapCallGenerator::generate(JVMState* jvms) {
GraphKit kit(jvms);
kit.C->print_inlining_update(this);
// Take the trap with arguments pushed on the stack. (Cf. null_check_receiver).

15
hotspot/src/share/vm/opto/callGenerator.hpp
View File

@ -31,8 +31,6 @@
#include "opto/type.hpp"
#include "runtime/deoptimization.hpp"
class Parse;
//---------------------------CallGenerator-------------------------------------
// The subclasses of this class handle generation of ideal nodes for
// call sites and method entry points.
@ -63,8 +61,9 @@ class CallGenerator : public ResourceObj {
virtual bool is_virtual() const { return false; }
// is_deferred: The decision whether to inline or not is deferred.
virtual bool is_deferred() const { return false; }
// is_predicted: Uses an explicit check against a predicted type.
virtual bool is_predicted() const { return false; }
// is_predicated: Uses an explicit check (predicate).
virtual bool is_predicated() const { return false; }
virtual int predicates_count() const { return 0; }
// is_trap: Does not return to the caller. (E.g., uncommon trap.)
virtual bool is_trap() const { return false; }
// does_virtual_dispatch: Should try inlining as normal method first.
@ -114,7 +113,7 @@ class CallGenerator : public ResourceObj {
//
// If the result is NULL, it means that this CallGenerator was unable
// to handle the given call, and another CallGenerator should be consulted.
virtual JVMState* generate(JVMState* jvms, Parse* parent_parser) = 0;
virtual JVMState* generate(JVMState* jvms) = 0;
// How to generate a call site that is inlined:
static CallGenerator* for_inline(ciMethod* m, float expected_uses = -1);
@ -160,9 +159,9 @@ class CallGenerator : public ResourceObj {
// Registry for intrinsics:
static CallGenerator* for_intrinsic(ciMethod* m);
static void register_intrinsic(ciMethod* m, CallGenerator* cg);
static CallGenerator* for_predicted_intrinsic(CallGenerator* intrinsic,
CallGenerator* cg);
virtual Node* generate_predicate(JVMState* jvms) { return NULL; };
static CallGenerator* for_predicated_intrinsic(CallGenerator* intrinsic,
CallGenerator* cg);
virtual Node* generate_predicate(JVMState* jvms, int predicate) { return NULL; };
virtual void print_inlining_late(const char* msg) { ShouldNotReachHere(); }

23
hotspot/src/share/vm/opto/callnode.cpp
View File

@ -74,20 +74,20 @@ Node *StartNode::match( const ProjNode *proj, const Matcher *match ) {
case TypeFunc::Control:
case TypeFunc::I_O:
case TypeFunc::Memory:
return new (match->C) MachProjNode(this,proj->_con,RegMask::Empty,MachProjNode::unmatched_proj);
return new MachProjNode(this,proj->_con,RegMask::Empty,MachProjNode::unmatched_proj);
case TypeFunc::FramePtr:
return new (match->C) MachProjNode(this,proj->_con,Matcher::c_frame_ptr_mask, Op_RegP);
return new MachProjNode(this,proj->_con,Matcher::c_frame_ptr_mask, Op_RegP);
case TypeFunc::ReturnAdr:
return new (match->C) MachProjNode(this,proj->_con,match->_return_addr_mask,Op_RegP);
return new MachProjNode(this,proj->_con,match->_return_addr_mask,Op_RegP);
case TypeFunc::Parms:
default: {
uint parm_num = proj->_con - TypeFunc::Parms;
const Type *t = _domain->field_at(proj->_con);
if (t->base() == Type::Half) // 2nd half of Longs and Doubles
return new (match->C) ConNode(Type::TOP);
return new ConNode(Type::TOP);
uint ideal_reg = t->ideal_reg();
RegMask &rm = match->_calling_convention_mask[parm_num];
return new (match->C) MachProjNode(this,proj->_con,rm,ideal_reg);
return new MachProjNode(this,proj->_con,rm,ideal_reg);
}
}
return NULL;
@ -685,12 +685,12 @@ Node *CallNode::match( const ProjNode *proj, const Matcher *match ) {
case TypeFunc::Control:
case TypeFunc::I_O:
case TypeFunc::Memory:
return new (match->C) MachProjNode(this,proj->_con,RegMask::Empty,MachProjNode::unmatched_proj);
return new MachProjNode(this,proj->_con,RegMask::Empty,MachProjNode::unmatched_proj);
case TypeFunc::Parms+1: // For LONG & DOUBLE returns
assert(tf()->_range->field_at(TypeFunc::Parms+1) == Type::HALF, "");
// 2nd half of doubles and longs
return new (match->C) MachProjNode(this,proj->_con, RegMask::Empty, (uint)OptoReg::Bad);
return new MachProjNode(this,proj->_con, RegMask::Empty, (uint)OptoReg::Bad);
case TypeFunc::Parms: { // Normal returns
uint ideal_reg = tf()->range()->field_at(TypeFunc::Parms)->ideal_reg();
@ -700,7 +700,7 @@ Node *CallNode::match( const ProjNode *proj, const Matcher *match ) {
RegMask rm = RegMask(regs.first());
if( OptoReg::is_valid(regs.second()) )
rm.Insert( regs.second() );
return new (match->C) MachProjNode(this,proj->_con,rm,ideal_reg);
return new MachProjNode(this,proj->_con,rm,ideal_reg);
}
case TypeFunc::ReturnAdr:
@ -1090,6 +1090,7 @@ const Type *SafePointNode::Value( PhaseTransform *phase ) const {
#ifndef PRODUCT
void SafePointNode::dump_spec(outputStream *st) const {
st->print(" SafePoint ");
_replaced_nodes.dump(st);
}
#endif
@ -1288,10 +1289,10 @@ Node* AllocateArrayNode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node* nproj = catchproj->clone();
igvn->register_new_node_with_optimizer(nproj);
Node *frame = new (phase->C) ParmNode( phase->C->start(), TypeFunc::FramePtr );
Node *frame = new ParmNode( phase->C->start(), TypeFunc::FramePtr );
frame = phase->transform(frame);
// Halt & Catch Fire
Node *halt = new (phase->C) HaltNode( nproj, frame );
Node *halt = new HaltNode( nproj, frame );
phase->C->root()->add_req(halt);
phase->transform(halt);
@ -1333,7 +1334,7 @@ Node *AllocateArrayNode::make_ideal_length(const TypeOopPtr* oop_type, PhaseTran
if (!allow_new_nodes) return NULL;
// Create a cast which is control dependent on the initialization to
// propagate the fact that the array length must be positive.
length = new (phase->C) CastIINode(length, narrow_length_type);
length = new CastIINode(length, narrow_length_type);
length->set_req(0, initialization()->proj_out(0));
}
}

33
hotspot/src/share/vm/opto/callnode.hpp
View File

@ -30,6 +30,7 @@
#include "opto/multnode.hpp"
#include "opto/opcodes.hpp"
#include "opto/phaseX.hpp"
#include "opto/replacednodes.hpp"
#include "opto/type.hpp"
// Portions of code courtesy of Clifford Click
@ -335,6 +336,7 @@ public:
OopMap* _oop_map; // Array of OopMap info (8-bit char) for GC
JVMState* const _jvms; // Pointer to list of JVM State objects
const TypePtr* _adr_type; // What type of memory does this node produce?
ReplacedNodes _replaced_nodes; // During parsing: list of pair of nodes from calls to GraphKit::replace_in_map()
// Many calls take *all* of memory as input,
// but some produce a limited subset of that memory as output.
@ -426,6 +428,37 @@ public:
void set_next_exception(SafePointNode* n);
bool has_exceptions() const { return next_exception() != NULL; }
// Helper methods to operate on replaced nodes
ReplacedNodes replaced_nodes() const {
return _replaced_nodes;
}
void set_replaced_nodes(ReplacedNodes replaced_nodes) {
_replaced_nodes = replaced_nodes;
}
void clone_replaced_nodes() {
_replaced_nodes.clone();
}
void record_replaced_node(Node* initial, Node* improved) {
_replaced_nodes.record(initial, improved);
}
void transfer_replaced_nodes_from(SafePointNode* sfpt, uint idx = 0) {
_replaced_nodes.transfer_from(sfpt->_replaced_nodes, idx);
}
void delete_replaced_nodes() {
_replaced_nodes.reset();
}
void apply_replaced_nodes() {
_replaced_nodes.apply(this);
}
void merge_replaced_nodes_with(SafePointNode* sfpt) {
_replaced_nodes.merge_with(sfpt->_replaced_nodes);
}
bool has_replaced_nodes() const {
return !_replaced_nodes.is_empty();
}
// Standard Node stuff
virtual int Opcode() const;
virtual bool pinned() const { return true; }

8
hotspot/src/share/vm/opto/castnode.cpp
View File

@ -228,11 +228,11 @@ static inline Node* addP_of_X2P(PhaseGVN *phase,
Node* dispX,
bool negate = false) {
if (negate) {
dispX = new (phase->C) SubXNode(phase->MakeConX(0), phase->transform(dispX));
dispX = new SubXNode(phase->MakeConX(0), phase->transform(dispX));
}
return new (phase->C) AddPNode(phase->C->top(),
phase->transform(new (phase->C) CastX2PNode(base)),
phase->transform(dispX));
return new AddPNode(phase->C->top(),
phase->transform(new CastX2PNode(base)),
phase->transform(dispX));
}
Node *CastX2PNode::Ideal(PhaseGVN *phase, bool can_reshape) {

60
hotspot/src/share/vm/opto/cfgnode.cpp
View File

@ -662,17 +662,17 @@ Node *RegionNode::Ideal(PhaseGVN *phase, bool can_reshape) {
convf2i->in(1) == bot_in ) {
// Matched pattern, including LShiftI; RShiftI, replace with integer compares
// max test
Node *cmp = gvn->register_new_node_with_optimizer(new (phase->C) CmpINode( convf2i, min ));
Node *boo = gvn->register_new_node_with_optimizer(new (phase->C) BoolNode( cmp, BoolTest::lt ));
IfNode *iff = (IfNode*)gvn->register_new_node_with_optimizer(new (phase->C) IfNode( top_if->in(0), boo, PROB_UNLIKELY_MAG(5), top_if->_fcnt ));
Node *if_min= gvn->register_new_node_with_optimizer(new (phase->C) IfTrueNode (iff));
Node *ifF = gvn->register_new_node_with_optimizer(new (phase->C) IfFalseNode(iff));
Node *cmp = gvn->register_new_node_with_optimizer(new CmpINode( convf2i, min ));
Node *boo = gvn->register_new_node_with_optimizer(new BoolNode( cmp, BoolTest::lt ));
IfNode *iff = (IfNode*)gvn->register_new_node_with_optimizer(new IfNode( top_if->in(0), boo, PROB_UNLIKELY_MAG(5), top_if->_fcnt ));
Node *if_min= gvn->register_new_node_with_optimizer(new IfTrueNode (iff));
Node *ifF = gvn->register_new_node_with_optimizer(new IfFalseNode(iff));
// min test
cmp = gvn->register_new_node_with_optimizer(new (phase->C) CmpINode( convf2i, max ));
boo = gvn->register_new_node_with_optimizer(new (phase->C) BoolNode( cmp, BoolTest::gt ));
iff = (IfNode*)gvn->register_new_node_with_optimizer(new (phase->C) IfNode( ifF, boo, PROB_UNLIKELY_MAG(5), bot_if->_fcnt ));
Node *if_max= gvn->register_new_node_with_optimizer(new (phase->C) IfTrueNode (iff));
ifF = gvn->register_new_node_with_optimizer(new (phase->C) IfFalseNode(iff));
cmp = gvn->register_new_node_with_optimizer(new CmpINode( convf2i, max ));
boo = gvn->register_new_node_with_optimizer(new BoolNode( cmp, BoolTest::gt ));
iff = (IfNode*)gvn->register_new_node_with_optimizer(new IfNode( ifF, boo, PROB_UNLIKELY_MAG(5), bot_if->_fcnt ));
Node *if_max= gvn->register_new_node_with_optimizer(new IfTrueNode (iff));
ifF = gvn->register_new_node_with_optimizer(new IfFalseNode(iff));
// update input edges to region node
set_req_X( min_idx, if_min, gvn );
set_req_X( max_idx, if_max, gvn );
@ -731,7 +731,7 @@ const TypePtr* flatten_phi_adr_type(const TypePtr* at) {
PhiNode* PhiNode::make(Node* r, Node* x, const Type *t, const TypePtr* at) {
uint preds = r->req(); // Number of predecessor paths
assert(t != Type::MEMORY || at == flatten_phi_adr_type(at), "flatten at");
PhiNode* p = new (Compile::current()) PhiNode(r, t, at);
PhiNode* p = new PhiNode(r, t, at);
for (uint j = 1; j < preds; j++) {
// Fill in all inputs, except those which the region does not yet have
if (r->in(j) != NULL)
@ -749,7 +749,7 @@ PhiNode* PhiNode::make_blank(Node* r, Node* x) {
const Type* t = x->bottom_type();
const TypePtr* at = NULL;
if (t == Type::MEMORY) at = flatten_phi_adr_type(x->adr_type());
return new (Compile::current()) PhiNode(r, t, at);
return new PhiNode(r, t, at);
}
@ -1258,9 +1258,9 @@ static Node *is_x2logic( PhaseGVN *phase, PhiNode *phi, int true_path ) {
} else return NULL;
// Build int->bool conversion
Node *n = new (phase->C) Conv2BNode( cmp->in(1) );
Node *n = new Conv2BNode( cmp->in(1) );
if( flipped )
n = new (phase->C) XorINode( phase->transform(n), phase->intcon(1) );
n = new XorINode( phase->transform(n), phase->intcon(1) );
return n;
}
@ -1320,9 +1320,9 @@ static Node* is_cond_add(PhaseGVN *phase, PhiNode *phi, int true_path) {
if( q->is_Con() && phase->type(q) != TypeInt::ZERO && y->is_Con() )
return NULL;
Node *cmplt = phase->transform( new (phase->C) CmpLTMaskNode(p,q) );
Node *j_and = phase->transform( new (phase->C) AndINode(cmplt,y) );
return new (phase->C) AddINode(j_and,x);
Node *cmplt = phase->transform( new CmpLTMaskNode(p,q) );
Node *j_and = phase->transform( new AndINode(cmplt,y) );
return new AddINode(j_and,x);
}
//------------------------------is_absolute------------------------------------
@ -1384,17 +1384,17 @@ static Node* is_absolute( PhaseGVN *phase, PhiNode *phi_root, int true_path) {
if( sub->Opcode() != Op_SubF ||
sub->in(2) != x ||
phase->type(sub->in(1)) != tzero ) return NULL;
x = new (phase->C) AbsFNode(x);
x = new AbsFNode(x);
if (flip) {
x = new (phase->C) SubFNode(sub->in(1), phase->transform(x));
x = new SubFNode(sub->in(1), phase->transform(x));
}
} else {
if( sub->Opcode() != Op_SubD ||
sub->in(2) != x ||
phase->type(sub->in(1)) != tzero ) return NULL;
x = new (phase->C) AbsDNode(x);
x = new AbsDNode(x);
if (flip) {
x = new (phase->C) SubDNode(sub->in(1), phase->transform(x));
x = new SubDNode(sub->in(1), phase->transform(x));
}
}
@ -1469,7 +1469,7 @@ static Node* split_flow_path(PhaseGVN *phase, PhiNode *phi) {
// Now start splitting out the flow paths that merge the same value.
// Split first the RegionNode.
PhaseIterGVN *igvn = phase->is_IterGVN();
RegionNode *newr = new (phase->C) RegionNode(hit+1);
RegionNode *newr = new RegionNode(hit+1);
split_once(igvn, phi, val, r, newr);
// Now split all other Phis than this one
@ -1781,13 +1781,13 @@ Node *PhiNode::Ideal(PhaseGVN *phase, bool can_reshape) {
}
if (doit) {
if (base == NULL) {
base = new (phase->C) PhiNode(in(0), type, NULL);
base = new PhiNode(in(0), type, NULL);
for (uint i = 1; i < req(); i++) {
base->init_req(i, in(i)->in(AddPNode::Base));
}
phase->is_IterGVN()->register_new_node_with_optimizer(base);
}
return new (phase->C) AddPNode(base, base, y);
return new AddPNode(base, base, y);
}
}
}
@ -1864,7 +1864,7 @@ Node *PhiNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// Phi(...MergeMem(m0, m1:AT1, m2:AT2)...) into
// MergeMem(Phi(...m0...), Phi:AT1(...m1...), Phi:AT2(...m2...))
PhaseIterGVN *igvn = phase->is_IterGVN();
Node* hook = new (phase->C) Node(1);
Node* hook = new Node(1);
PhiNode* new_base = (PhiNode*) clone();
// Must eagerly register phis, since they participate in loops.
if (igvn) {
@ -1961,7 +1961,7 @@ Node *PhiNode::Ideal(PhaseGVN *phase, bool can_reshape) {
} else {
narrow_t = TypeNarrowKlass::make(this->bottom_type()->is_ptr());
}
PhiNode* new_phi = new (phase->C) PhiNode(r, narrow_t);
PhiNode* new_phi = new PhiNode(r, narrow_t);
uint orig_cnt = req();
for (uint i=1; i<req(); ++i) {// For all paths in
Node *ii = in(i);
@ -1975,9 +1975,9 @@ Node *PhiNode::Ideal(PhaseGVN *phase, bool can_reshape) {
new_ii = new_phi;
} else {
if (is_decodeN) {
new_ii = new (phase->C) EncodePNode(ii, narrow_t);
new_ii = new EncodePNode(ii, narrow_t);
} else {
new_ii = new (phase->C) EncodePKlassNode(ii, narrow_t);
new_ii = new EncodePKlassNode(ii, narrow_t);
}
igvn->register_new_node_with_optimizer(new_ii);
}
@ -1986,9 +1986,9 @@ Node *PhiNode::Ideal(PhaseGVN *phase, bool can_reshape) {
}
igvn->register_new_node_with_optimizer(new_phi, this);
if (is_decodeN) {
progress = new (phase->C) DecodeNNode(new_phi, bottom_type());
progress = new DecodeNNode(new_phi, bottom_type());
} else {
progress = new (phase->C) DecodeNKlassNode(new_phi, bottom_type());
progress = new DecodeNKlassNode(new_phi, bottom_type());
}
}
}

4
hotspot/src/share/vm/opto/chaitin.cpp
View File

@ -1730,7 +1730,7 @@ Node *PhaseChaitin::find_base_for_derived( Node **derived_base_map, Node *derive
// Now we see we need a base-Phi here to merge the bases
const Type *t = base->bottom_type();
base = new (C) PhiNode( derived->in(0), t );
base = new PhiNode( derived->in(0), t );
for( i = 1; i < derived->req(); i++ ) {
base->init_req(i, find_base_for_derived(derived_base_map, derived->in(i), maxlrg));
t = t->meet(base->in(i)->bottom_type());
@ -1800,7 +1800,7 @@ bool PhaseChaitin::stretch_base_pointer_live_ranges(ResourceArea *a) {
Block *phi_block = _cfg.get_block_for_node(phi);
if (_cfg.get_block_for_node(phi_block->pred(2)) == block) {
const RegMask *mask = C->matcher()->idealreg2spillmask[Op_RegI];
Node *spill = new (C) MachSpillCopyNode(MachSpillCopyNode::LoopPhiInput, phi, *mask, *mask);
Node *spill = new MachSpillCopyNode(MachSpillCopyNode::LoopPhiInput, phi, *mask, *mask);
insert_proj( phi_block, 1, spill, maxlrg++ );
n->set_req(1,spill);
must_recompute_live = true;

6
hotspot/src/share/vm/opto/coalesce.cpp
View File

@ -291,7 +291,7 @@ void PhaseAggressiveCoalesce::insert_copies( Matcher &matcher ) {
_phc.clone_projs(pred, pred->end_idx(), m, copy, _phc._lrg_map);
} else {
const RegMask *rm = C->matcher()->idealreg2spillmask[m->ideal_reg()];
copy = new (C) MachSpillCopyNode(MachSpillCopyNode::PhiInput, m, *rm, *rm);
copy = new MachSpillCopyNode(MachSpillCopyNode::PhiInput, m, *rm, *rm);
// Find a good place to insert. Kinda tricky, use a subroutine
insert_copy_with_overlap(pred,copy,phi_name,src_name);
}
@ -325,7 +325,7 @@ void PhaseAggressiveCoalesce::insert_copies( Matcher &matcher ) {
l += _phc.clone_projs(b, l, m, copy, _phc._lrg_map);
} else {
const RegMask *rm = C->matcher()->idealreg2spillmask[m->ideal_reg()];
copy = new (C) MachSpillCopyNode(MachSpillCopyNode::TwoAddress, m, *rm, *rm);
copy = new MachSpillCopyNode(MachSpillCopyNode::TwoAddress, m, *rm, *rm);
// Insert the copy in the basic block, just before us
b->insert_node(copy, l++);
}
@ -372,7 +372,7 @@ void PhaseAggressiveCoalesce::insert_copies( Matcher &matcher ) {
continue; // Live out; do not pre-split
// Split the lrg at this use
const RegMask *rm = C->matcher()->idealreg2spillmask[inp->ideal_reg()];
Node* copy = new (C) MachSpillCopyNode(MachSpillCopyNode::DebugUse, inp, *rm, *rm);
Node* copy = new MachSpillCopyNode(MachSpillCopyNode::DebugUse, inp, *rm, *rm);
// Insert the copy in the use-def chain
n->set_req(inpidx, copy );
// Insert the copy in the basic block, just before us

45
hotspot/src/share/vm/opto/compile.cpp
View File

@ -95,7 +95,7 @@
// Constant table base node singleton.
MachConstantBaseNode* Compile::mach_constant_base_node() {
if (_mach_constant_base_node == NULL) {
_mach_constant_base_node = new (C) MachConstantBaseNode();
_mach_constant_base_node = new MachConstantBaseNode();
_mach_constant_base_node->add_req(C->root());
}
return _mach_constant_base_node;
@ -392,6 +392,11 @@ void Compile::remove_useless_nodes(Unique_Node_List &useful) {
uint next = 0;
while (next < useful.size()) {
Node *n = useful.at(next++);
if (n->is_SafePoint()) {
// We're done with a parsing phase. Replaced nodes are not valid
// beyond that point.
n->as_SafePoint()->delete_replaced_nodes();
}
// Use raw traversal of out edges since this code removes out edges
int max = n->outcnt();
for (int j = 0; j < max; ++j) {
@ -673,7 +678,6 @@ Compile::Compile( ciEnv* ci_env, C2Compiler* compiler, ciMethod* target, int osr
_print_inlining_stream(NULL),
_print_inlining_idx(0),
_print_inlining_output(NULL),
_preserve_jvm_state(0),
_interpreter_frame_size(0) {
C = this;
@ -748,14 +752,14 @@ Compile::Compile( ciEnv* ci_env, C2Compiler* compiler, ciMethod* target, int osr
const TypeTuple *domain = StartOSRNode::osr_domain();
const TypeTuple *range = TypeTuple::make_range(method()->signature());
init_tf(TypeFunc::make(domain, range));
StartNode* s = new (this) StartOSRNode(root(), domain);
StartNode* s = new StartOSRNode(root(), domain);
initial_gvn()->set_type_bottom(s);
init_start(s);
cg = CallGenerator::for_osr(method(), entry_bci());
} else {
// Normal case.
init_tf(TypeFunc::make(method()));
StartNode* s = new (this) StartNode(root(), tf()->domain());
StartNode* s = new StartNode(root(), tf()->domain());
initial_gvn()->set_type_bottom(s);
init_start(s);
if (method()->intrinsic_id() == vmIntrinsics::_Reference_get && UseG1GC) {
@ -783,7 +787,7 @@ Compile::Compile( ciEnv* ci_env, C2Compiler* compiler, ciMethod* target, int osr
return;
}
JVMState* jvms = build_start_state(start(), tf());
if ((jvms = cg->generate(jvms, NULL)) == NULL) {
if ((jvms = cg->generate(jvms)) == NULL) {
record_method_not_compilable("method parse failed");
return;
}
@ -980,7 +984,6 @@ Compile::Compile( ciEnv* ci_env,
_print_inlining_stream(NULL),
_print_inlining_idx(0),
_print_inlining_output(NULL),
_preserve_jvm_state(0),
_allowed_reasons(0),
_interpreter_frame_size(0) {
C = this;
@ -1061,9 +1064,9 @@ void Compile::Init(int aliaslevel) {
// Globally visible Nodes
// First set TOP to NULL to give safe behavior during creation of RootNode
set_cached_top_node(NULL);
set_root(new (this) RootNode());
set_root(new RootNode());
// Now that you have a Root to point to, create the real TOP
set_cached_top_node( new (this) ConNode(Type::TOP) );
set_cached_top_node( new ConNode(Type::TOP) );
set_recent_alloc(NULL, NULL);
// Create Debug Information Recorder to record scopes, oopmaps, etc.
@ -1914,6 +1917,8 @@ void Compile::inline_boxing_calls(PhaseIterGVN& igvn) {
for_igvn()->clear();
gvn->replace_with(&igvn);
_late_inlines_pos = _late_inlines.length();
while (_boxing_late_inlines.length() > 0) {
CallGenerator* cg = _boxing_late_inlines.pop();
cg->do_late_inline();
@ -1977,8 +1982,8 @@ void Compile::inline_incrementally(PhaseIterGVN& igvn) {
if (live_nodes() > (uint)LiveNodeCountInliningCutoff) {
if (low_live_nodes < (uint)LiveNodeCountInliningCutoff * 8 / 10) {
// PhaseIdealLoop is expensive so we only try it once we are
// out of loop and we only try it again if the previous helped
// got the number of nodes down significantly
// out of live nodes and we only try it again if the previous
// helped got the number of nodes down significantly
PhaseIdealLoop ideal_loop( igvn, false, true );
if (failing()) return;
low_live_nodes = live_nodes();
@ -2072,6 +2077,10 @@ void Compile::Optimize() {
// Inline valueOf() methods now.
inline_boxing_calls(igvn);
if (AlwaysIncrementalInline) {
inline_incrementally(igvn);
}
print_method(PHASE_INCREMENTAL_BOXING_INLINE, 2);
if (failing()) return;
@ -2757,9 +2766,9 @@ void Compile::final_graph_reshaping_impl( Node *n, Final_Reshape_Counts &frc) {
// Decode a narrow oop to match address
// [R12 + narrow_oop_reg<<3 + offset]
if (t->isa_oopptr()) {
nn = new (this) DecodeNNode(nn, t);
nn = new DecodeNNode(nn, t);
} else {
nn = new (this) DecodeNKlassNode(nn, t);
nn = new DecodeNKlassNode(nn, t);
}
n->set_req(AddPNode::Base, nn);
n->set_req(AddPNode::Address, nn);
@ -2880,7 +2889,7 @@ void Compile::final_graph_reshaping_impl( Node *n, Final_Reshape_Counts &frc) {
}
}
if (new_in2 != NULL) {
Node* cmpN = new (this) CmpNNode(in1->in(1), new_in2);
Node* cmpN = new CmpNNode(in1->in(1), new_in2);
n->subsume_by(cmpN, this);
if (in1->outcnt() == 0) {
in1->disconnect_inputs(NULL, this);
@ -2979,8 +2988,8 @@ void Compile::final_graph_reshaping_impl( Node *n, Final_Reshape_Counts &frc) {
n->subsume_by(divmod->mod_proj(), this);
} else {
// replace a%b with a-((a/b)*b)
Node* mult = new (this) MulINode(d, d->in(2));
Node* sub = new (this) SubINode(d->in(1), mult);
Node* mult = new MulINode(d, d->in(2));
Node* sub = new SubINode(d->in(1), mult);
n->subsume_by(sub, this);
}
}
@ -2999,8 +3008,8 @@ void Compile::final_graph_reshaping_impl( Node *n, Final_Reshape_Counts &frc) {
n->subsume_by(divmod->mod_proj(), this);
} else {
// replace a%b with a-((a/b)*b)
Node* mult = new (this) MulLNode(d, d->in(2));
Node* sub = new (this) SubLNode(d->in(1), mult);
Node* mult = new MulLNode(d, d->in(2));
Node* sub = new SubLNode(d->in(1), mult);
n->subsume_by(sub, this);
}
}
@ -3049,7 +3058,7 @@ void Compile::final_graph_reshaping_impl( Node *n, Final_Reshape_Counts &frc) {
}
} else {
if (t == NULL || t->_lo < 0 || t->_hi > (int)mask) {
Node* shift = new (this) AndINode(in2, ConNode::make(this, TypeInt::make(mask)));
Node* shift = new AndINode(in2, ConNode::make(this, TypeInt::make(mask)));
n->set_req(2, shift);
}
}

18
hotspot/src/share/vm/opto/compile.hpp
View File

@ -431,9 +431,6 @@ class Compile : public Phase {
// Remove the speculative part of types and clean up the graph
void remove_speculative_types(PhaseIterGVN &igvn);
// Are we within a PreserveJVMState block?
int _preserve_jvm_state;
void* _replay_inline_data; // Pointer to data loaded from file
void print_inlining_init();
@ -1198,21 +1195,6 @@ class Compile : public Phase {
// Auxiliary method for randomized fuzzing/stressing
static bool randomized_select(int count);
// enter a PreserveJVMState block
void inc_preserve_jvm_state() {
_preserve_jvm_state++;
}
// exit a PreserveJVMState block
void dec_preserve_jvm_state() {
_preserve_jvm_state--;
assert(_preserve_jvm_state >= 0, "_preserve_jvm_state shouldn't be negative");
}
bool has_preserve_jvm_state() const {
return _preserve_jvm_state > 0;
}
};
#endif // SHARE_VM_OPTO_COMPILE_HPP

22
hotspot/src/share/vm/opto/connode.cpp
View File

@ -45,17 +45,17 @@ uint ConNode::hash() const {
//------------------------------make-------------------------------------------
ConNode *ConNode::make( Compile* C, const Type *t ) {
switch( t->basic_type() ) {
case T_INT: return new (C) ConINode( t->is_int() );
case T_LONG: return new (C) ConLNode( t->is_long() );
case T_FLOAT: return new (C) ConFNode( t->is_float_constant() );
case T_DOUBLE: return new (C) ConDNode( t->is_double_constant() );
case T_VOID: return new (C) ConNode ( Type::TOP );
case T_OBJECT: return new (C) ConPNode( t->is_ptr() );
case T_ARRAY: return new (C) ConPNode( t->is_aryptr() );
case T_ADDRESS: return new (C) ConPNode( t->is_ptr() );
case T_NARROWOOP: return new (C) ConNNode( t->is_narrowoop() );
case T_NARROWKLASS: return new (C) ConNKlassNode( t->is_narrowklass() );
case T_METADATA: return new (C) ConPNode( t->is_ptr() );
case T_INT: return new ConINode( t->is_int() );
case T_LONG: return new ConLNode( t->is_long() );
case T_FLOAT: return new ConFNode( t->is_float_constant() );
case T_DOUBLE: return new ConDNode( t->is_double_constant() );
case T_VOID: return new ConNode ( Type::TOP );
case T_OBJECT: return new ConPNode( t->is_ptr() );
case T_ARRAY: return new ConPNode( t->is_aryptr() );
case T_ADDRESS: return new ConPNode( t->is_ptr() );
case T_NARROWOOP: return new ConNNode( t->is_narrowoop() );
case T_NARROWKLASS: return new ConNKlassNode( t->is_narrowklass() );
case T_METADATA: return new ConPNode( t->is_ptr() );
// Expected cases: TypePtr::NULL_PTR, any is_rawptr()
// Also seen: AnyPtr(TopPTR *+top); from command line:
// r -XX:+PrintOpto -XX:CIStart=285 -XX:+CompileTheWorld -XX:CompileTheWorldStartAt=660

12
hotspot/src/share/vm/opto/connode.hpp
View File

@ -58,7 +58,7 @@ public:
// Factory method:
static ConINode* make( Compile* C, int con ) {
return new (C) ConINode( TypeInt::make(con) );
return new ConINode( TypeInt::make(con) );
}
};
@ -73,9 +73,9 @@ public:
// Factory methods:
static ConPNode* make( Compile *C ,address con ) {
if (con == NULL)
return new (C) ConPNode( TypePtr::NULL_PTR ) ;
return new ConPNode( TypePtr::NULL_PTR ) ;
else
return new (C) ConPNode( TypeRawPtr::make(con) );
return new ConPNode( TypeRawPtr::make(con) );
}
};
@ -106,7 +106,7 @@ public:
// Factory method:
static ConLNode* make( Compile *C ,jlong con ) {
return new (C) ConLNode( TypeLong::make(con) );
return new ConLNode( TypeLong::make(con) );
}
};
@ -120,7 +120,7 @@ public:
// Factory method:
static ConFNode* make( Compile *C, float con ) {
return new (C) ConFNode( TypeF::make(con) );
return new ConFNode( TypeF::make(con) );
}
};
@ -134,7 +134,7 @@ public:
// Factory method:
static ConDNode* make( Compile *C, double con ) {
return new (C) ConDNode( TypeD::make(con) );
return new ConDNode( TypeD::make(con) );
}
};

14
hotspot/src/share/vm/opto/convertnode.cpp
View File

@ -374,11 +374,11 @@ Node *ConvI2LNode::Ideal(PhaseGVN *phase, bool can_reshape) {
ryhi = -rylo0;
}
Node* cx = phase->transform( new (phase->C) ConvI2LNode(x, TypeLong::make(rxlo, rxhi, widen)) );
Node* cy = phase->transform( new (phase->C) ConvI2LNode(y, TypeLong::make(rylo, ryhi, widen)) );
Node* cx = phase->transform( new ConvI2LNode(x, TypeLong::make(rxlo, rxhi, widen)) );
Node* cy = phase->transform( new ConvI2LNode(y, TypeLong::make(rylo, ryhi, widen)) );
switch (op) {
case Op_AddI: return new (phase->C) AddLNode(cx, cy);
case Op_SubI: return new (phase->C) SubLNode(cx, cy);
case Op_AddI: return new AddLNode(cx, cy);
case Op_SubI: return new SubLNode(cx, cy);
default: ShouldNotReachHere();
}
}
@ -452,9 +452,9 @@ Node *ConvL2INode::Ideal(PhaseGVN *phase, bool can_reshape) {
assert( x != andl && y != andl, "dead loop in ConvL2INode::Ideal" );
if (phase->type(x) == Type::TOP) return NULL;
if (phase->type(y) == Type::TOP) return NULL;
Node *add1 = phase->transform(new (phase->C) ConvL2INode(x));
Node *add2 = phase->transform(new (phase->C) ConvL2INode(y));
return new (phase->C) AddINode(add1,add2);
Node *add1 = phase->transform(new ConvL2INode(x));
Node *add2 = phase->transform(new ConvL2INode(y));
return new AddINode(add1,add2);
}
// Disable optimization: LoadL->ConvL2I ==> LoadI.

168
hotspot/src/share/vm/opto/divnode.cpp
View File

@ -106,7 +106,7 @@ static Node *transform_int_divide( PhaseGVN *phase, Node *dividend, jint divisor
// division by +/- 1
if (!d_pos) {
// Just negate the value
q = new (phase->C) SubINode(phase->intcon(0), dividend);
q = new SubINode(phase->intcon(0), dividend);
}
} else if ( is_power_of_2(d) ) {
// division by +/- a power of 2
@ -143,18 +143,18 @@ static Node *transform_int_divide( PhaseGVN *phase, Node *dividend, jint divisor
// (-2+3)>>2 becomes 0, etc.
// Compute 0 or -1, based on sign bit
Node *sign = phase->transform(new (phase->C) RShiftINode(dividend, phase->intcon(N - 1)));
Node *sign = phase->transform(new RShiftINode(dividend, phase->intcon(N - 1)));
// Mask sign bit to the low sign bits
Node *round = phase->transform(new (phase->C) URShiftINode(sign, phase->intcon(N - l)));
Node *round = phase->transform(new URShiftINode(sign, phase->intcon(N - l)));
// Round up before shifting
dividend = phase->transform(new (phase->C) AddINode(dividend, round));
dividend = phase->transform(new AddINode(dividend, round));
}
// Shift for division
q = new (phase->C) RShiftINode(dividend, phase->intcon(l));
q = new RShiftINode(dividend, phase->intcon(l));
if (!d_pos) {
q = new (phase->C) SubINode(phase->intcon(0), phase->transform(q));
q = new SubINode(phase->intcon(0), phase->transform(q));
}
} else {
// Attempt the jint constant divide -> multiply transform found in
@ -166,33 +166,33 @@ static Node *transform_int_divide( PhaseGVN *phase, Node *dividend, jint divisor
jint shift_const;
if (magic_int_divide_constants(d, magic_const, shift_const)) {
Node *magic = phase->longcon(magic_const);
Node *dividend_long = phase->transform(new (phase->C) ConvI2LNode(dividend));
Node *dividend_long = phase->transform(new ConvI2LNode(dividend));
// Compute the high half of the dividend x magic multiplication
Node *mul_hi = phase->transform(new (phase->C) MulLNode(dividend_long, magic));
Node *mul_hi = phase->transform(new MulLNode(dividend_long, magic));
if (magic_const < 0) {
mul_hi = phase->transform(new (phase->C) RShiftLNode(mul_hi, phase->intcon(N)));
mul_hi = phase->transform(new (phase->C) ConvL2INode(mul_hi));
mul_hi = phase->transform(new RShiftLNode(mul_hi, phase->intcon(N)));
mul_hi = phase->transform(new ConvL2INode(mul_hi));
// The magic multiplier is too large for a 32 bit constant. We've adjusted
// it down by 2^32, but have to add 1 dividend back in after the multiplication.
// This handles the "overflow" case described by Granlund and Montgomery.
mul_hi = phase->transform(new (phase->C) AddINode(dividend, mul_hi));
mul_hi = phase->transform(new AddINode(dividend, mul_hi));
// Shift over the (adjusted) mulhi
if (shift_const != 0) {
mul_hi = phase->transform(new (phase->C) RShiftINode(mul_hi, phase->intcon(shift_const)));
mul_hi = phase->transform(new RShiftINode(mul_hi, phase->intcon(shift_const)));
}
} else {
// No add is required, we can merge the shifts together.
mul_hi = phase->transform(new (phase->C) RShiftLNode(mul_hi, phase->intcon(N + shift_const)));
mul_hi = phase->transform(new (phase->C) ConvL2INode(mul_hi));
mul_hi = phase->transform(new RShiftLNode(mul_hi, phase->intcon(N + shift_const)));
mul_hi = phase->transform(new ConvL2INode(mul_hi));
}
// Get a 0 or -1 from the sign of the dividend.
Node *addend0 = mul_hi;
Node *addend1 = phase->transform(new (phase->C) RShiftINode(dividend, phase->intcon(N-1)));
Node *addend1 = phase->transform(new RShiftINode(dividend, phase->intcon(N-1)));
// If the divisor is negative, swap the order of the input addends;
// this has the effect of negating the quotient.
@ -202,7 +202,7 @@ static Node *transform_int_divide( PhaseGVN *phase, Node *dividend, jint divisor
// Adjust the final quotient by subtracting -1 (adding 1)
// from the mul_hi.
q = new (phase->C) SubINode(addend0, addend1);
q = new SubINode(addend0, addend1);
}
}
@ -261,7 +261,7 @@ static Node* long_by_long_mulhi(PhaseGVN* phase, Node* dividend, jlong magic_con
// no need to synthesize it in ideal nodes.
if (Matcher::has_match_rule(Op_MulHiL)) {
Node* v = phase->longcon(magic_const);
return new (phase->C) MulHiLNode(dividend, v);
return new MulHiLNode(dividend, v);
}
// Taken from Hacker's Delight, Fig. 8-2. Multiply high signed.
@ -287,11 +287,11 @@ static Node* long_by_long_mulhi(PhaseGVN* phase, Node* dividend, jlong magic_con
const int N = 64;
// Dummy node to keep intermediate nodes alive during construction
Node* hook = new (phase->C) Node(4);
Node* hook = new Node(4);
// u0 = u & 0xFFFFFFFF; u1 = u >> 32;
Node* u0 = phase->transform(new (phase->C) AndLNode(dividend, phase->longcon(0xFFFFFFFF)));
Node* u1 = phase->transform(new (phase->C) RShiftLNode(dividend, phase->intcon(N / 2)));
Node* u0 = phase->transform(new AndLNode(dividend, phase->longcon(0xFFFFFFFF)));
Node* u1 = phase->transform(new RShiftLNode(dividend, phase->intcon(N / 2)));
hook->init_req(0, u0);
hook->init_req(1, u1);
@ -300,29 +300,29 @@ static Node* long_by_long_mulhi(PhaseGVN* phase, Node* dividend, jlong magic_con
Node* v1 = phase->longcon(magic_const >> (N / 2));
// w0 = u0*v0;
Node* w0 = phase->transform(new (phase->C) MulLNode(u0, v0));
Node* w0 = phase->transform(new MulLNode(u0, v0));
// t = u1*v0 + (w0 >> 32);
Node* u1v0 = phase->transform(new (phase->C) MulLNode(u1, v0));
Node* temp = phase->transform(new (phase->C) URShiftLNode(w0, phase->intcon(N / 2)));
Node* t = phase->transform(new (phase->C) AddLNode(u1v0, temp));
Node* u1v0 = phase->transform(new MulLNode(u1, v0));
Node* temp = phase->transform(new URShiftLNode(w0, phase->intcon(N / 2)));
Node* t = phase->transform(new AddLNode(u1v0, temp));
hook->init_req(2, t);
// w1 = t & 0xFFFFFFFF;
Node* w1 = phase->transform(new (phase->C) AndLNode(t, phase->longcon(0xFFFFFFFF)));
Node* w1 = phase->transform(new AndLNode(t, phase->longcon(0xFFFFFFFF)));
hook->init_req(3, w1);
// w2 = t >> 32;
Node* w2 = phase->transform(new (phase->C) RShiftLNode(t, phase->intcon(N / 2)));
Node* w2 = phase->transform(new RShiftLNode(t, phase->intcon(N / 2)));
// w1 = u0*v1 + w1;
Node* u0v1 = phase->transform(new (phase->C) MulLNode(u0, v1));
w1 = phase->transform(new (phase->C) AddLNode(u0v1, w1));
Node* u0v1 = phase->transform(new MulLNode(u0, v1));
w1 = phase->transform(new AddLNode(u0v1, w1));
// return u1*v1 + w2 + (w1 >> 32);
Node* u1v1 = phase->transform(new (phase->C) MulLNode(u1, v1));
Node* temp1 = phase->transform(new (phase->C) AddLNode(u1v1, w2));
Node* temp2 = phase->transform(new (phase->C) RShiftLNode(w1, phase->intcon(N / 2)));
Node* u1v1 = phase->transform(new MulLNode(u1, v1));
Node* temp1 = phase->transform(new AddLNode(u1v1, w2));
Node* temp2 = phase->transform(new RShiftLNode(w1, phase->intcon(N / 2)));
// Remove the bogus extra edges used to keep things alive
PhaseIterGVN* igvn = phase->is_IterGVN();
@ -334,7 +334,7 @@ static Node* long_by_long_mulhi(PhaseGVN* phase, Node* dividend, jlong magic_con
}
}
return new (phase->C) AddLNode(temp1, temp2);
return new AddLNode(temp1, temp2);
}
@ -357,7 +357,7 @@ static Node *transform_long_divide( PhaseGVN *phase, Node *dividend, jlong divis
// division by +/- 1
if (!d_pos) {
// Just negate the value
q = new (phase->C) SubLNode(phase->longcon(0), dividend);
q = new SubLNode(phase->longcon(0), dividend);
}
} else if ( is_power_of_2_long(d) ) {
@ -396,18 +396,18 @@ static Node *transform_long_divide( PhaseGVN *phase, Node *dividend, jlong divis
// (-2+3)>>2 becomes 0, etc.
// Compute 0 or -1, based on sign bit
Node *sign = phase->transform(new (phase->C) RShiftLNode(dividend, phase->intcon(N - 1)));
Node *sign = phase->transform(new RShiftLNode(dividend, phase->intcon(N - 1)));
// Mask sign bit to the low sign bits
Node *round = phase->transform(new (phase->C) URShiftLNode(sign, phase->intcon(N - l)));
Node *round = phase->transform(new URShiftLNode(sign, phase->intcon(N - l)));
// Round up before shifting
dividend = phase->transform(new (phase->C) AddLNode(dividend, round));
dividend = phase->transform(new AddLNode(dividend, round));
}
// Shift for division
q = new (phase->C) RShiftLNode(dividend, phase->intcon(l));
q = new RShiftLNode(dividend, phase->intcon(l));
if (!d_pos) {
q = new (phase->C) SubLNode(phase->longcon(0), phase->transform(q));
q = new SubLNode(phase->longcon(0), phase->transform(q));
}
} else if ( !Matcher::use_asm_for_ldiv_by_con(d) ) { // Use hardware DIV instruction when
// it is faster than code generated below.
@ -427,17 +427,17 @@ static Node *transform_long_divide( PhaseGVN *phase, Node *dividend, jlong divis
// The magic multiplier is too large for a 64 bit constant. We've adjusted
// it down by 2^64, but have to add 1 dividend back in after the multiplication.
// This handles the "overflow" case described by Granlund and Montgomery.
mul_hi = phase->transform(new (phase->C) AddLNode(dividend, mul_hi));
mul_hi = phase->transform(new AddLNode(dividend, mul_hi));
}
// Shift over the (adjusted) mulhi
if (shift_const != 0) {
mul_hi = phase->transform(new (phase->C) RShiftLNode(mul_hi, phase->intcon(shift_const)));
mul_hi = phase->transform(new RShiftLNode(mul_hi, phase->intcon(shift_const)));
}
// Get a 0 or -1 from the sign of the dividend.
Node *addend0 = mul_hi;
Node *addend1 = phase->transform(new (phase->C) RShiftLNode(dividend, phase->intcon(N-1)));
Node *addend1 = phase->transform(new RShiftLNode(dividend, phase->intcon(N-1)));
// If the divisor is negative, swap the order of the input addends;
// this has the effect of negating the quotient.
@ -447,7 +447,7 @@ static Node *transform_long_divide( PhaseGVN *phase, Node *dividend, jlong divis
// Adjust the final quotient by subtracting -1 (adding 1)
// from the mul_hi.
q = new (phase->C) SubLNode(addend0, addend1);
q = new SubLNode(addend0, addend1);
}
}
@ -737,7 +737,7 @@ Node *DivFNode::Ideal(PhaseGVN *phase, bool can_reshape) {
assert( frexp((double)reciprocal, &exp) == 0.5, "reciprocal should be power of 2" );
// return multiplication by the reciprocal
return (new (phase->C) MulFNode(in(1), phase->makecon(TypeF::make(reciprocal))));
return (new MulFNode(in(1), phase->makecon(TypeF::make(reciprocal))));
}
//=============================================================================
@ -831,7 +831,7 @@ Node *DivDNode::Ideal(PhaseGVN *phase, bool can_reshape) {
assert( frexp(reciprocal, &exp) == 0.5, "reciprocal should be power of 2" );
// return multiplication by the reciprocal
return (new (phase->C) MulDNode(in(1), phase->makecon(TypeD::make(reciprocal))));
return (new MulDNode(in(1), phase->makecon(TypeD::make(reciprocal))));
}
//=============================================================================
@ -858,7 +858,7 @@ Node *ModINode::Ideal(PhaseGVN *phase, bool can_reshape) {
if( !ti->is_con() ) return NULL;
jint con = ti->get_con();
Node *hook = new (phase->C) Node(1);
Node *hook = new Node(1);
// First, special check for modulo 2^k-1
if( con >= 0 && con < max_jint && is_power_of_2(con+1) ) {
@ -878,24 +878,24 @@ Node *ModINode::Ideal(PhaseGVN *phase, bool can_reshape) {
hook->init_req(0, x); // Add a use to x to prevent him from dying
// Generate code to reduce X rapidly to nearly 2^k-1.
for( int i = 0; i < trip_count; i++ ) {
Node *xl = phase->transform( new (phase->C) AndINode(x,divisor) );
Node *xh = phase->transform( new (phase->C) RShiftINode(x,phase->intcon(k)) ); // Must be signed
x = phase->transform( new (phase->C) AddINode(xh,xl) );
Node *xl = phase->transform( new AndINode(x,divisor) );
Node *xh = phase->transform( new RShiftINode(x,phase->intcon(k)) ); // Must be signed
x = phase->transform( new AddINode(xh,xl) );
hook->set_req(0, x);
}
// Generate sign-fixup code. Was original value positive?
// int hack_res = (i >= 0) ? divisor : 1;
Node *cmp1 = phase->transform( new (phase->C) CmpINode( in(1), phase->intcon(0) ) );
Node *bol1 = phase->transform( new (phase->C) BoolNode( cmp1, BoolTest::ge ) );
Node *cmov1= phase->transform( new (phase->C) CMoveINode(bol1, phase->intcon(1), divisor, TypeInt::POS) );
Node *cmp1 = phase->transform( new CmpINode( in(1), phase->intcon(0) ) );
Node *bol1 = phase->transform( new BoolNode( cmp1, BoolTest::ge ) );
Node *cmov1= phase->transform( new CMoveINode(bol1, phase->intcon(1), divisor, TypeInt::POS) );
// if( x >= hack_res ) x -= divisor;
Node *sub = phase->transform( new (phase->C) SubINode( x, divisor ) );
Node *cmp2 = phase->transform( new (phase->C) CmpINode( x, cmov1 ) );
Node *bol2 = phase->transform( new (phase->C) BoolNode( cmp2, BoolTest::ge ) );
Node *sub = phase->transform( new SubINode( x, divisor ) );
Node *cmp2 = phase->transform( new CmpINode( x, cmov1 ) );
Node *bol2 = phase->transform( new BoolNode( cmp2, BoolTest::ge ) );
// Convention is to not transform the return value of an Ideal
// since Ideal is expected to return a modified 'this' or a new node.
Node *cmov2= new (phase->C) CMoveINode(bol2, x, sub, TypeInt::INT);
Node *cmov2= new CMoveINode(bol2, x, sub, TypeInt::INT);
// cmov2 is now the mod
// Now remove the bogus extra edges used to keep things alive
@ -918,7 +918,7 @@ Node *ModINode::Ideal(PhaseGVN *phase, bool can_reshape) {
jint pos_con = (con >= 0) ? con : -con;
// integer Mod 1 is always 0
if( pos_con == 1 ) return new (phase->C) ConINode(TypeInt::ZERO);
if( pos_con == 1 ) return new ConINode(TypeInt::ZERO);
int log2_con = -1;
@ -931,7 +931,7 @@ Node *ModINode::Ideal(PhaseGVN *phase, bool can_reshape) {
// See if this can be masked, if the dividend is non-negative
if( dti && dti->_lo >= 0 )
return ( new (phase->C) AndINode( in(1), phase->intcon( pos_con-1 ) ) );
return ( new AndINode( in(1), phase->intcon( pos_con-1 ) ) );
}
// Save in(1) so that it cannot be changed or deleted
@ -946,12 +946,12 @@ Node *ModINode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node *mult = NULL;
if( log2_con >= 0 )
mult = phase->transform( new (phase->C) LShiftINode( divide, phase->intcon( log2_con ) ) );
mult = phase->transform( new LShiftINode( divide, phase->intcon( log2_con ) ) );
else
mult = phase->transform( new (phase->C) MulINode( divide, phase->intcon( pos_con ) ) );
mult = phase->transform( new MulINode( divide, phase->intcon( pos_con ) ) );
// Finally, subtract the multiplied divided value from the original
result = new (phase->C) SubINode( in(1), mult );
result = new SubINode( in(1), mult );
}
// Now remove the bogus extra edges used to keep things alive
@ -1029,7 +1029,7 @@ Node *ModLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
if( !tl->is_con() ) return NULL;
jlong con = tl->get_con();
Node *hook = new (phase->C) Node(1);
Node *hook = new Node(1);
// Expand mod
if( con >= 0 && con < max_jlong && is_power_of_2_long(con+1) ) {
@ -1051,24 +1051,24 @@ Node *ModLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
hook->init_req(0, x); // Add a use to x to prevent him from dying
// Generate code to reduce X rapidly to nearly 2^k-1.
for( int i = 0; i < trip_count; i++ ) {
Node *xl = phase->transform( new (phase->C) AndLNode(x,divisor) );
Node *xh = phase->transform( new (phase->C) RShiftLNode(x,phase->intcon(k)) ); // Must be signed
x = phase->transform( new (phase->C) AddLNode(xh,xl) );
Node *xl = phase->transform( new AndLNode(x,divisor) );
Node *xh = phase->transform( new RShiftLNode(x,phase->intcon(k)) ); // Must be signed
x = phase->transform( new AddLNode(xh,xl) );
hook->set_req(0, x); // Add a use to x to prevent him from dying
}
// Generate sign-fixup code. Was original value positive?
// long hack_res = (i >= 0) ? divisor : CONST64(1);
Node *cmp1 = phase->transform( new (phase->C) CmpLNode( in(1), phase->longcon(0) ) );
Node *bol1 = phase->transform( new (phase->C) BoolNode( cmp1, BoolTest::ge ) );
Node *cmov1= phase->transform( new (phase->C) CMoveLNode(bol1, phase->longcon(1), divisor, TypeLong::LONG) );
Node *cmp1 = phase->transform( new CmpLNode( in(1), phase->longcon(0) ) );
Node *bol1 = phase->transform( new BoolNode( cmp1, BoolTest::ge ) );
Node *cmov1= phase->transform( new CMoveLNode(bol1, phase->longcon(1), divisor, TypeLong::LONG) );
// if( x >= hack_res ) x -= divisor;
Node *sub = phase->transform( new (phase->C) SubLNode( x, divisor ) );
Node *cmp2 = phase->transform( new (phase->C) CmpLNode( x, cmov1 ) );
Node *bol2 = phase->transform( new (phase->C) BoolNode( cmp2, BoolTest::ge ) );
Node *sub = phase->transform( new SubLNode( x, divisor ) );
Node *cmp2 = phase->transform( new CmpLNode( x, cmov1 ) );
Node *bol2 = phase->transform( new BoolNode( cmp2, BoolTest::ge ) );
// Convention is to not transform the return value of an Ideal
// since Ideal is expected to return a modified 'this' or a new node.
Node *cmov2= new (phase->C) CMoveLNode(bol2, x, sub, TypeLong::LONG);
Node *cmov2= new CMoveLNode(bol2, x, sub, TypeLong::LONG);
// cmov2 is now the mod
// Now remove the bogus extra edges used to keep things alive
@ -1091,7 +1091,7 @@ Node *ModLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
jlong pos_con = (con >= 0) ? con : -con;
// integer Mod 1 is always 0
if( pos_con == 1 ) return new (phase->C) ConLNode(TypeLong::ZERO);
if( pos_con == 1 ) return new ConLNode(TypeLong::ZERO);
int log2_con = -1;
@ -1104,7 +1104,7 @@ Node *ModLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// See if this can be masked, if the dividend is non-negative
if( dtl && dtl->_lo >= 0 )
return ( new (phase->C) AndLNode( in(1), phase->longcon( pos_con-1 ) ) );
return ( new AndLNode( in(1), phase->longcon( pos_con-1 ) ) );
}
// Save in(1) so that it cannot be changed or deleted
@ -1119,12 +1119,12 @@ Node *ModLNode::Ideal(PhaseGVN *phase, bool can_reshape) {
Node *mult = NULL;
if( log2_con >= 0 )
mult = phase->transform( new (phase->C) LShiftLNode( divide, phase->intcon( log2_con ) ) );
mult = phase->transform( new LShiftLNode( divide, phase->intcon( log2_con ) ) );
else
mult = phase->transform( new (phase->C) MulLNode( divide, phase->longcon( pos_con ) ) );
mult = phase->transform( new MulLNode( divide, phase->longcon( pos_con ) ) );
// Finally, subtract the multiplied divided value from the original
result = new (phase->C) SubLNode( in(1), mult );
result = new SubLNode( in(1), mult );
}
// Now remove the bogus extra edges used to keep things alive
@ -1279,9 +1279,9 @@ DivModINode* DivModINode::make(Compile* C, Node* div_or_mod) {
assert(n->Opcode() == Op_DivI || n->Opcode() == Op_ModI,
"only div or mod input pattern accepted");
DivModINode* divmod = new (C) DivModINode(n->in(0), n->in(1), n->in(2));
Node* dproj = new (C) ProjNode(divmod, DivModNode::div_proj_num);
Node* mproj = new (C) ProjNode(divmod, DivModNode::mod_proj_num);
DivModINode* divmod = new DivModINode(n->in(0), n->in(1), n->in(2));
Node* dproj = new ProjNode(divmod, DivModNode::div_proj_num);
Node* mproj = new ProjNode(divmod, DivModNode::mod_proj_num);
return divmod;
}
@ -1291,9 +1291,9 @@ DivModLNode* DivModLNode::make(Compile* C, Node* div_or_mod) {
assert(n->Opcode() == Op_DivL || n->Opcode() == Op_ModL,
"only div or mod input pattern accepted");
DivModLNode* divmod = new (C) DivModLNode(n->in(0), n->in(1), n->in(2));
Node* dproj = new (C) ProjNode(divmod, DivModNode::div_proj_num);
Node* mproj = new (C) ProjNode(divmod, DivModNode::mod_proj_num);
DivModLNode* divmod = new DivModLNode(n->in(0), n->in(1), n->in(2));
Node* dproj = new ProjNode(divmod, DivModNode::div_proj_num);
Node* mproj = new ProjNode(divmod, DivModNode::mod_proj_num);
return divmod;
}
@ -1308,7 +1308,7 @@ Node *DivModINode::match( const ProjNode *proj, const Matcher *match ) {
assert(proj->_con == mod_proj_num, "must be div or mod projection");
rm = match->modI_proj_mask();
}
return new (match->C)MachProjNode(this, proj->_con, rm, ideal_reg);
return new MachProjNode(this, proj->_con, rm, ideal_reg);
}
@ -1323,5 +1323,5 @@ Node *DivModLNode::match( const ProjNode *proj, const Matcher *match ) {
assert(proj->_con == mod_proj_num, "must be div or mod projection");
rm = match->modL_proj_mask();
}
return new (match->C)MachProjNode(this, proj->_con, rm, ideal_reg);
return new MachProjNode(this, proj->_con, rm, ideal_reg);
}

22
hotspot/src/share/vm/opto/doCall.cpp
View File

@ -119,12 +119,12 @@ CallGenerator* Compile::call_generator(ciMethod* callee, int vtable_index, bool
if (allow_inline && allow_intrinsics) {
CallGenerator* cg = find_intrinsic(callee, call_does_dispatch);
if (cg != NULL) {
if (cg->is_predicted()) {
if (cg->is_predicated()) {
// Code without intrinsic but, hopefully, inlined.
CallGenerator* inline_cg = this->call_generator(callee,
vtable_index, call_does_dispatch, jvms, allow_inline, prof_factor, speculative_receiver_type, false);
if (inline_cg != NULL) {
cg = CallGenerator::for_predicted_intrinsic(cg, inline_cg);
cg = CallGenerator::for_predicated_intrinsic(cg, inline_cg);
}
}
@ -525,7 +525,7 @@ void Parse::do_call() {
// because exceptions don't return to the call site.)
profile_call(receiver);
JVMState* new_jvms = cg->generate(jvms, this);
JVMState* new_jvms = cg->generate(jvms);
if (new_jvms == NULL) {
// When inlining attempt fails (e.g., too many arguments),
// it may contaminate the current compile state, making it
@ -539,7 +539,7 @@ void Parse::do_call() {
// intrinsic was expecting to optimize. Should always be possible to
// get a normal java call that may inline in that case
cg = C->call_generator(cg->method(), vtable_index, call_does_dispatch, jvms, try_inline, prof_factor(), speculative_receiver_type, /* allow_intrinsics= */ false);
new_jvms = cg->generate(jvms, this);
new_jvms = cg->generate(jvms);
if (new_jvms == NULL) {
guarantee(failing(), "call failed to generate: calls should work");
return;
@ -596,7 +596,7 @@ void Parse::do_call() {
const Type* sig_type = TypeOopPtr::make_from_klass(ctype->as_klass());
if (arg_type != NULL && !arg_type->higher_equal(sig_type)) {
Node* retnode = pop();
Node* cast_obj = _gvn.transform(new (C) CheckCastPPNode(control(), retnode, sig_type));
Node* cast_obj = _gvn.transform(new CheckCastPPNode(control(), retnode, sig_type));
push(cast_obj);
}
}
@ -689,7 +689,7 @@ void Parse::catch_call_exceptions(ciExceptionHandlerStream& handlers) {
}
int len = bcis->length();
CatchNode *cn = new (C) CatchNode(control(), i_o, len+1);
CatchNode *cn = new CatchNode(control(), i_o, len+1);
Node *catch_ = _gvn.transform(cn);
// now branch with the exception state to each of the (potential)
@ -700,14 +700,14 @@ void Parse::catch_call_exceptions(ciExceptionHandlerStream& handlers) {
// Locals are just copied from before the call.
// Get control from the CatchNode.
int handler_bci = bcis->at(i);
Node* ctrl = _gvn.transform( new (C) CatchProjNode(catch_, i+1,handler_bci));
Node* ctrl = _gvn.transform( new CatchProjNode(catch_, i+1,handler_bci));
// This handler cannot happen?
if (ctrl == top()) continue;
set_control(ctrl);
// Create exception oop
const TypeInstPtr* extype = extypes->at(i)->is_instptr();
Node *ex_oop = _gvn.transform(new (C) CreateExNode(extypes->at(i), ctrl, i_o));
Node *ex_oop = _gvn.transform(new CreateExNode(extypes->at(i), ctrl, i_o));
// Handle unloaded exception classes.
if (saw_unloaded->contains(handler_bci)) {
@ -746,7 +746,7 @@ void Parse::catch_call_exceptions(ciExceptionHandlerStream& handlers) {
// The first CatchProj is for the normal return.
// (Note: If this is a call to rethrow_Java, this node goes dead.)
set_control(_gvn.transform( new (C) CatchProjNode(catch_, CatchProjNode::fall_through_index, CatchProjNode::no_handler_bci)));
set_control(_gvn.transform( new CatchProjNode(catch_, CatchProjNode::fall_through_index, CatchProjNode::no_handler_bci)));
}
@ -797,7 +797,7 @@ void Parse::catch_inline_exceptions(SafePointNode* ex_map) {
// I'm loading the class from, I can replace the LoadKlass with the
// klass constant for the exception oop.
if( ex_node->is_Phi() ) {
ex_klass_node = new (C) PhiNode( ex_node->in(0), TypeKlassPtr::OBJECT );
ex_klass_node = new PhiNode( ex_node->in(0), TypeKlassPtr::OBJECT );
for( uint i = 1; i < ex_node->req(); i++ ) {
Node* p = basic_plus_adr( ex_node->in(i), ex_node->in(i), oopDesc::klass_offset_in_bytes() );
Node* k = _gvn.transform( LoadKlassNode::make(_gvn, immutable_memory(), p, TypeInstPtr::KLASS, TypeKlassPtr::OBJECT) );
@ -863,7 +863,7 @@ void Parse::catch_inline_exceptions(SafePointNode* ex_map) {
PreserveJVMState pjvms(this);
const TypeInstPtr* tinst = TypeOopPtr::make_from_klass_unique(klass)->cast_to_ptr_type(TypePtr::NotNull)->is_instptr();
assert(klass->has_subklass() || tinst->klass_is_exact(), "lost exactness");
Node* ex_oop = _gvn.transform(new (C) CheckCastPPNode(control(), ex_node, tinst));
Node* ex_oop = _gvn.transform(new CheckCastPPNode(control(), ex_node, tinst));
push_ex_oop(ex_oop); // Push exception oop for handler
#ifndef PRODUCT
if (PrintOpto && WizardMode) {

10
hotspot/src/share/vm/opto/escape.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2014, 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
@ -939,7 +939,13 @@ void ConnectionGraph::process_call_arguments(CallNode *call) {
strcmp(call->as_CallLeaf()->_name, "aescrypt_encryptBlock") == 0 ||
strcmp(call->as_CallLeaf()->_name, "aescrypt_decryptBlock") == 0 ||
strcmp(call->as_CallLeaf()->_name, "cipherBlockChaining_encryptAESCrypt") == 0 ||
strcmp(call->as_CallLeaf()->_name, "cipherBlockChaining_decryptAESCrypt") == 0)
strcmp(call->as_CallLeaf()->_name, "cipherBlockChaining_decryptAESCrypt") == 0 ||
strcmp(call->as_CallLeaf()->_name, "sha1_implCompress") == 0 ||
strcmp(call->as_CallLeaf()->_name, "sha1_implCompressMB") == 0 ||
strcmp(call->as_CallLeaf()->_name, "sha256_implCompress") == 0 ||
strcmp(call->as_CallLeaf()->_name, "sha256_implCompressMB") == 0 ||
strcmp(call->as_CallLeaf()->_name, "sha512_implCompress") == 0 ||
strcmp(call->as_CallLeaf()->_name, "sha512_implCompressMB") == 0)
))) {
call->dump();
fatal(err_msg_res("EA unexpected CallLeaf %s", call->as_CallLeaf()->_name));

75
hotspot/src/share/vm/opto/generateOptoStub.cpp
View File

@ -50,7 +50,7 @@ void GraphKit::gen_stub(address C_function,
const TypeTuple *jrange = C->tf()->range();
// The procedure start
StartNode* start = new (C) StartNode(root(), jdomain);
StartNode* start = new StartNode(root(), jdomain);
_gvn.set_type_bottom(start);
// Make a map, with JVM state
@ -64,7 +64,7 @@ void GraphKit::gen_stub(address C_function,
jvms->set_scloff(max_map);
jvms->set_endoff(max_map);
{
SafePointNode *map = new (C) SafePointNode( max_map, jvms );
SafePointNode *map = new SafePointNode( max_map, jvms );
jvms->set_map(map);
set_jvms(jvms);
assert(map == this->map(), "kit.map is set");
@ -73,7 +73,7 @@ void GraphKit::gen_stub(address C_function,
// Make up the parameters
uint i;
for( i = 0; i < parm_cnt; i++ )
map()->init_req(i, _gvn.transform(new (C) ParmNode(start, i)));
map()->init_req(i, _gvn.transform(new ParmNode(start, i)));
for( ; i<map()->req(); i++ )
map()->init_req(i, top()); // For nicer debugging
@ -81,7 +81,7 @@ void GraphKit::gen_stub(address C_function,
set_all_memory(map()->memory());
// Get base of thread-local storage area
Node* thread = _gvn.transform( new (C) ThreadLocalNode() );
Node* thread = _gvn.transform( new ThreadLocalNode() );
const int NoAlias = Compile::AliasIdxBot;
@ -166,8 +166,7 @@ void GraphKit::gen_stub(address C_function,
//-----------------------------
// Make the call node
CallRuntimeNode *call = new (C)
CallRuntimeNode(c_sig, C_function, name, TypePtr::BOTTOM);
CallRuntimeNode *call = new CallRuntimeNode(c_sig, C_function, name, TypePtr::BOTTOM);
//-----------------------------
// Fix-up the debug info for the call
@ -184,7 +183,7 @@ void GraphKit::gen_stub(address C_function,
for (; i < parm_cnt; i++) { // Regular input arguments
// Convert ints to longs if required.
if (CCallingConventionRequiresIntsAsLongs && jdomain->field_at(i)->isa_int()) {
Node* int_as_long = _gvn.transform(new (C) ConvI2LNode(map()->in(i)));
Node* int_as_long = _gvn.transform(new ConvI2LNode(map()->in(i)));
call->init_req(cnt++, int_as_long); // long
call->init_req(cnt++, top()); // half
} else {
@ -200,23 +199,23 @@ void GraphKit::gen_stub(address C_function,
//-----------------------------
// Now set up the return results
set_control( _gvn.transform( new (C) ProjNode(call,TypeFunc::Control)) );
set_i_o( _gvn.transform( new (C) ProjNode(call,TypeFunc::I_O )) );
set_control( _gvn.transform( new ProjNode(call,TypeFunc::Control)) );
set_i_o( _gvn.transform( new ProjNode(call,TypeFunc::I_O )) );
set_all_memory_call(call);
if (range->cnt() > TypeFunc::Parms) {
Node* retnode = _gvn.transform( new (C) ProjNode(call,TypeFunc::Parms) );
Node* retnode = _gvn.transform( new ProjNode(call,TypeFunc::Parms) );
// C-land is allowed to return sub-word values. Convert to integer type.
assert( retval != Type::TOP, "" );
if (retval == TypeInt::BOOL) {
retnode = _gvn.transform( new (C) AndINode(retnode, intcon(0xFF)) );
retnode = _gvn.transform( new AndINode(retnode, intcon(0xFF)) );
} else if (retval == TypeInt::CHAR) {
retnode = _gvn.transform( new (C) AndINode(retnode, intcon(0xFFFF)) );
retnode = _gvn.transform( new AndINode(retnode, intcon(0xFFFF)) );
} else if (retval == TypeInt::BYTE) {
retnode = _gvn.transform( new (C) LShiftINode(retnode, intcon(24)) );
retnode = _gvn.transform( new (C) RShiftINode(retnode, intcon(24)) );
retnode = _gvn.transform( new LShiftINode(retnode, intcon(24)) );
retnode = _gvn.transform( new RShiftINode(retnode, intcon(24)) );
} else if (retval == TypeInt::SHORT) {
retnode = _gvn.transform( new (C) LShiftINode(retnode, intcon(16)) );
retnode = _gvn.transform( new (C) RShiftINode(retnode, intcon(16)) );
retnode = _gvn.transform( new LShiftINode(retnode, intcon(16)) );
retnode = _gvn.transform( new RShiftINode(retnode, intcon(16)) );
}
map()->set_req( TypeFunc::Parms, retnode );
}
@ -253,21 +252,21 @@ void GraphKit::gen_stub(address C_function,
Node* exit_memory = reset_memory();
Node* cmp = _gvn.transform( new (C) CmpPNode(pending, null()) );
Node* bo = _gvn.transform( new (C) BoolNode(cmp, BoolTest::ne) );
Node* cmp = _gvn.transform( new CmpPNode(pending, null()) );
Node* bo = _gvn.transform( new BoolNode(cmp, BoolTest::ne) );
IfNode *iff = create_and_map_if(control(), bo, PROB_MIN, COUNT_UNKNOWN);
Node* if_null = _gvn.transform( new (C) IfFalseNode(iff) );
Node* if_not_null = _gvn.transform( new (C) IfTrueNode(iff) );
Node* if_null = _gvn.transform( new IfFalseNode(iff) );
Node* if_not_null = _gvn.transform( new IfTrueNode(iff) );
assert (StubRoutines::forward_exception_entry() != NULL, "must be generated before");
Node *exc_target = makecon(TypeRawPtr::make( StubRoutines::forward_exception_entry() ));
Node *to_exc = new (C) TailCallNode(if_not_null,
i_o(),
exit_memory,
frameptr(),
returnadr(),
exc_target, null());
Node *to_exc = new TailCallNode(if_not_null,
i_o(),
exit_memory,
frameptr(),
returnadr(),
exc_target, null());
root()->add_req(_gvn.transform(to_exc)); // bind to root to keep live
C->init_start(start);
@ -277,27 +276,27 @@ void GraphKit::gen_stub(address C_function,
switch( is_fancy_jump ) {
case 0: // Make a return instruction
// Return to caller, free any space for return address
ret = new (C) ReturnNode(TypeFunc::Parms, if_null,
i_o(),
exit_memory,
frameptr(),
returnadr());
ret = new ReturnNode(TypeFunc::Parms, if_null,
i_o(),
exit_memory,
frameptr(),
returnadr());
if (C->tf()->range()->cnt() > TypeFunc::Parms)
ret->add_req( map()->in(TypeFunc::Parms) );
break;
case 1: // This is a fancy tail-call jump. Jump to computed address.
// Jump to new callee; leave old return address alone.
ret = new (C) TailCallNode(if_null,
i_o(),
exit_memory,
frameptr(),
returnadr(),
target, map()->in(TypeFunc::Parms));
ret = new TailCallNode(if_null,
i_o(),
exit_memory,
frameptr(),
returnadr(),
target, map()->in(TypeFunc::Parms));
break;
case 2: // Pop return address & jump
// Throw away old return address; jump to new computed address
//assert(C_function == CAST_FROM_FN_PTR(address, OptoRuntime::rethrow_C), "fancy_jump==2 only for rethrow");
ret = new (C) TailJumpNode(if_null,
ret = new TailJumpNode(if_null,
i_o(),
exit_memory,
frameptr(),

395
hotspot/src/share/vm/opto/graphKit.cpp
View File

@ -294,7 +294,7 @@ JVMState* GraphKit::transfer_exceptions_into_jvms() {
JVMState* jvms = new (C) JVMState(_method, NULL);
jvms->set_bci(_bci);
jvms->set_sp(_sp);
jvms->set_map(new (C) SafePointNode(TypeFunc::Parms, jvms));
jvms->set_map(new SafePointNode(TypeFunc::Parms, jvms));
set_jvms(jvms);
for (uint i = 0; i < map()->req(); i++) map()->init_req(i, top());
set_all_memory(top());
@ -347,7 +347,7 @@ void GraphKit::combine_exception_states(SafePointNode* ex_map, SafePointNode* ph
if (region->in(0) != hidden_merge_mark) {
// The control input is not (yet) a specially-marked region in phi_map.
// Make it so, and build some phis.
region = new (C) RegionNode(2);
region = new RegionNode(2);
_gvn.set_type(region, Type::CONTROL);
region->set_req(0, hidden_merge_mark); // marks an internal ex-state
region->init_req(1, phi_map->control());
@ -432,6 +432,7 @@ void GraphKit::combine_exception_states(SafePointNode* ex_map, SafePointNode* ph
}
}
}
phi_map->merge_replaced_nodes_with(ex_map);
}
//--------------------------use_exception_state--------------------------------
@ -496,13 +497,13 @@ void GraphKit::uncommon_trap_if_should_post_on_exceptions(Deoptimization::DeoptR
// take the uncommon_trap in the BuildCutout below.
// first must access the should_post_on_exceptions_flag in this thread's JavaThread
Node* jthread = _gvn.transform(new (C) ThreadLocalNode());
Node* jthread = _gvn.transform(new ThreadLocalNode());
Node* adr = basic_plus_adr(top(), jthread, in_bytes(JavaThread::should_post_on_exceptions_flag_offset()));
Node* should_post_flag = make_load(control(), adr, TypeInt::INT, T_INT, Compile::AliasIdxRaw, MemNode::unordered);
// Test the should_post_on_exceptions_flag vs. 0
Node* chk = _gvn.transform( new (C) CmpINode(should_post_flag, intcon(0)) );
Node* tst = _gvn.transform( new (C) BoolNode(chk, BoolTest::eq) );
Node* chk = _gvn.transform( new CmpINode(should_post_flag, intcon(0)) );
Node* tst = _gvn.transform( new BoolNode(chk, BoolTest::eq) );
// Branch to slow_path if should_post_on_exceptions_flag was true
{ BuildCutout unless(this, tst, PROB_MAX);
@ -645,7 +646,6 @@ PreserveJVMState::PreserveJVMState(GraphKit* kit, bool clone_map) {
_map = kit->map(); // preserve the map
_sp = kit->sp();
kit->set_map(clone_map ? kit->clone_map() : NULL);
Compile::current()->inc_preserve_jvm_state();
#ifdef ASSERT
_bci = kit->bci();
Parse* parser = kit->is_Parse();
@ -663,7 +663,6 @@ PreserveJVMState::~PreserveJVMState() {
#endif
kit->set_map(_map);
kit->set_sp(_sp);
Compile::current()->dec_preserve_jvm_state();
}
@ -675,8 +674,8 @@ BuildCutout::BuildCutout(GraphKit* kit, Node* p, float prob, float cnt)
SafePointNode* outer_map = _map; // preserved map is caller's
SafePointNode* inner_map = kit->map();
IfNode* iff = kit->create_and_map_if(outer_map->control(), p, prob, cnt);
outer_map->set_control(kit->gvn().transform( new (kit->C) IfTrueNode(iff) ));
inner_map->set_control(kit->gvn().transform( new (kit->C) IfFalseNode(iff) ));
outer_map->set_control(kit->gvn().transform( new IfTrueNode(iff) ));
inner_map->set_control(kit->gvn().transform( new IfFalseNode(iff) ));
}
BuildCutout::~BuildCutout() {
GraphKit* kit = _kit;
@ -1118,7 +1117,7 @@ bool GraphKit::compute_stack_effects(int& inputs, int& depth) {
Node* GraphKit::basic_plus_adr(Node* base, Node* ptr, Node* offset) {
// short-circuit a common case
if (offset == intcon(0)) return ptr;
return _gvn.transform( new (C) AddPNode(base, ptr, offset) );
return _gvn.transform( new AddPNode(base, ptr, offset) );
}
Node* GraphKit::ConvI2L(Node* offset) {
@ -1127,7 +1126,7 @@ Node* GraphKit::ConvI2L(Node* offset) {
if (offset_con != Type::OffsetBot) {
return longcon((jlong) offset_con);
}
return _gvn.transform( new (C) ConvI2LNode(offset));
return _gvn.transform( new ConvI2LNode(offset));
}
Node* GraphKit::ConvI2UL(Node* offset) {
@ -1135,9 +1134,9 @@ Node* GraphKit::ConvI2UL(Node* offset) {
if (offset_con != (juint) Type::OffsetBot) {
return longcon((julong) offset_con);
}
Node* conv = _gvn.transform( new (C) ConvI2LNode(offset));
Node* conv = _gvn.transform( new ConvI2LNode(offset));
Node* mask = _gvn.transform( ConLNode::make(C, (julong) max_juint) );
return _gvn.transform( new (C) AndLNode(conv, mask) );
return _gvn.transform( new AndLNode(conv, mask) );
}
Node* GraphKit::ConvL2I(Node* offset) {
@ -1146,7 +1145,7 @@ Node* GraphKit::ConvL2I(Node* offset) {
if (offset_con != (jlong)Type::OffsetBot) {
return intcon((int) offset_con);
}
return _gvn.transform( new (C) ConvL2INode(offset));
return _gvn.transform( new ConvL2INode(offset));
}
//-------------------------load_object_klass-----------------------------------
@ -1165,7 +1164,7 @@ Node* GraphKit::load_array_length(Node* array) {
Node *alen;
if (alloc == NULL) {
Node *r_adr = basic_plus_adr(array, arrayOopDesc::length_offset_in_bytes());
alen = _gvn.transform( new (C) LoadRangeNode(0, immutable_memory(), r_adr, TypeInt::POS));
alen = _gvn.transform( new LoadRangeNode(0, immutable_memory(), r_adr, TypeInt::POS));
} else {
alen = alloc->Ideal_length();
Node* ccast = alloc->make_ideal_length(_gvn.type(array)->is_oopptr(), &_gvn);
@ -1199,8 +1198,8 @@ Node* GraphKit::null_check_common(Node* value, BasicType type,
// Construct NULL check
Node *chk = NULL;
switch(type) {
case T_LONG : chk = new (C) CmpLNode(value, _gvn.zerocon(T_LONG)); break;
case T_INT : chk = new (C) CmpINode(value, _gvn.intcon(0)); break;
case T_LONG : chk = new CmpLNode(value, _gvn.zerocon(T_LONG)); break;
case T_INT : chk = new CmpINode(value, _gvn.intcon(0)); break;
case T_ARRAY : // fall through
type = T_OBJECT; // simplify further tests
case T_OBJECT : {
@ -1247,7 +1246,7 @@ Node* GraphKit::null_check_common(Node* value, BasicType type,
return value; // Elided null check quickly!
}
}
chk = new (C) CmpPNode( value, null() );
chk = new CmpPNode( value, null() );
break;
}
@ -1258,7 +1257,7 @@ Node* GraphKit::null_check_common(Node* value, BasicType type,
chk = _gvn.transform(chk);
BoolTest::mask btest = assert_null ? BoolTest::eq : BoolTest::ne;
BoolNode *btst = new (C) BoolNode( chk, btest);
BoolNode *btst = new BoolNode( chk, btest);
Node *tst = _gvn.transform( btst );
//-----------
@ -1325,8 +1324,8 @@ Node* GraphKit::null_check_common(Node* value, BasicType type,
if (null_control != NULL) {
IfNode* iff = create_and_map_if(control(), tst, ok_prob, COUNT_UNKNOWN);
Node* null_true = _gvn.transform( new (C) IfFalseNode(iff));
set_control( _gvn.transform( new (C) IfTrueNode(iff)));
Node* null_true = _gvn.transform( new IfFalseNode(iff));
set_control( _gvn.transform( new IfTrueNode(iff)));
if (null_true == top())
explicit_null_checks_elided++;
(*null_control) = null_true;
@ -1378,7 +1377,7 @@ Node* GraphKit::cast_not_null(Node* obj, bool do_replace_in_map) {
// Object is already not-null?
if( t == t_not_null ) return obj;
Node *cast = new (C) CastPPNode(obj,t_not_null);
Node *cast = new CastPPNode(obj,t_not_null);
cast->init_req(0, control());
cast = _gvn.transform( cast );
@ -1403,60 +1402,17 @@ void GraphKit::replace_in_map(Node* old, Node* neww) {
// on the map. This includes locals, stack, and monitors
// of the current (innermost) JVM state.
if (!ReplaceInParentMaps) {
// don't let inconsistent types from profiling escape this
// method
const Type* told = _gvn.type(old);
const Type* tnew = _gvn.type(neww);
if (!tnew->higher_equal(told)) {
return;
}
// PreserveJVMState doesn't do a deep copy so we can't modify
// parents
if (Compile::current()->has_preserve_jvm_state()) {
return;
}
Parse* parser = is_Parse();
bool progress = true;
Node* ctrl = map()->in(0);
// Follow the chain of parsers and see whether the update can be
// done in the map of callers. We can do the replace for a caller if
// the current control post dominates the control of a caller.
while (parser != NULL && parser->caller() != NULL && progress) {
progress = false;
Node* parent_map = parser->caller()->map();
assert(parser->exits().map()->jvms()->depth() == parser->caller()->depth(), "map mismatch");
Node* parent_ctrl = parent_map->in(0);
while (parent_ctrl->is_Region()) {
Node* n = parent_ctrl->as_Region()->is_copy();
if (n == NULL) {
break;
}
parent_ctrl = n;
}
for (;;) {
if (ctrl == parent_ctrl) {
// update the map of the exits which is the one that will be
// used when compilation resume after inlining
parser->exits().map()->replace_edge(old, neww);
progress = true;
break;
}
if (ctrl->is_Proj() && ctrl->as_Proj()->is_uncommon_trap_if_pattern(Deoptimization::Reason_none)) {
ctrl = ctrl->in(0)->in(0);
} else if (ctrl->is_Region()) {
Node* n = ctrl->as_Region()->is_copy();
if (n == NULL) {
break;
}
ctrl = n;
} else {
break;
}
}
parser = parser->parent_parser();
}
map()->record_replaced_node(old, neww);
}
@ -1486,7 +1442,7 @@ void GraphKit::set_all_memory(Node* newmem) {
//------------------------------set_all_memory_call----------------------------
void GraphKit::set_all_memory_call(Node* call, bool separate_io_proj) {
Node* newmem = _gvn.transform( new (C) ProjNode(call, TypeFunc::Memory, separate_io_proj) );
Node* newmem = _gvn.transform( new ProjNode(call, TypeFunc::Memory, separate_io_proj) );
set_all_memory(newmem);
}
@ -1721,9 +1677,9 @@ Node* GraphKit::array_element_address(Node* ary, Node* idx, BasicType elembt,
int index_max = max_jint - 1; // array size is max_jint, index is one less
if (sizetype != NULL) index_max = sizetype->_hi - 1;
const TypeLong* lidxtype = TypeLong::make(CONST64(0), index_max, Type::WidenMax);
idx = _gvn.transform( new (C) ConvI2LNode(idx, lidxtype) );
idx = _gvn.transform( new ConvI2LNode(idx, lidxtype) );
#endif
Node* scale = _gvn.transform( new (C) LShiftXNode(idx, intcon(shift)) );
Node* scale = _gvn.transform( new LShiftXNode(idx, intcon(shift)) );
return basic_plus_adr(ary, base, scale);
}
@ -1771,8 +1727,8 @@ void GraphKit::set_edges_for_java_call(CallJavaNode* call, bool must_throw, bool
// Re-use the current map to produce the result.
set_control(_gvn.transform(new (C) ProjNode(call, TypeFunc::Control)));
set_i_o( _gvn.transform(new (C) ProjNode(call, TypeFunc::I_O , separate_io_proj)));
set_control(_gvn.transform(new ProjNode(call, TypeFunc::Control)));
set_i_o( _gvn.transform(new ProjNode(call, TypeFunc::I_O , separate_io_proj)));
set_all_memory_call(xcall, separate_io_proj);
//return xcall; // no need, caller already has it
@ -1786,7 +1742,7 @@ Node* GraphKit::set_results_for_java_call(CallJavaNode* call, bool separate_io_p
if (call->method() == NULL ||
call->method()->return_type()->basic_type() == T_VOID)
ret = top();
else ret = _gvn.transform(new (C) ProjNode(call, TypeFunc::Parms));
else ret = _gvn.transform(new ProjNode(call, TypeFunc::Parms));
// Note: Since any out-of-line call can produce an exception,
// we always insert an I_O projection from the call into the result.
@ -1797,8 +1753,8 @@ Node* GraphKit::set_results_for_java_call(CallJavaNode* call, bool separate_io_p
// The caller requested separate projections be used by the fall
// through and exceptional paths, so replace the projections for
// the fall through path.
set_i_o(_gvn.transform( new (C) ProjNode(call, TypeFunc::I_O) ));
set_all_memory(_gvn.transform( new (C) ProjNode(call, TypeFunc::Memory) ));
set_i_o(_gvn.transform( new ProjNode(call, TypeFunc::I_O) ));
set_all_memory(_gvn.transform( new ProjNode(call, TypeFunc::Memory) ));
}
return ret;
}
@ -1838,13 +1794,13 @@ void GraphKit::set_predefined_output_for_runtime_call(Node* call,
Node* keep_mem,
const TypePtr* hook_mem) {
// no i/o
set_control(_gvn.transform( new (C) ProjNode(call,TypeFunc::Control) ));
set_control(_gvn.transform( new ProjNode(call,TypeFunc::Control) ));
if (keep_mem) {
// First clone the existing memory state
set_all_memory(keep_mem);
if (hook_mem != NULL) {
// Make memory for the call
Node* mem = _gvn.transform( new (C) ProjNode(call, TypeFunc::Memory) );
Node* mem = _gvn.transform( new ProjNode(call, TypeFunc::Memory) );
// Set the RawPtr memory state only. This covers all the heap top/GC stuff
// We also use hook_mem to extract specific effects from arraycopy stubs.
set_memory(mem, hook_mem);
@ -1864,12 +1820,16 @@ void GraphKit::set_predefined_output_for_runtime_call(Node* call,
// Replace the call with the current state of the kit.
void GraphKit::replace_call(CallNode* call, Node* result) {
void GraphKit::replace_call(CallNode* call, Node* result, bool do_replaced_nodes) {
JVMState* ejvms = NULL;
if (has_exceptions()) {
ejvms = transfer_exceptions_into_jvms();
}
ReplacedNodes replaced_nodes = map()->replaced_nodes();
ReplacedNodes replaced_nodes_exception;
Node* ex_ctl = top();
SafePointNode* final_state = stop();
// Find all the needed outputs of this call
@ -1886,6 +1846,10 @@ void GraphKit::replace_call(CallNode* call, Node* result) {
C->gvn_replace_by(callprojs.fallthrough_catchproj, final_ctl);
}
if (callprojs.fallthrough_memproj != NULL) {
if (final_mem->is_MergeMem()) {
// Parser's exits MergeMem was not transformed but may be optimized
final_mem = _gvn.transform(final_mem);
}
C->gvn_replace_by(callprojs.fallthrough_memproj, final_mem);
}
if (callprojs.fallthrough_ioproj != NULL) {
@ -1917,10 +1881,13 @@ void GraphKit::replace_call(CallNode* call, Node* result) {
// Load my combined exception state into the kit, with all phis transformed:
SafePointNode* ex_map = ekit.combine_and_pop_all_exception_states();
replaced_nodes_exception = ex_map->replaced_nodes();
Node* ex_oop = ekit.use_exception_state(ex_map);
if (callprojs.catchall_catchproj != NULL) {
C->gvn_replace_by(callprojs.catchall_catchproj, ekit.control());
ex_ctl = ekit.control();
}
if (callprojs.catchall_memproj != NULL) {
C->gvn_replace_by(callprojs.catchall_memproj, ekit.reset_memory());
@ -1953,6 +1920,13 @@ void GraphKit::replace_call(CallNode* call, Node* result) {
_gvn.transform(wl.pop());
}
}
if (callprojs.fallthrough_catchproj != NULL && !final_ctl->is_top() && do_replaced_nodes) {
replaced_nodes.apply(C, final_ctl);
}
if (!ex_ctl->is_top() && do_replaced_nodes) {
replaced_nodes_exception.apply(C, ex_ctl);
}
}
@ -1968,7 +1942,7 @@ void GraphKit::increment_counter(Node* counter_addr) {
int adr_type = Compile::AliasIdxRaw;
Node* ctrl = control();
Node* cnt = make_load(ctrl, counter_addr, TypeInt::INT, T_INT, adr_type, MemNode::unordered);
Node* incr = _gvn.transform(new (C) AddINode(cnt, _gvn.intcon(1)));
Node* incr = _gvn.transform(new AddINode(cnt, _gvn.intcon(1)));
store_to_memory(ctrl, counter_addr, incr, T_INT, adr_type, MemNode::unordered);
}
@ -2087,7 +2061,7 @@ void GraphKit::uncommon_trap(int trap_request,
// The debug info is the only real input to this call.
// Halt-and-catch fire here. The above call should never return!
HaltNode* halt = new(C) HaltNode(control(), frameptr());
HaltNode* halt = new HaltNode(control(), frameptr());
_gvn.set_type_bottom(halt);
root()->add_req(halt);
@ -2169,7 +2143,7 @@ Node* GraphKit::record_profile_for_speculation(Node* n, ciKlass* exact_kls, bool
// the new type. The new type depends on the control: what
// profiling tells us is only valid from here as far as we can
// tell.
Node* cast = new(C) CheckCastPPNode(control(), n, current_type->remove_speculative()->join_speculative(spec_type));
Node* cast = new CheckCastPPNode(control(), n, current_type->remove_speculative()->join_speculative(spec_type));
cast = _gvn.transform(cast);
replace_in_map(n, cast);
n = cast;
@ -2287,7 +2261,7 @@ void GraphKit::round_double_result(ciMethod* dest_method) {
Node* GraphKit::precision_rounding(Node* n) {
return UseStrictFP && _method->flags().is_strict()
&& UseSSE == 0 && Matcher::strict_fp_requires_explicit_rounding
? _gvn.transform( new (C) RoundFloatNode(0, n) )
? _gvn.transform( new RoundFloatNode(0, n) )
: n;
}
@ -2295,7 +2269,7 @@ Node* GraphKit::precision_rounding(Node* n) {
Node* GraphKit::dprecision_rounding(Node *n) {
return UseStrictFP && _method->flags().is_strict()
&& UseSSE <= 1 && Matcher::strict_fp_requires_explicit_rounding
? _gvn.transform( new (C) RoundDoubleNode(0, n) )
? _gvn.transform( new RoundDoubleNode(0, n) )
: n;
}
@ -2303,7 +2277,7 @@ Node* GraphKit::dprecision_rounding(Node *n) {
Node* GraphKit::dstore_rounding(Node* n) {
return Matcher::strict_fp_requires_explicit_rounding
&& UseSSE <= 1
? _gvn.transform( new (C) RoundDoubleNode(0, n) )
? _gvn.transform( new RoundDoubleNode(0, n) )
: n;
}
@ -2382,11 +2356,11 @@ Node* GraphKit::opt_iff(Node* region, Node* iff) {
IfNode *opt_iff = _gvn.transform(iff)->as_If();
// Fast path taken; set region slot 2
Node *fast_taken = _gvn.transform( new (C) IfFalseNode(opt_iff) );
Node *fast_taken = _gvn.transform( new IfFalseNode(opt_iff) );
region->init_req(2,fast_taken); // Capture fast-control
// Fast path not-taken, i.e. slow path
Node *slow_taken = _gvn.transform( new (C) IfTrueNode(opt_iff) );
Node *slow_taken = _gvn.transform( new IfTrueNode(opt_iff) );
return slow_taken;
}
@ -2410,12 +2384,12 @@ Node* GraphKit::make_runtime_call(int flags,
}
CallNode* call;
if (!is_leaf) {
call = new(C) CallStaticJavaNode(call_type, call_addr, call_name,
call = new CallStaticJavaNode(call_type, call_addr, call_name,
bci(), adr_type);
} else if (flags & RC_NO_FP) {
call = new(C) CallLeafNoFPNode(call_type, call_addr, call_name, adr_type);
call = new CallLeafNoFPNode(call_type, call_addr, call_name, adr_type);
} else {
call = new(C) CallLeafNode(call_type, call_addr, call_name, adr_type);
call = new CallLeafNode(call_type, call_addr, call_name, adr_type);
}
// The following is similar to set_edges_for_java_call,
@ -2476,7 +2450,7 @@ Node* GraphKit::make_runtime_call(int flags,
}
if (has_io) {
set_i_o(_gvn.transform(new (C) ProjNode(call, TypeFunc::I_O)));
set_i_o(_gvn.transform(new ProjNode(call, TypeFunc::I_O)));
}
return call;
@ -2490,48 +2464,55 @@ void GraphKit::merge_memory(Node* new_mem, Node* region, int new_path) {
Node* new_slice = mms.memory2();
if (old_slice != new_slice) {
PhiNode* phi;
if (new_slice->is_Phi() && new_slice->as_Phi()->region() == region) {
phi = new_slice->as_Phi();
#ifdef ASSERT
if (old_slice->is_Phi() && old_slice->as_Phi()->region() == region)
old_slice = old_slice->in(new_path);
// Caller is responsible for ensuring that any pre-existing
// phis are already aware of old memory.
int old_path = (new_path > 1) ? 1 : 2; // choose old_path != new_path
assert(phi->in(old_path) == old_slice, "pre-existing phis OK");
#endif
mms.set_memory(phi);
if (old_slice->is_Phi() && old_slice->as_Phi()->region() == region) {
if (mms.is_empty()) {
// clone base memory Phi's inputs for this memory slice
assert(old_slice == mms.base_memory(), "sanity");
phi = PhiNode::make(region, NULL, Type::MEMORY, mms.adr_type(C));
_gvn.set_type(phi, Type::MEMORY);
for (uint i = 1; i < phi->req(); i++) {
phi->init_req(i, old_slice->in(i));
}
} else {
phi = old_slice->as_Phi(); // Phi was generated already
}
} else {
phi = PhiNode::make(region, old_slice, Type::MEMORY, mms.adr_type(C));
_gvn.set_type(phi, Type::MEMORY);
phi->set_req(new_path, new_slice);
mms.set_memory(_gvn.transform(phi)); // assume it is complete
}
phi->set_req(new_path, new_slice);
mms.set_memory(phi);
}
}
}
//------------------------------make_slow_call_ex------------------------------
// Make the exception handler hookups for the slow call
void GraphKit::make_slow_call_ex(Node* call, ciInstanceKlass* ex_klass, bool separate_io_proj) {
void GraphKit::make_slow_call_ex(Node* call, ciInstanceKlass* ex_klass, bool separate_io_proj, bool deoptimize) {
if (stopped()) return;
// Make a catch node with just two handlers: fall-through and catch-all
Node* i_o = _gvn.transform( new (C) ProjNode(call, TypeFunc::I_O, separate_io_proj) );
Node* catc = _gvn.transform( new (C) CatchNode(control(), i_o, 2) );
Node* norm = _gvn.transform( new (C) CatchProjNode(catc, CatchProjNode::fall_through_index, CatchProjNode::no_handler_bci) );
Node* excp = _gvn.transform( new (C) CatchProjNode(catc, CatchProjNode::catch_all_index, CatchProjNode::no_handler_bci) );
Node* i_o = _gvn.transform( new ProjNode(call, TypeFunc::I_O, separate_io_proj) );
Node* catc = _gvn.transform( new CatchNode(control(), i_o, 2) );
Node* norm = _gvn.transform( new CatchProjNode(catc, CatchProjNode::fall_through_index, CatchProjNode::no_handler_bci) );
Node* excp = _gvn.transform( new CatchProjNode(catc, CatchProjNode::catch_all_index, CatchProjNode::no_handler_bci) );
{ PreserveJVMState pjvms(this);
set_control(excp);
set_i_o(i_o);
if (excp != top()) {
// Create an exception state also.
// Use an exact type if the caller has specified a specific exception.
const Type* ex_type = TypeOopPtr::make_from_klass_unique(ex_klass)->cast_to_ptr_type(TypePtr::NotNull);
Node* ex_oop = new (C) CreateExNode(ex_type, control(), i_o);
add_exception_state(make_exception_state(_gvn.transform(ex_oop)));
if (deoptimize) {
// Deoptimize if an exception is caught. Don't construct exception state in this case.
uncommon_trap(Deoptimization::Reason_unhandled,
Deoptimization::Action_none);
} else {
// Create an exception state also.
// Use an exact type if the caller has specified a specific exception.
const Type* ex_type = TypeOopPtr::make_from_klass_unique(ex_klass)->cast_to_ptr_type(TypePtr::NotNull);
Node* ex_oop = new CreateExNode(ex_type, control(), i_o);
add_exception_state(make_exception_state(_gvn.transform(ex_oop)));
}
}
}
@ -2580,11 +2561,11 @@ Node* GraphKit::gen_subtype_check(Node* subklass, Node* superklass) {
case SSC_easy_test:
{
// Just do a direct pointer compare and be done.
Node* cmp = _gvn.transform( new(C) CmpPNode(subklass, superklass) );
Node* bol = _gvn.transform( new(C) BoolNode(cmp, BoolTest::eq) );
Node* cmp = _gvn.transform( new CmpPNode(subklass, superklass) );
Node* bol = _gvn.transform( new BoolNode(cmp, BoolTest::eq) );
IfNode* iff = create_and_xform_if(control(), bol, PROB_STATIC_FREQUENT, COUNT_UNKNOWN);
set_control( _gvn.transform( new(C) IfTrueNode (iff) ) );
return _gvn.transform( new(C) IfFalseNode(iff) );
set_control( _gvn.transform( new IfTrueNode (iff) ) );
return _gvn.transform( new IfFalseNode(iff) );
}
case SSC_full_test:
break;
@ -2599,7 +2580,7 @@ Node* GraphKit::gen_subtype_check(Node* subklass, Node* superklass) {
// First load the super-klass's check-offset
Node *p1 = basic_plus_adr( superklass, superklass, in_bytes(Klass::super_check_offset_offset()) );
Node *chk_off = _gvn.transform(new (C) LoadINode(NULL, memory(p1), p1, _gvn.type(p1)->is_ptr(),
Node *chk_off = _gvn.transform(new LoadINode(NULL, memory(p1), p1, _gvn.type(p1)->is_ptr(),
TypeInt::INT, MemNode::unordered));
int cacheoff_con = in_bytes(Klass::secondary_super_cache_offset());
bool might_be_cache = (find_int_con(chk_off, cacheoff_con) == cacheoff_con);
@ -2611,7 +2592,7 @@ Node* GraphKit::gen_subtype_check(Node* subklass, Node* superklass) {
// Worst-case type is a little odd: NULL is allowed as a result (usually
// klass loads can never produce a NULL).
Node *chk_off_X = ConvI2X(chk_off);
Node *p2 = _gvn.transform( new (C) AddPNode(subklass,subklass,chk_off_X) );
Node *p2 = _gvn.transform( new AddPNode(subklass,subklass,chk_off_X) );
// For some types like interfaces the following loadKlass is from a 1-word
// cache which is mutable so can't use immutable memory. Other
// types load from the super-class display table which is immutable.
@ -2625,11 +2606,11 @@ Node* GraphKit::gen_subtype_check(Node* subklass, Node* superklass) {
// See if we get an immediate positive hit. Happens roughly 83% of the
// time. Test to see if the value loaded just previously from the subklass
// is exactly the superklass.
Node *cmp1 = _gvn.transform( new (C) CmpPNode( superklass, nkls ) );
Node *bol1 = _gvn.transform( new (C) BoolNode( cmp1, BoolTest::eq ) );
Node *cmp1 = _gvn.transform( new CmpPNode( superklass, nkls ) );
Node *bol1 = _gvn.transform( new BoolNode( cmp1, BoolTest::eq ) );
IfNode *iff1 = create_and_xform_if( control(), bol1, PROB_LIKELY(0.83f), COUNT_UNKNOWN );
Node *iftrue1 = _gvn.transform( new (C) IfTrueNode ( iff1 ) );
set_control( _gvn.transform( new (C) IfFalseNode( iff1 ) ) );
Node *iftrue1 = _gvn.transform( new IfTrueNode ( iff1 ) );
set_control( _gvn.transform( new IfFalseNode( iff1 ) ) );
// Compile speed common case: Check for being deterministic right now. If
// chk_off is a constant and not equal to cacheoff then we are NOT a
@ -2642,9 +2623,9 @@ Node* GraphKit::gen_subtype_check(Node* subklass, Node* superklass) {
}
// Gather the various success & failures here
RegionNode *r_ok_subtype = new (C) RegionNode(4);
RegionNode *r_ok_subtype = new RegionNode(4);
record_for_igvn(r_ok_subtype);
RegionNode *r_not_subtype = new (C) RegionNode(3);
RegionNode *r_not_subtype = new RegionNode(3);
record_for_igvn(r_not_subtype);
r_ok_subtype->init_req(1, iftrue1);
@ -2655,20 +2636,20 @@ Node* GraphKit::gen_subtype_check(Node* subklass, Node* superklass) {
// cache. If it points to the display (and NOT the cache) and the display
// missed then it's not a subtype.
Node *cacheoff = _gvn.intcon(cacheoff_con);
Node *cmp2 = _gvn.transform( new (C) CmpINode( chk_off, cacheoff ) );
Node *bol2 = _gvn.transform( new (C) BoolNode( cmp2, BoolTest::ne ) );
Node *cmp2 = _gvn.transform( new CmpINode( chk_off, cacheoff ) );
Node *bol2 = _gvn.transform( new BoolNode( cmp2, BoolTest::ne ) );
IfNode *iff2 = create_and_xform_if( control(), bol2, PROB_LIKELY(0.63f), COUNT_UNKNOWN );
r_not_subtype->init_req(1, _gvn.transform( new (C) IfTrueNode (iff2) ) );
set_control( _gvn.transform( new (C) IfFalseNode(iff2) ) );
r_not_subtype->init_req(1, _gvn.transform( new IfTrueNode (iff2) ) );
set_control( _gvn.transform( new IfFalseNode(iff2) ) );
// Check for self. Very rare to get here, but it is taken 1/3 the time.
// No performance impact (too rare) but allows sharing of secondary arrays
// which has some footprint reduction.
Node *cmp3 = _gvn.transform( new (C) CmpPNode( subklass, superklass ) );
Node *bol3 = _gvn.transform( new (C) BoolNode( cmp3, BoolTest::eq ) );
Node *cmp3 = _gvn.transform( new CmpPNode( subklass, superklass ) );
Node *bol3 = _gvn.transform( new BoolNode( cmp3, BoolTest::eq ) );
IfNode *iff3 = create_and_xform_if( control(), bol3, PROB_LIKELY(0.36f), COUNT_UNKNOWN );
r_ok_subtype->init_req(2, _gvn.transform( new (C) IfTrueNode ( iff3 ) ) );
set_control( _gvn.transform( new (C) IfFalseNode( iff3 ) ) );
r_ok_subtype->init_req(2, _gvn.transform( new IfTrueNode ( iff3 ) ) );
set_control( _gvn.transform( new IfFalseNode( iff3 ) ) );
// -- Roads not taken here: --
// We could also have chosen to perform the self-check at the beginning
@ -2692,13 +2673,13 @@ Node* GraphKit::gen_subtype_check(Node* subklass, Node* superklass) {
// The decision to inline or out-of-line this final check is platform
// dependent, and is found in the AD file definition of PartialSubtypeCheck.
Node* psc = _gvn.transform(
new (C) PartialSubtypeCheckNode(control(), subklass, superklass) );
new PartialSubtypeCheckNode(control(), subklass, superklass) );
Node *cmp4 = _gvn.transform( new (C) CmpPNode( psc, null() ) );
Node *bol4 = _gvn.transform( new (C) BoolNode( cmp4, BoolTest::ne ) );
Node *cmp4 = _gvn.transform( new CmpPNode( psc, null() ) );
Node *bol4 = _gvn.transform( new BoolNode( cmp4, BoolTest::ne ) );
IfNode *iff4 = create_and_xform_if( control(), bol4, PROB_FAIR, COUNT_UNKNOWN );
r_not_subtype->init_req(2, _gvn.transform( new (C) IfTrueNode (iff4) ) );
r_ok_subtype ->init_req(3, _gvn.transform( new (C) IfFalseNode(iff4) ) );
r_not_subtype->init_req(2, _gvn.transform( new IfTrueNode (iff4) ) );
r_ok_subtype ->init_req(3, _gvn.transform( new IfFalseNode(iff4) ) );
// Return false path; set default control to true path.
set_control( _gvn.transform(r_ok_subtype) );
@ -2762,18 +2743,18 @@ Node* GraphKit::type_check_receiver(Node* receiver, ciKlass* klass,
const TypeKlassPtr* tklass = TypeKlassPtr::make(klass);
Node* recv_klass = load_object_klass(receiver);
Node* want_klass = makecon(tklass);
Node* cmp = _gvn.transform( new(C) CmpPNode(recv_klass, want_klass) );
Node* bol = _gvn.transform( new(C) BoolNode(cmp, BoolTest::eq) );
Node* cmp = _gvn.transform( new CmpPNode(recv_klass, want_klass) );
Node* bol = _gvn.transform( new BoolNode(cmp, BoolTest::eq) );
IfNode* iff = create_and_xform_if(control(), bol, prob, COUNT_UNKNOWN);
set_control( _gvn.transform( new(C) IfTrueNode (iff) ));
Node* fail = _gvn.transform( new(C) IfFalseNode(iff) );
set_control( _gvn.transform( new IfTrueNode (iff) ));
Node* fail = _gvn.transform( new IfFalseNode(iff) );
const TypeOopPtr* recv_xtype = tklass->as_instance_type();
assert(recv_xtype->klass_is_exact(), "");
// Subsume downstream occurrences of receiver with a cast to
// recv_xtype, since now we know what the type will be.
Node* cast = new(C) CheckCastPPNode(control(), receiver, recv_xtype);
Node* cast = new CheckCastPPNode(control(), receiver, recv_xtype);
(*casted_receiver) = _gvn.transform(cast);
// (User must make the replace_in_map call.)
@ -2920,8 +2901,8 @@ Node* GraphKit::gen_instanceof(Node* obj, Node* superklass, bool safe_for_replac
// Make the merge point
enum { _obj_path = 1, _fail_path, _null_path, PATH_LIMIT };
RegionNode* region = new(C) RegionNode(PATH_LIMIT);
Node* phi = new(C) PhiNode(region, TypeInt::BOOL);
RegionNode* region = new RegionNode(PATH_LIMIT);
Node* phi = new PhiNode(region, TypeInt::BOOL);
C->set_has_split_ifs(true); // Has chance for split-if optimization
ciProfileData* data = NULL;
@ -3052,8 +3033,8 @@ Node* GraphKit::gen_checkcast(Node *obj, Node* superklass,
// Make the merge point
enum { _obj_path = 1, _null_path, PATH_LIMIT };
RegionNode* region = new (C) RegionNode(PATH_LIMIT);
Node* phi = new (C) PhiNode(region, toop);
RegionNode* region = new RegionNode(PATH_LIMIT);
Node* phi = new PhiNode(region, toop);
C->set_has_split_ifs(true); // Has chance for split-if optimization
// Use null-cast information if it is available
@ -3114,8 +3095,7 @@ Node* GraphKit::gen_checkcast(Node *obj, Node* superklass,
Node* not_subtype_ctrl = gen_subtype_check( obj_klass, superklass );
// Plug in success path into the merge
cast_obj = _gvn.transform(new (C) CheckCastPPNode(control(),
not_null_obj, toop));
cast_obj = _gvn.transform(new CheckCastPPNode(control(), not_null_obj, toop));
// Failure path ends in uncommon trap (or may be dead - failure impossible)
if (failure_control == NULL) {
if (not_subtype_ctrl != top()) { // If failure is possible
@ -3168,7 +3148,7 @@ Node* GraphKit::insert_mem_bar(int opcode, Node* precedent) {
mb->init_req(TypeFunc::Control, control());
mb->init_req(TypeFunc::Memory, reset_memory());
Node* membar = _gvn.transform(mb);
set_control(_gvn.transform(new (C) ProjNode(membar, TypeFunc::Control)));
set_control(_gvn.transform(new ProjNode(membar, TypeFunc::Control)));
set_all_memory_call(membar);
return membar;
}
@ -3197,11 +3177,11 @@ Node* GraphKit::insert_mem_bar_volatile(int opcode, int alias_idx, Node* precede
mb->set_req(TypeFunc::Memory, memory(alias_idx));
}
Node* membar = _gvn.transform(mb);
set_control(_gvn.transform(new (C) ProjNode(membar, TypeFunc::Control)));
set_control(_gvn.transform(new ProjNode(membar, TypeFunc::Control)));
if (alias_idx == Compile::AliasIdxBot) {
merged_memory()->set_base_memory(_gvn.transform(new (C) ProjNode(membar, TypeFunc::Memory)));
merged_memory()->set_base_memory(_gvn.transform(new ProjNode(membar, TypeFunc::Memory)));
} else {
set_memory(_gvn.transform(new (C) ProjNode(membar, TypeFunc::Memory)),alias_idx);
set_memory(_gvn.transform(new ProjNode(membar, TypeFunc::Memory)),alias_idx);
}
return membar;
}
@ -3221,10 +3201,10 @@ FastLockNode* GraphKit::shared_lock(Node* obj) {
assert(dead_locals_are_killed(), "should kill locals before sync. point");
// Box the stack location
Node* box = _gvn.transform(new (C) BoxLockNode(next_monitor()));
Node* box = _gvn.transform(new BoxLockNode(next_monitor()));
Node* mem = reset_memory();
FastLockNode * flock = _gvn.transform(new (C) FastLockNode(0, obj, box) )->as_FastLock();
FastLockNode * flock = _gvn.transform(new FastLockNode(0, obj, box) )->as_FastLock();
if (UseBiasedLocking && PrintPreciseBiasedLockingStatistics) {
// Create the counters for this fast lock.
flock->create_lock_counter(sync_jvms()); // sync_jvms used to get current bci
@ -3238,7 +3218,7 @@ FastLockNode* GraphKit::shared_lock(Node* obj) {
map()->push_monitor( flock );
const TypeFunc *tf = LockNode::lock_type();
LockNode *lock = new (C) LockNode(C, tf);
LockNode *lock = new LockNode(C, tf);
lock->init_req( TypeFunc::Control, control() );
lock->init_req( TypeFunc::Memory , mem );
@ -3292,7 +3272,7 @@ void GraphKit::shared_unlock(Node* box, Node* obj) {
insert_mem_bar(Op_MemBarReleaseLock);
const TypeFunc *tf = OptoRuntime::complete_monitor_exit_Type();
UnlockNode *unlock = new (C) UnlockNode(C, tf);
UnlockNode *unlock = new UnlockNode(C, tf);
uint raw_idx = Compile::AliasIdxRaw;
unlock->init_req( TypeFunc::Control, control() );
unlock->init_req( TypeFunc::Memory , memory(raw_idx) );
@ -3353,24 +3333,25 @@ static void hook_memory_on_init(GraphKit& kit, int alias_idx,
//---------------------------set_output_for_allocation-------------------------
Node* GraphKit::set_output_for_allocation(AllocateNode* alloc,
const TypeOopPtr* oop_type) {
const TypeOopPtr* oop_type,
bool deoptimize_on_exception) {
int rawidx = Compile::AliasIdxRaw;
alloc->set_req( TypeFunc::FramePtr, frameptr() );
add_safepoint_edges(alloc);
Node* allocx = _gvn.transform(alloc);
set_control( _gvn.transform(new (C) ProjNode(allocx, TypeFunc::Control) ) );
set_control( _gvn.transform(new ProjNode(allocx, TypeFunc::Control) ) );
// create memory projection for i_o
set_memory ( _gvn.transform( new (C) ProjNode(allocx, TypeFunc::Memory, true) ), rawidx );
make_slow_call_ex(allocx, env()->Throwable_klass(), true);
set_memory ( _gvn.transform( new ProjNode(allocx, TypeFunc::Memory, true) ), rawidx );
make_slow_call_ex(allocx, env()->Throwable_klass(), true, deoptimize_on_exception);
// create a memory projection as for the normal control path
Node* malloc = _gvn.transform(new (C) ProjNode(allocx, TypeFunc::Memory));
Node* malloc = _gvn.transform(new ProjNode(allocx, TypeFunc::Memory));
set_memory(malloc, rawidx);
// a normal slow-call doesn't change i_o, but an allocation does
// we create a separate i_o projection for the normal control path
set_i_o(_gvn.transform( new (C) ProjNode(allocx, TypeFunc::I_O, false) ) );
Node* rawoop = _gvn.transform( new (C) ProjNode(allocx, TypeFunc::Parms) );
set_i_o(_gvn.transform( new ProjNode(allocx, TypeFunc::I_O, false) ) );
Node* rawoop = _gvn.transform( new ProjNode(allocx, TypeFunc::Parms) );
// put in an initialization barrier
InitializeNode* init = insert_mem_bar_volatile(Op_Initialize, rawidx,
@ -3406,7 +3387,7 @@ Node* GraphKit::set_output_for_allocation(AllocateNode* alloc,
}
// Cast raw oop to the real thing...
Node* javaoop = new (C) CheckCastPPNode(control(), rawoop, oop_type);
Node* javaoop = new CheckCastPPNode(control(), rawoop, oop_type);
javaoop = _gvn.transform(javaoop);
C->set_recent_alloc(control(), javaoop);
assert(just_allocated_object(control()) == javaoop, "just allocated");
@ -3439,9 +3420,11 @@ Node* GraphKit::set_output_for_allocation(AllocateNode* alloc,
// The optional arguments are for specialized use by intrinsics:
// - If 'extra_slow_test' if not null is an extra condition for the slow-path.
// - If 'return_size_val', report the the total object size to the caller.
// - deoptimize_on_exception controls how Java exceptions are handled (rethrow vs deoptimize)
Node* GraphKit::new_instance(Node* klass_node,
Node* extra_slow_test,
Node* *return_size_val) {
Node* *return_size_val,
bool deoptimize_on_exception) {
// Compute size in doublewords
// The size is always an integral number of doublewords, represented
// as a positive bytewise size stored in the klass's layout_helper.
@ -3465,9 +3448,9 @@ Node* GraphKit::new_instance(Node* klass_node,
// (It may be stress-tested by specifying StressReflectiveCode.)
// Basically, we want to get into the VM is there's an illegal argument.
Node* bit = intcon(Klass::_lh_instance_slow_path_bit);
initial_slow_test = _gvn.transform( new (C) AndINode(layout_val, bit) );
initial_slow_test = _gvn.transform( new AndINode(layout_val, bit) );
if (extra_slow_test != intcon(0)) {
initial_slow_test = _gvn.transform( new (C) OrINode(initial_slow_test, extra_slow_test) );
initial_slow_test = _gvn.transform( new OrINode(initial_slow_test, extra_slow_test) );
}
// (Macro-expander will further convert this to a Bool, if necessary.)
}
@ -3484,7 +3467,7 @@ Node* GraphKit::new_instance(Node* klass_node,
// Clear the low bits to extract layout_helper_size_in_bytes:
assert((int)Klass::_lh_instance_slow_path_bit < BytesPerLong, "clear bit");
Node* mask = MakeConX(~ (intptr_t)right_n_bits(LogBytesPerLong));
size = _gvn.transform( new (C) AndXNode(size, mask) );
size = _gvn.transform( new AndXNode(size, mask) );
}
if (return_size_val != NULL) {
(*return_size_val) = size;
@ -3504,13 +3487,12 @@ Node* GraphKit::new_instance(Node* klass_node,
Node *mem = reset_memory();
set_all_memory(mem); // Create new memory state
AllocateNode* alloc
= new (C) AllocateNode(C, AllocateNode::alloc_type(Type::TOP),
control(), mem, i_o(),
size, klass_node,
initial_slow_test);
AllocateNode* alloc = new AllocateNode(C, AllocateNode::alloc_type(Type::TOP),
control(), mem, i_o(),
size, klass_node,
initial_slow_test);
return set_output_for_allocation(alloc, oop_type);
return set_output_for_allocation(alloc, oop_type, deoptimize_on_exception);
}
//-------------------------------new_array-------------------------------------
@ -3520,7 +3502,8 @@ Node* GraphKit::new_instance(Node* klass_node,
Node* GraphKit::new_array(Node* klass_node, // array klass (maybe variable)
Node* length, // number of array elements
int nargs, // number of arguments to push back for uncommon trap
Node* *return_size_val) {
Node* *return_size_val,
bool deoptimize_on_exception) {
jint layout_con = Klass::_lh_neutral_value;
Node* layout_val = get_layout_helper(klass_node, layout_con);
int layout_is_con = (layout_val == NULL);
@ -3531,8 +3514,8 @@ Node* GraphKit::new_array(Node* klass_node, // array klass (maybe variable)
// Optimistically assume that it is a subtype of Object[],
// so that we can fold up all the address arithmetic.
layout_con = Klass::array_layout_helper(T_OBJECT);
Node* cmp_lh = _gvn.transform( new(C) CmpINode(layout_val, intcon(layout_con)) );
Node* bol_lh = _gvn.transform( new(C) BoolNode(cmp_lh, BoolTest::eq) );
Node* cmp_lh = _gvn.transform( new CmpINode(layout_val, intcon(layout_con)) );
Node* bol_lh = _gvn.transform( new BoolNode(cmp_lh, BoolTest::eq) );
{ BuildCutout unless(this, bol_lh, PROB_MAX);
inc_sp(nargs);
uncommon_trap(Deoptimization::Reason_class_check,
@ -3556,8 +3539,8 @@ Node* GraphKit::new_array(Node* klass_node, // array klass (maybe variable)
fast_size_limit <<= (LogBytesPerLong - log2_esize);
}
Node* initial_slow_cmp = _gvn.transform( new (C) CmpUNode( length, intcon( fast_size_limit ) ) );
Node* initial_slow_test = _gvn.transform( new (C) BoolNode( initial_slow_cmp, BoolTest::gt ) );
Node* initial_slow_cmp = _gvn.transform( new CmpUNode( length, intcon( fast_size_limit ) ) );
Node* initial_slow_test = _gvn.transform( new BoolNode( initial_slow_cmp, BoolTest::gt ) );
if (initial_slow_test->is_Bool()) {
// Hide it behind a CMoveI, or else PhaseIdealLoop::split_up will get sick.
initial_slow_test = initial_slow_test->as_Bool()->as_int_value(&_gvn);
@ -3585,10 +3568,10 @@ Node* GraphKit::new_array(Node* klass_node, // array klass (maybe variable)
} else {
Node* hss = intcon(Klass::_lh_header_size_shift);
Node* hsm = intcon(Klass::_lh_header_size_mask);
Node* hsize = _gvn.transform( new(C) URShiftINode(layout_val, hss) );
hsize = _gvn.transform( new(C) AndINode(hsize, hsm) );
Node* hsize = _gvn.transform( new URShiftINode(layout_val, hss) );
hsize = _gvn.transform( new AndINode(hsize, hsm) );
Node* mask = intcon(round_mask);
header_size = _gvn.transform( new(C) AddINode(hsize, mask) );
header_size = _gvn.transform( new AddINode(hsize, mask) );
}
Node* elem_shift = NULL;
@ -3613,7 +3596,7 @@ Node* GraphKit::new_array(Node* klass_node, // array klass (maybe variable)
jlong size_max = arrayOopDesc::max_array_length(T_BYTE);
if (size_max > tllen->_hi) size_max = tllen->_hi;
const TypeLong* tlcon = TypeLong::make(CONST64(0), size_max, Type::WidenMin);
lengthx = _gvn.transform( new (C) ConvI2LNode(length, tlcon));
lengthx = _gvn.transform( new ConvI2LNode(length, tlcon));
}
}
#endif
@ -3624,11 +3607,11 @@ Node* GraphKit::new_array(Node* klass_node, // array klass (maybe variable)
// after a successful allocation.
Node* abody = lengthx;
if (elem_shift != NULL)
abody = _gvn.transform( new(C) LShiftXNode(lengthx, elem_shift) );
Node* size = _gvn.transform( new(C) AddXNode(headerx, abody) );
abody = _gvn.transform( new LShiftXNode(lengthx, elem_shift) );
Node* size = _gvn.transform( new AddXNode(headerx, abody) );
if (round_mask != 0) {
Node* mask = MakeConX(~round_mask);
size = _gvn.transform( new(C) AndXNode(size, mask) );
size = _gvn.transform( new AndXNode(size, mask) );
}
// else if round_mask == 0, the size computation is self-rounding
@ -3646,11 +3629,11 @@ Node* GraphKit::new_array(Node* klass_node, // array klass (maybe variable)
// Create the AllocateArrayNode and its result projections
AllocateArrayNode* alloc
= new (C) AllocateArrayNode(C, AllocateArrayNode::alloc_type(TypeInt::INT),
control(), mem, i_o(),
size, klass_node,
initial_slow_test,
length);
= new AllocateArrayNode(C, AllocateArrayNode::alloc_type(TypeInt::INT),
control(), mem, i_o(),
size, klass_node,
initial_slow_test,
length);
// Cast to correct type. Note that the klass_node may be constant or not,
// and in the latter case the actual array type will be inexact also.
@ -3663,7 +3646,7 @@ Node* GraphKit::new_array(Node* klass_node, // array klass (maybe variable)
ary_type = ary_type->is_aryptr()->cast_to_size(length_type);
}
Node* javaoop = set_output_for_allocation(alloc, ary_type);
Node* javaoop = set_output_for_allocation(alloc, ary_type, deoptimize_on_exception);
// Cast length on remaining path to be as narrow as possible
if (map()->find_edge(length) >= 0) {
@ -3760,10 +3743,10 @@ void GraphKit::add_predicate_impl(Deoptimization::DeoptReason reason, int nargs)
}
Node *cont = _gvn.intcon(1);
Node* opq = _gvn.transform(new (C) Opaque1Node(C, cont));
Node *bol = _gvn.transform(new (C) Conv2BNode(opq));
Node* opq = _gvn.transform(new Opaque1Node(C, cont));
Node *bol = _gvn.transform(new Conv2BNode(opq));
IfNode* iff = create_and_map_if(control(), bol, PROB_MAX, COUNT_UNKNOWN);
Node* iffalse = _gvn.transform(new (C) IfFalseNode(iff));
Node* iffalse = _gvn.transform(new IfFalseNode(iff));
C->add_predicate_opaq(opq);
{
PreserveJVMState pjvms(this);
@ -3771,7 +3754,7 @@ void GraphKit::add_predicate_impl(Deoptimization::DeoptReason reason, int nargs)
inc_sp(nargs);
uncommon_trap(reason, Deoptimization::Action_maybe_recompile);
}
Node* iftrue = _gvn.transform(new (C) IfTrueNode(iff));
Node* iftrue = _gvn.transform(new IfTrueNode(iff));
set_control(iftrue);
}
@ -3963,7 +3946,7 @@ void GraphKit::g1_write_barrier_pre(bool do_load,
__ if_then(index, BoolTest::ne, zeroX, likely); {
// decrement the index
Node* next_index = _gvn.transform(new (C) SubXNode(index, __ ConX(sizeof(intptr_t))));
Node* next_index = _gvn.transform(new SubXNode(index, __ ConX(sizeof(intptr_t))));
// Now get the buffer location we will log the previous value into and store it
Node *log_addr = __ AddP(no_base, buffer, next_index);
@ -4006,7 +3989,7 @@ void GraphKit::g1_mark_card(IdealKit& ideal,
// Now do the queue work
__ if_then(index, BoolTest::ne, zeroX); {
Node* next_index = _gvn.transform(new (C) SubXNode(index, __ ConX(sizeof(intptr_t))));
Node* next_index = _gvn.transform(new SubXNode(index, __ ConX(sizeof(intptr_t))));
Node* log_addr = __ AddP(no_base, buffer, next_index);
// Order, see storeCM.
@ -4213,5 +4196,5 @@ void GraphKit::store_String_length(Node* ctrl, Node* str, Node* value) {
Node* GraphKit::cast_array_to_stable(Node* ary, const TypeAryPtr* ary_type) {
// Reify the property as a CastPP node in Ideal graph to comply with monotonicity
// assumption of CCP analysis.
return _gvn.transform(new(C) CastPPNode(ary, ary_type->cast_to_stable(true)));
return _gvn.transform(new CastPPNode(ary, ary_type->cast_to_stable(true)));
}

55
hotspot/src/share/vm/opto/graphKit.hpp
View File

@ -309,31 +309,31 @@ class GraphKit : public Phase {
// Some convenient shortcuts for common nodes
Node* IfTrue(IfNode* iff) { return _gvn.transform(new (C) IfTrueNode(iff)); }
Node* IfFalse(IfNode* iff) { return _gvn.transform(new (C) IfFalseNode(iff)); }
Node* IfTrue(IfNode* iff) { return _gvn.transform(new IfTrueNode(iff)); }
Node* IfFalse(IfNode* iff) { return _gvn.transform(new IfFalseNode(iff)); }
Node* AddI(Node* l, Node* r) { return _gvn.transform(new (C) AddINode(l, r)); }
Node* SubI(Node* l, Node* r) { return _gvn.transform(new (C) SubINode(l, r)); }
Node* MulI(Node* l, Node* r) { return _gvn.transform(new (C) MulINode(l, r)); }
Node* DivI(Node* ctl, Node* l, Node* r) { return _gvn.transform(new (C) DivINode(ctl, l, r)); }
Node* AddI(Node* l, Node* r) { return _gvn.transform(new AddINode(l, r)); }
Node* SubI(Node* l, Node* r) { return _gvn.transform(new SubINode(l, r)); }
Node* MulI(Node* l, Node* r) { return _gvn.transform(new MulINode(l, r)); }
Node* DivI(Node* ctl, Node* l, Node* r) { return _gvn.transform(new DivINode(ctl, l, r)); }
Node* AndI(Node* l, Node* r) { return _gvn.transform(new (C) AndINode(l, r)); }
Node* OrI(Node* l, Node* r) { return _gvn.transform(new (C) OrINode(l, r)); }
Node* XorI(Node* l, Node* r) { return _gvn.transform(new (C) XorINode(l, r)); }
Node* AndI(Node* l, Node* r) { return _gvn.transform(new AndINode(l, r)); }
Node* OrI(Node* l, Node* r) { return _gvn.transform(new OrINode(l, r)); }
Node* XorI(Node* l, Node* r) { return _gvn.transform(new XorINode(l, r)); }
Node* MaxI(Node* l, Node* r) { return _gvn.transform(new (C) MaxINode(l, r)); }
Node* MinI(Node* l, Node* r) { return _gvn.transform(new (C) MinINode(l, r)); }
Node* MaxI(Node* l, Node* r) { return _gvn.transform(new MaxINode(l, r)); }
Node* MinI(Node* l, Node* r) { return _gvn.transform(new MinINode(l, r)); }
Node* LShiftI(Node* l, Node* r) { return _gvn.transform(new (C) LShiftINode(l, r)); }
Node* RShiftI(Node* l, Node* r) { return _gvn.transform(new (C) RShiftINode(l, r)); }
Node* URShiftI(Node* l, Node* r) { return _gvn.transform(new (C) URShiftINode(l, r)); }
Node* LShiftI(Node* l, Node* r) { return _gvn.transform(new LShiftINode(l, r)); }
Node* RShiftI(Node* l, Node* r) { return _gvn.transform(new RShiftINode(l, r)); }
Node* URShiftI(Node* l, Node* r) { return _gvn.transform(new URShiftINode(l, r)); }
Node* CmpI(Node* l, Node* r) { return _gvn.transform(new (C) CmpINode(l, r)); }
Node* CmpL(Node* l, Node* r) { return _gvn.transform(new (C) CmpLNode(l, r)); }
Node* CmpP(Node* l, Node* r) { return _gvn.transform(new (C) CmpPNode(l, r)); }
Node* Bool(Node* cmp, BoolTest::mask relop) { return _gvn.transform(new (C) BoolNode(cmp, relop)); }
Node* CmpI(Node* l, Node* r) { return _gvn.transform(new CmpINode(l, r)); }
Node* CmpL(Node* l, Node* r) { return _gvn.transform(new CmpLNode(l, r)); }
Node* CmpP(Node* l, Node* r) { return _gvn.transform(new CmpPNode(l, r)); }
Node* Bool(Node* cmp, BoolTest::mask relop) { return _gvn.transform(new BoolNode(cmp, relop)); }
Node* AddP(Node* b, Node* a, Node* o) { return _gvn.transform(new (C) AddPNode(b, a, o)); }
Node* AddP(Node* b, Node* a, Node* o) { return _gvn.transform(new AddPNode(b, a, o)); }
// Convert between int and long, and size_t.
// (See macros ConvI2X, etc., in type.hpp for ConvI2X, etc.)
@ -690,7 +690,7 @@ class GraphKit : public Phase {
// Replace the call with the current state of the kit. Requires
// that the call was generated with separate io_projs so that
// exceptional control flow can be handled properly.
void replace_call(CallNode* call, Node* result);
void replace_call(CallNode* call, Node* result, bool do_replaced_nodes = false);
// helper functions for statistics
void increment_counter(address counter_addr); // increment a debug counter
@ -807,7 +807,7 @@ class GraphKit : public Phase {
// merge in all memory slices from new_mem, along the given path
void merge_memory(Node* new_mem, Node* region, int new_path);
void make_slow_call_ex(Node* call, ciInstanceKlass* ex_klass, bool separate_io_proj);
void make_slow_call_ex(Node* call, ciInstanceKlass* ex_klass, bool separate_io_proj, bool deoptimize = false);
// Helper functions to build synchronizations
int next_monitor();
@ -849,13 +849,16 @@ class GraphKit : public Phase {
// implementation of object creation
Node* set_output_for_allocation(AllocateNode* alloc,
const TypeOopPtr* oop_type);
const TypeOopPtr* oop_type,
bool deoptimize_on_exception=false);
Node* get_layout_helper(Node* klass_node, jint& constant_value);
Node* new_instance(Node* klass_node,
Node* slow_test = NULL,
Node* *return_size_val = NULL);
Node* *return_size_val = NULL,
bool deoptimize_on_exception = false);
Node* new_array(Node* klass_node, Node* count_val, int nargs,
Node* *return_size_val = NULL);
Node* *return_size_val = NULL,
bool deoptimize_on_exception = false);
// java.lang.String helpers
Node* load_String_offset(Node* ctrl, Node* str);
@ -867,7 +870,7 @@ class GraphKit : public Phase {
// Handy for making control flow
IfNode* create_and_map_if(Node* ctrl, Node* tst, float prob, float cnt) {
IfNode* iff = new (C) IfNode(ctrl, tst, prob, cnt);// New IfNode's
IfNode* iff = new IfNode(ctrl, tst, prob, cnt);// New IfNode's
_gvn.set_type(iff, iff->Value(&_gvn)); // Value may be known at parse-time
// Place 'if' on worklist if it will be in graph
if (!tst->is_Con()) record_for_igvn(iff); // Range-check and Null-check removal is later
@ -875,7 +878,7 @@ class GraphKit : public Phase {
}
IfNode* create_and_xform_if(Node* ctrl, Node* tst, float prob, float cnt) {
IfNode* iff = new (C) IfNode(ctrl, tst, prob, cnt);// New IfNode's
IfNode* iff = new IfNode(ctrl, tst, prob, cnt);// New IfNode's
_gvn.transform(iff); // Value may be known at parse-time
// Place 'if' on worklist if it will be in graph
if (!tst->is_Con()) record_for_igvn(iff); // Range-check and Null-check removal is later

20
hotspot/src/share/vm/opto/idealKit.cpp
View File

@ -86,7 +86,7 @@ void IdealKit::if_then(Node* left, BoolTest::mask relop,
}
// Delay gvn.tranform on if-nodes until construction is finished
// to prevent a constant bool input from discarding a control output.
IfNode* iff = delay_transform(new (C) IfNode(ctrl(), bol, prob, cnt))->as_If();
IfNode* iff = delay_transform(new IfNode(ctrl(), bol, prob, cnt))->as_If();
Node* then = IfTrue(iff);
Node* elsen = IfFalse(iff);
Node* else_cvstate = copy_cvstate();
@ -205,7 +205,7 @@ Node* IdealKit::make_label(int goto_ct) {
assert(_cvstate != NULL, "must declare variables before labels");
Node* lab = new_cvstate();
int sz = 1 + goto_ct + 1 /* fall thru */;
Node* reg = delay_transform(new (C) RegionNode(sz));
Node* reg = delay_transform(new RegionNode(sz));
lab->init_req(TypeFunc::Control, reg);
return lab;
}
@ -312,7 +312,7 @@ Node* IdealKit::delay_transform(Node* n) {
//-----------------------------new_cvstate-----------------------------------
Node* IdealKit::new_cvstate() {
uint sz = _var_ct + first_var;
return new (C) Node(sz);
return new Node(sz);
}
//-----------------------------copy_cvstate-----------------------------------
@ -397,7 +397,7 @@ Node* IdealKit::storeCM(Node* ctl, Node* adr, Node *val, Node* oop_store, int oo
// Add required edge to oop_store, optimizer does not support precedence edges.
// Convert required edge to precedence edge before allocation.
Node* st = new (C) StoreCMNode(ctl, mem, adr, adr_type, val, oop_store, oop_adr_idx);
Node* st = new StoreCMNode(ctl, mem, adr, adr_type, val, oop_store, oop_adr_idx);
st = transform(st);
set_memory(st, adr_idx);
@ -497,7 +497,7 @@ void IdealKit::make_leaf_call(const TypeFunc *slow_call_type,
uint adr_idx = C->get_alias_index(adr_type);
// Slow-path leaf call
CallNode *call = (CallNode*)new (C) CallLeafNode( slow_call_type, slow_call, leaf_name, adr_type);
CallNode *call = (CallNode*)new CallLeafNode( slow_call_type, slow_call, leaf_name, adr_type);
// Set fixed predefined input arguments
call->init_req( TypeFunc::Control, ctrl() );
@ -518,10 +518,10 @@ void IdealKit::make_leaf_call(const TypeFunc *slow_call_type,
// Slow leaf call has no side-effects, sets few values
set_ctrl(transform( new (C) ProjNode(call,TypeFunc::Control) ));
set_ctrl(transform( new ProjNode(call,TypeFunc::Control) ));
// Make memory for the call
Node* mem = _gvn.transform( new (C) ProjNode(call, TypeFunc::Memory) );
Node* mem = _gvn.transform( new ProjNode(call, TypeFunc::Memory) );
// Set the RawPtr memory state only.
set_memory(mem, adr_idx);
@ -544,7 +544,7 @@ void IdealKit::make_leaf_call_no_fp(const TypeFunc *slow_call_type,
uint adr_idx = C->get_alias_index(adr_type);
// Slow-path leaf call
CallNode *call = (CallNode*)new (C) CallLeafNoFPNode( slow_call_type, slow_call, leaf_name, adr_type);
CallNode *call = (CallNode*)new CallLeafNoFPNode( slow_call_type, slow_call, leaf_name, adr_type);
// Set fixed predefined input arguments
call->init_req( TypeFunc::Control, ctrl() );
@ -565,10 +565,10 @@ void IdealKit::make_leaf_call_no_fp(const TypeFunc *slow_call_type,
// Slow leaf call has no side-effects, sets few values
set_ctrl(transform( new (C) ProjNode(call,TypeFunc::Control) ));
set_ctrl(transform( new ProjNode(call,TypeFunc::Control) ));
// Make memory for the call
Node* mem = _gvn.transform( new (C) ProjNode(call, TypeFunc::Memory) );
Node* mem = _gvn.transform( new ProjNode(call, TypeFunc::Memory) );
// Set the RawPtr memory state only.
set_memory(mem, adr_idx);

34
hotspot/src/share/vm/opto/idealKit.hpp
View File

@ -173,43 +173,43 @@ class IdealKit: public StackObj {
void goto_(Node* lab, bool bind = false);
void declarations_done();
Node* IfTrue(IfNode* iff) { return transform(new (C) IfTrueNode(iff)); }
Node* IfFalse(IfNode* iff) { return transform(new (C) IfFalseNode(iff)); }
Node* IfTrue(IfNode* iff) { return transform(new IfTrueNode(iff)); }
Node* IfFalse(IfNode* iff) { return transform(new IfFalseNode(iff)); }
// Data
Node* ConI(jint k) { return (Node*)gvn().intcon(k); }
Node* makecon(const Type *t) const { return _gvn.makecon(t); }
Node* AddI(Node* l, Node* r) { return transform(new (C) AddINode(l, r)); }
Node* SubI(Node* l, Node* r) { return transform(new (C) SubINode(l, r)); }
Node* AndI(Node* l, Node* r) { return transform(new (C) AndINode(l, r)); }
Node* MaxI(Node* l, Node* r) { return transform(new (C) MaxINode(l, r)); }
Node* LShiftI(Node* l, Node* r) { return transform(new (C) LShiftINode(l, r)); }
Node* CmpI(Node* l, Node* r) { return transform(new (C) CmpINode(l, r)); }
Node* Bool(Node* cmp, BoolTest::mask relop) { return transform(new (C) BoolNode(cmp, relop)); }
Node* AddI(Node* l, Node* r) { return transform(new AddINode(l, r)); }
Node* SubI(Node* l, Node* r) { return transform(new SubINode(l, r)); }
Node* AndI(Node* l, Node* r) { return transform(new AndINode(l, r)); }
Node* MaxI(Node* l, Node* r) { return transform(new MaxINode(l, r)); }
Node* LShiftI(Node* l, Node* r) { return transform(new LShiftINode(l, r)); }
Node* CmpI(Node* l, Node* r) { return transform(new CmpINode(l, r)); }
Node* Bool(Node* cmp, BoolTest::mask relop) { return transform(new BoolNode(cmp, relop)); }
void increment(IdealVariable& v, Node* j) { set(v, AddI(value(v), j)); }
void decrement(IdealVariable& v, Node* j) { set(v, SubI(value(v), j)); }
Node* CmpL(Node* l, Node* r) { return transform(new (C) CmpLNode(l, r)); }
Node* CmpL(Node* l, Node* r) { return transform(new CmpLNode(l, r)); }
// TLS
Node* thread() { return gvn().transform(new (C) ThreadLocalNode()); }
Node* thread() { return gvn().transform(new ThreadLocalNode()); }
// Pointers
// Raw address should be transformed regardless 'delay_transform' flag
// to produce canonical form CastX2P(offset).
Node* AddP(Node *base, Node *ptr, Node *off) { return _gvn.transform(new (C) AddPNode(base, ptr, off)); }
Node* AddP(Node *base, Node *ptr, Node *off) { return _gvn.transform(new AddPNode(base, ptr, off)); }
Node* CmpP(Node* l, Node* r) { return transform(new (C) CmpPNode(l, r)); }
Node* CmpP(Node* l, Node* r) { return transform(new CmpPNode(l, r)); }
#ifdef _LP64
Node* XorX(Node* l, Node* r) { return transform(new (C) XorLNode(l, r)); }
Node* XorX(Node* l, Node* r) { return transform(new XorLNode(l, r)); }
#else // _LP64
Node* XorX(Node* l, Node* r) { return transform(new (C) XorINode(l, r)); }
Node* XorX(Node* l, Node* r) { return transform(new XorINode(l, r)); }
#endif // _LP64
Node* URShiftX(Node* l, Node* r) { return transform(new (C) URShiftXNode(l, r)); }
Node* URShiftX(Node* l, Node* r) { return transform(new URShiftXNode(l, r)); }
Node* ConX(jint k) { return (Node*)gvn().MakeConX(k); }
Node* CastPX(Node* ctl, Node* p) { return transform(new (C) CastP2XNode(ctl, p)); }
Node* CastPX(Node* ctl, Node* p) { return transform(new CastP2XNode(ctl, p)); }
// Memory operations

52
hotspot/src/share/vm/opto/ifnode.cpp
View File

@ -238,10 +238,10 @@ static Node* split_if(IfNode *iff, PhaseIterGVN *igvn) {
Node* predicate_x = NULL;
bool counted_loop = r->is_CountedLoop();
Node *region_c = new (igvn->C) RegionNode(req_c + 1);
Node *region_c = new RegionNode(req_c + 1);
Node *phi_c = con1;
uint len = r->req();
Node *region_x = new (igvn->C) RegionNode(len - req_c);
Node *region_x = new RegionNode(len - req_c);
Node *phi_x = PhiNode::make_blank(region_x, phi);
for (uint i = 1, i_c = 1, i_x = 1; i < len; i++) {
if (phi->in(i) == con1) {
@ -272,7 +272,7 @@ static Node* split_if(IfNode *iff, PhaseIterGVN *igvn) {
// Prevent the untimely death of phi_x. Currently he has no uses. He is
// about to get one. If this only use goes away, then phi_x will look dead.
// However, he will be picking up some more uses down below.
Node *hook = new (igvn->C) Node(4);
Node *hook = new Node(4);
hook->init_req(0, phi_x);
hook->init_req(1, phi_c);
phi_x = phase->transform( phi_x );
@ -284,30 +284,30 @@ static Node* split_if(IfNode *iff, PhaseIterGVN *igvn) {
cmp_x->set_req(2,con2);
cmp_x = phase->transform(cmp_x);
// Make the bool
Node *b_c = phase->transform(new (igvn->C) BoolNode(cmp_c,b->_test._test));
Node *b_x = phase->transform(new (igvn->C) BoolNode(cmp_x,b->_test._test));
Node *b_c = phase->transform(new BoolNode(cmp_c,b->_test._test));
Node *b_x = phase->transform(new BoolNode(cmp_x,b->_test._test));
// Make the IfNode
IfNode *iff_c = new (igvn->C) IfNode(region_c,b_c,iff->_prob,iff->_fcnt);
IfNode *iff_c = new IfNode(region_c,b_c,iff->_prob,iff->_fcnt);
igvn->set_type_bottom(iff_c);
igvn->_worklist.push(iff_c);
hook->init_req(2, iff_c);
IfNode *iff_x = new (igvn->C) IfNode(region_x,b_x,iff->_prob, iff->_fcnt);
IfNode *iff_x = new IfNode(region_x,b_x,iff->_prob, iff->_fcnt);
igvn->set_type_bottom(iff_x);
igvn->_worklist.push(iff_x);
hook->init_req(3, iff_x);
// Make the true/false arms
Node *iff_c_t = phase->transform(new (igvn->C) IfTrueNode (iff_c));
Node *iff_c_f = phase->transform(new (igvn->C) IfFalseNode(iff_c));
Node *iff_c_t = phase->transform(new IfTrueNode (iff_c));
Node *iff_c_f = phase->transform(new IfFalseNode(iff_c));
if (predicate_c != NULL) {
assert(predicate_x == NULL, "only one predicate entry expected");
// Clone loop predicates to each path
iff_c_t = igvn->clone_loop_predicates(predicate_c, iff_c_t, !counted_loop);
iff_c_f = igvn->clone_loop_predicates(predicate_c, iff_c_f, !counted_loop);
}
Node *iff_x_t = phase->transform(new (igvn->C) IfTrueNode (iff_x));
Node *iff_x_f = phase->transform(new (igvn->C) IfFalseNode(iff_x));
Node *iff_x_t = phase->transform(new IfTrueNode (iff_x));
Node *iff_x_f = phase->transform(new IfFalseNode(iff_x));
if (predicate_x != NULL) {
assert(predicate_c == NULL, "only one predicate entry expected");
// Clone loop predicates to each path
@ -316,14 +316,14 @@ static Node* split_if(IfNode *iff, PhaseIterGVN *igvn) {
}
// Merge the TRUE paths
Node *region_s = new (igvn->C) RegionNode(3);
Node *region_s = new RegionNode(3);
igvn->_worklist.push(region_s);
region_s->init_req(1, iff_c_t);
region_s->init_req(2, iff_x_t);
igvn->register_new_node_with_optimizer( region_s );
// Merge the FALSE paths
Node *region_f = new (igvn->C) RegionNode(3);
Node *region_f = new RegionNode(3);
igvn->_worklist.push(region_f);
region_f->init_req(1, iff_c_f);
region_f->init_req(2, iff_x_f);
@ -438,7 +438,7 @@ static Node* split_if(IfNode *iff, PhaseIterGVN *igvn) {
// 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 (igvn->C) ConINode(TypeInt::ZERO);
return new ConINode(TypeInt::ZERO);
}
//------------------------------is_range_check---------------------------------
@ -541,16 +541,16 @@ static void adjust_check(Node* proj, Node* range, Node* index,
// Compute a new check
Node *new_add = gvn->intcon(off_lo);
if( index ) {
new_add = off_lo ? gvn->transform(new (gvn->C) AddINode( index, new_add )) : index;
new_add = off_lo ? gvn->transform(new AddINode( index, new_add )) : index;
}
Node *new_cmp = (flip == 1)
? new (gvn->C) CmpUNode( new_add, range )
: new (gvn->C) CmpUNode( range, new_add );
? new CmpUNode( new_add, range )
: new CmpUNode( range, new_add );
new_cmp = gvn->transform(new_cmp);
// See if no need to adjust the existing check
if( new_cmp == cmp ) return;
// Else, adjust existing check
Node *new_bol = gvn->transform( new (gvn->C) BoolNode( new_cmp, bol->as_Bool()->_test._test ) );
Node *new_bol = gvn->transform( new BoolNode( new_cmp, bol->as_Bool()->_test._test ) );
igvn->rehash_node_delayed( iff );
iff->set_req_X( 1, new_bol, igvn );
}
@ -728,9 +728,9 @@ Node* IfNode::fold_compares(PhaseGVN* phase) {
if (failtype->_hi != max_jint && failtype->_lo != min_jint && bound > 1) {
// Merge the two compares into a single unsigned compare by building (CmpU (n - lo) hi)
BoolTest::mask cond = fail->as_Proj()->_con ? BoolTest::lt : BoolTest::ge;
Node* adjusted = phase->transform(new (phase->C) SubINode(n, phase->intcon(failtype->_lo)));
Node* newcmp = phase->transform(new (phase->C) CmpUNode(adjusted, phase->intcon(bound)));
Node* newbool = phase->transform(new (phase->C) BoolNode(newcmp, cond));
Node* adjusted = phase->transform(new SubINode(n, phase->intcon(failtype->_lo)));
Node* newcmp = phase->transform(new CmpUNode(adjusted, phase->intcon(bound)));
Node* newbool = phase->transform(new BoolNode(newcmp, cond));
phase->is_IterGVN()->replace_input_of(dom_iff, 1, phase->intcon(ctrl->as_Proj()->_con));
phase->hash_delete(this);
set_req(1, newbool);
@ -1003,7 +1003,7 @@ Node *IfNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// 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 new ConINode(TypeInt::ZERO);
}
//------------------------------dominated_by-----------------------------------
@ -1099,7 +1099,7 @@ static IfNode* idealize_test(PhaseGVN* phase, IfNode* iff) {
// Flip test to be canonical. Requires flipping the IfFalse/IfTrue and
// cloning the IfNode.
Node* new_b = phase->transform( new (phase->C) BoolNode(b->in(1), bt.negate()) );
Node* new_b = phase->transform( new BoolNode(b->in(1), bt.negate()) );
if( !new_b->is_Bool() ) return NULL;
b = new_b->as_Bool();
@ -1107,7 +1107,7 @@ static IfNode* idealize_test(PhaseGVN* phase, IfNode* iff) {
assert( igvn, "Test is not canonical in parser?" );
// The IF node never really changes, but it needs to be cloned
iff = new (phase->C) IfNode( iff->in(0), b, 1.0-iff->_prob, iff->_fcnt);
iff = new IfNode( iff->in(0), b, 1.0-iff->_prob, iff->_fcnt);
Node *prior = igvn->hash_find_insert(iff);
if( prior ) {
@ -1120,8 +1120,8 @@ static IfNode* idealize_test(PhaseGVN* phase, IfNode* iff) {
igvn->_worklist.push(iff);
// Now handle projections. Cloning not required.
Node* new_if_f = (Node*)(new (phase->C) IfFalseNode( iff ));
Node* new_if_t = (Node*)(new (phase->C) IfTrueNode ( iff ));
Node* new_if_f = (Node*)(new IfFalseNode( iff ));
Node* new_if_t = (Node*)(new IfTrueNode ( iff ));
igvn->register_new_node_with_optimizer(new_if_f);
igvn->register_new_node_with_optimizer(new_if_t);

8
hotspot/src/share/vm/opto/lcm.cpp
View File

@ -419,7 +419,7 @@ void PhaseCFG::implicit_null_check(Block* block, Node *proj, Node *val, int allo
Node *tmp2 = block->get_node(block->end_idx()+2);
block->map_node(tmp2, block->end_idx()+1);
block->map_node(tmp1, block->end_idx()+2);
Node *tmp = new (C) Node(C->top()); // Use not NULL input
Node *tmp = new Node(C->top()); // Use not NULL input
tmp1->replace_by(tmp);
tmp2->replace_by(tmp1);
tmp->replace_by(tmp2);
@ -430,7 +430,7 @@ void PhaseCFG::implicit_null_check(Block* block, Node *proj, Node *val, int allo
// Since schedule-local needs precise def-use info, we need to correct
// it as well.
Node *old_tst = proj->in(0);
MachNode *nul_chk = new (C) MachNullCheckNode(old_tst->in(0),best,bidx);
MachNode *nul_chk = new MachNullCheckNode(old_tst->in(0),best,bidx);
block->map_node(nul_chk, block->end_idx());
map_node_to_block(nul_chk, block);
// Redirect users of old_test to nul_chk
@ -671,7 +671,7 @@ uint PhaseCFG::sched_call(Block* block, uint node_cnt, Node_List& worklist, Grow
// Set all registers killed and not already defined by the call.
uint r_cnt = mcall->tf()->range()->cnt();
int op = mcall->ideal_Opcode();
MachProjNode *proj = new (C) MachProjNode( mcall, r_cnt+1, RegMask::Empty, MachProjNode::fat_proj );
MachProjNode *proj = new MachProjNode( mcall, r_cnt+1, RegMask::Empty, MachProjNode::fat_proj );
map_node_to_block(proj, block);
block->insert_node(proj, node_cnt++);
@ -900,7 +900,7 @@ bool PhaseCFG::schedule_local(Block* block, GrowableArray<int>& ready_cnt, Vecto
regs.Insert(_matcher.c_frame_pointer());
regs.OR(n->out_RegMask());
MachProjNode *proj = new (C) MachProjNode( n, 1, RegMask::Empty, MachProjNode::fat_proj );
MachProjNode *proj = new MachProjNode( n, 1, RegMask::Empty, MachProjNode::fat_proj );
map_node_to_block(proj, block);
block->insert_node(proj, phi_cnt++);

922
hotspot/src/share/vm/opto/library_call.cpp
View File

File diff suppressed because it is too large Load Diff

30
hotspot/src/share/vm/opto/loopPredicate.cpp
View File

@ -104,7 +104,7 @@ ProjNode* PhaseIdealLoop::create_new_if_for_predicate(ProjNode* cont_proj, Node*
assert(rgn->is_Call(), "must be call uct");
CallNode* call = rgn->as_Call();
IdealLoopTree* loop = get_loop(call);
rgn = new (C) RegionNode(1);
rgn = new RegionNode(1);
rgn->add_req(uncommon_proj);
register_control(rgn, loop, uncommon_proj);
_igvn.hash_delete(call);
@ -130,8 +130,8 @@ ProjNode* PhaseIdealLoop::create_new_if_for_predicate(ProjNode* cont_proj, Node*
IfNode *new_iff = iff->clone()->as_If();
new_iff->set_req(0, entry);
register_control(new_iff, lp, entry);
Node *if_cont = new (C) IfTrueNode(new_iff);
Node *if_uct = new (C) IfFalseNode(new_iff);
Node *if_cont = new IfTrueNode(new_iff);
Node *if_uct = new IfFalseNode(new_iff);
if (cont_proj->is_IfFalse()) {
// Swap
Node* tmp = if_uct; if_uct = if_cont; if_cont = tmp;
@ -191,7 +191,7 @@ ProjNode* PhaseIterGVN::create_new_if_for_predicate(ProjNode* cont_proj, Node* n
if (!rgn->is_Region()) { // create a region to guard the call
assert(rgn->is_Call(), "must be call uct");
CallNode* call = rgn->as_Call();
rgn = new (C) RegionNode(1);
rgn = new RegionNode(1);
register_new_node_with_optimizer(rgn);
rgn->add_req(uncommon_proj);
hash_delete(call);
@ -208,8 +208,8 @@ ProjNode* PhaseIterGVN::create_new_if_for_predicate(ProjNode* cont_proj, Node* n
new_iff->set_req(0, new_entry);
register_new_node_with_optimizer(new_iff);
Node *if_cont = new (C) IfTrueNode(new_iff);
Node *if_uct = new (C) IfFalseNode(new_iff);
Node *if_cont = new IfTrueNode(new_iff);
Node *if_uct = new IfFalseNode(new_iff);
if (cont_proj->is_IfFalse()) {
// Swap
Node* tmp = if_uct; if_uct = if_cont; if_cont = tmp;
@ -254,10 +254,10 @@ ProjNode* PhaseIdealLoop::clone_predicate(ProjNode* predicate_proj, Node* new_en
// Match original condition since predicate's projections could be swapped.
assert(predicate_proj->in(0)->in(1)->in(1)->Opcode()==Op_Opaque1, "must be");
Node* opq = new (igvn->C) Opaque1Node(igvn->C, predicate_proj->in(0)->in(1)->in(1)->in(1));
Node* opq = new Opaque1Node(igvn->C, predicate_proj->in(0)->in(1)->in(1)->in(1));
igvn->C->add_predicate_opaq(opq);
Node* bol = new (igvn->C) Conv2BNode(opq);
Node* bol = new Conv2BNode(opq);
if (loop_phase != NULL) {
loop_phase->register_new_node(opq, ctrl);
loop_phase->register_new_node(bol, ctrl);
@ -605,11 +605,11 @@ BoolNode* PhaseIdealLoop::rc_predicate(IdealLoopTree *loop, Node* ctrl,
// Calculate exact limit here.
// Note, counted loop's test is '<' or '>'.
limit = exact_limit(loop);
max_idx_expr = new (C) SubINode(limit, stride);
max_idx_expr = new SubINode(limit, stride);
register_new_node(max_idx_expr, ctrl);
if (TraceLoopPredicate) predString->print("(limit - stride) ");
} else {
max_idx_expr = new (C) SubINode(limit, stride);
max_idx_expr = new SubINode(limit, stride);
register_new_node(max_idx_expr, ctrl);
if (TraceLoopPredicate) predString->print("(limit - stride) ");
}
@ -619,22 +619,22 @@ BoolNode* PhaseIdealLoop::rc_predicate(IdealLoopTree *loop, Node* ctrl,
if (scale != 1) {
ConNode* con_scale = _igvn.intcon(scale);
max_idx_expr = new (C) MulINode(max_idx_expr, con_scale);
max_idx_expr = new MulINode(max_idx_expr, con_scale);
register_new_node(max_idx_expr, ctrl);
if (TraceLoopPredicate) predString->print("* %d ", scale);
}
if (offset && (!offset->is_Con() || offset->get_int() != 0)){
max_idx_expr = new (C) AddINode(max_idx_expr, offset);
max_idx_expr = new AddINode(max_idx_expr, offset);
register_new_node(max_idx_expr, ctrl);
if (TraceLoopPredicate)
if (offset->is_Con()) predString->print("+ %d ", offset->get_int());
else predString->print("+ offset ");
}
CmpUNode* cmp = new (C) CmpUNode(max_idx_expr, range);
CmpUNode* cmp = new CmpUNode(max_idx_expr, range);
register_new_node(cmp, ctrl);
BoolNode* bol = new (C) BoolNode(cmp, BoolTest::lt);
BoolNode* bol = new BoolNode(cmp, BoolTest::lt);
register_new_node(bol, ctrl);
if (TraceLoopPredicate) {
@ -750,7 +750,7 @@ bool PhaseIdealLoop::loop_predication_impl(IdealLoopTree *loop) {
// Negate test if necessary
bool negated = false;
if (proj->_con != predicate_proj->_con) {
new_predicate_bol = new (C) BoolNode(new_predicate_bol->in(1), new_predicate_bol->_test.negate());
new_predicate_bol = new BoolNode(new_predicate_bol->in(1), new_predicate_bol->_test.negate());
register_new_node(new_predicate_bol, ctrl);
negated = true;
}

142
hotspot/src/share/vm/opto/loopTransform.cpp
View File

@ -227,24 +227,24 @@ Node* IdealLoopTree::reassociate_add_sub(Node* n1, PhaseIdealLoop *phase) {
if (neg_inv1) {
Node *zero = phase->_igvn.intcon(0);
phase->set_ctrl(zero, phase->C->root());
n_inv1 = new (phase->C) SubINode(zero, inv1);
n_inv1 = new SubINode(zero, inv1);
phase->register_new_node(n_inv1, inv1_c);
} else {
n_inv1 = inv1;
}
Node* inv;
if (neg_inv2) {
inv = new (phase->C) SubINode(n_inv1, inv2);
inv = new SubINode(n_inv1, inv2);
} else {
inv = new (phase->C) AddINode(n_inv1, inv2);
inv = new AddINode(n_inv1, inv2);
}
phase->register_new_node(inv, phase->get_early_ctrl(inv));
Node* addx;
if (neg_x) {
addx = new (phase->C) SubINode(inv, x);
addx = new SubINode(inv, x);
} else {
addx = new (phase->C) AddINode(x, inv);
addx = new AddINode(x, inv);
}
phase->register_new_node(addx, phase->get_ctrl(x));
phase->_igvn.replace_node(n1, addx);
@ -953,7 +953,7 @@ void PhaseIdealLoop::insert_pre_post_loops( IdealLoopTree *loop, Node_List &old_
post_end->_prob = PROB_FAIR;
// Build the main-loop normal exit.
IfFalseNode *new_main_exit = new (C) IfFalseNode(main_end);
IfFalseNode *new_main_exit = new IfFalseNode(main_end);
_igvn.register_new_node_with_optimizer( new_main_exit );
set_idom(new_main_exit, main_end, dd_main_exit );
set_loop(new_main_exit, loop->_parent);
@ -963,15 +963,15 @@ void PhaseIdealLoop::insert_pre_post_loops( IdealLoopTree *loop, Node_List &old_
// (the main-loop trip-counter exit value) because we will be changing
// the exit value (via unrolling) so we cannot constant-fold away the zero
// trip guard until all unrolling is done.
Node *zer_opaq = new (C) Opaque1Node(C, incr);
Node *zer_cmp = new (C) CmpINode( zer_opaq, limit );
Node *zer_bol = new (C) BoolNode( zer_cmp, b_test );
Node *zer_opaq = new Opaque1Node(C, incr);
Node *zer_cmp = new CmpINode( zer_opaq, limit );
Node *zer_bol = new BoolNode( zer_cmp, b_test );
register_new_node( zer_opaq, new_main_exit );
register_new_node( zer_cmp , new_main_exit );
register_new_node( zer_bol , new_main_exit );
// Build the IfNode
IfNode *zer_iff = new (C) IfNode( new_main_exit, zer_bol, PROB_FAIR, COUNT_UNKNOWN );
IfNode *zer_iff = new IfNode( new_main_exit, zer_bol, PROB_FAIR, COUNT_UNKNOWN );
_igvn.register_new_node_with_optimizer( zer_iff );
set_idom(zer_iff, new_main_exit, dd_main_exit);
set_loop(zer_iff, loop->_parent);
@ -981,7 +981,7 @@ void PhaseIdealLoop::insert_pre_post_loops( IdealLoopTree *loop, Node_List &old_
set_idom(main_exit, zer_iff, dd_main_exit);
set_idom(main_exit->unique_out(), zer_iff, dd_main_exit);
// Make the true-path, must enter the post loop
Node *zer_taken = new (C) IfTrueNode( zer_iff );
Node *zer_taken = new IfTrueNode( zer_iff );
_igvn.register_new_node_with_optimizer( zer_taken );
set_idom(zer_taken, zer_iff, dd_main_exit);
set_loop(zer_taken, loop->_parent);
@ -1029,7 +1029,7 @@ void PhaseIdealLoop::insert_pre_post_loops( IdealLoopTree *loop, Node_List &old_
// Find the pre-loop normal exit.
Node* pre_exit = pre_end->proj_out(false);
assert( pre_exit->Opcode() == Op_IfFalse, "" );
IfFalseNode *new_pre_exit = new (C) IfFalseNode(pre_end);
IfFalseNode *new_pre_exit = new IfFalseNode(pre_end);
_igvn.register_new_node_with_optimizer( new_pre_exit );
set_idom(new_pre_exit, pre_end, dd_main_head);
set_loop(new_pre_exit, loop->_parent);
@ -1038,15 +1038,15 @@ void PhaseIdealLoop::insert_pre_post_loops( IdealLoopTree *loop, Node_List &old_
// pre-loop, the main-loop may not execute at all. Later in life this
// zero-trip guard will become the minimum-trip guard when we unroll
// the main-loop.
Node *min_opaq = new (C) Opaque1Node(C, limit);
Node *min_cmp = new (C) CmpINode( pre_incr, min_opaq );
Node *min_bol = new (C) BoolNode( min_cmp, b_test );
Node *min_opaq = new Opaque1Node(C, limit);
Node *min_cmp = new CmpINode( pre_incr, min_opaq );
Node *min_bol = new BoolNode( min_cmp, b_test );
register_new_node( min_opaq, new_pre_exit );
register_new_node( min_cmp , new_pre_exit );
register_new_node( min_bol , new_pre_exit );
// Build the IfNode (assume the main-loop is executed always).
IfNode *min_iff = new (C) IfNode( new_pre_exit, min_bol, PROB_ALWAYS, COUNT_UNKNOWN );
IfNode *min_iff = new IfNode( new_pre_exit, min_bol, PROB_ALWAYS, COUNT_UNKNOWN );
_igvn.register_new_node_with_optimizer( min_iff );
set_idom(min_iff, new_pre_exit, dd_main_head);
set_loop(min_iff, loop->_parent);
@ -1057,7 +1057,7 @@ void PhaseIdealLoop::insert_pre_post_loops( IdealLoopTree *loop, Node_List &old_
set_idom(pre_exit, min_iff, dd_main_head);
set_idom(pre_exit->unique_out(), min_iff, dd_main_head);
// Make the true-path, must enter the main loop
Node *min_taken = new (C) IfTrueNode( min_iff );
Node *min_taken = new IfTrueNode( min_iff );
_igvn.register_new_node_with_optimizer( min_taken );
set_idom(min_taken, min_iff, dd_main_head);
set_loop(min_taken, loop->_parent);
@ -1087,11 +1087,11 @@ void PhaseIdealLoop::insert_pre_post_loops( IdealLoopTree *loop, Node_List &old_
// RCE and alignment may change this later.
Node *cmp_end = pre_end->cmp_node();
assert( cmp_end->in(2) == limit, "" );
Node *pre_limit = new (C) AddINode( init, stride );
Node *pre_limit = new AddINode( init, stride );
// Save the original loop limit in this Opaque1 node for
// use by range check elimination.
Node *pre_opaq = new (C) Opaque1Node(C, pre_limit, limit);
Node *pre_opaq = new Opaque1Node(C, pre_limit, limit);
register_new_node( pre_limit, pre_head->in(0) );
register_new_node( pre_opaq , pre_head->in(0) );
@ -1116,19 +1116,19 @@ void PhaseIdealLoop::insert_pre_post_loops( IdealLoopTree *loop, Node_List &old_
BoolTest::mask new_test = (main_end->stride_con() > 0) ? BoolTest::lt : BoolTest::gt;
// Modify pre loop end condition
Node* pre_bol = pre_end->in(CountedLoopEndNode::TestValue)->as_Bool();
BoolNode* new_bol0 = new (C) BoolNode(pre_bol->in(1), new_test);
BoolNode* new_bol0 = new BoolNode(pre_bol->in(1), new_test);
register_new_node( new_bol0, pre_head->in(0) );
_igvn.hash_delete(pre_end);
pre_end->set_req(CountedLoopEndNode::TestValue, new_bol0);
// Modify main loop guard condition
assert(min_iff->in(CountedLoopEndNode::TestValue) == min_bol, "guard okay");
BoolNode* new_bol1 = new (C) BoolNode(min_bol->in(1), new_test);
BoolNode* new_bol1 = new BoolNode(min_bol->in(1), new_test);
register_new_node( new_bol1, new_pre_exit );
_igvn.hash_delete(min_iff);
min_iff->set_req(CountedLoopEndNode::TestValue, new_bol1);
// Modify main loop end condition
BoolNode* main_bol = main_end->in(CountedLoopEndNode::TestValue)->as_Bool();
BoolNode* new_bol2 = new (C) BoolNode(main_bol->in(1), new_test);
BoolNode* new_bol2 = new BoolNode(main_bol->in(1), new_test);
register_new_node( new_bol2, main_end->in(CountedLoopEndNode::TestControl) );
_igvn.hash_delete(main_end);
main_end->set_req(CountedLoopEndNode::TestValue, new_bol2);
@ -1279,13 +1279,13 @@ void PhaseIdealLoop::do_unroll( IdealLoopTree *loop, Node_List &old_new, bool ad
// zero trip guard limit will be different from loop limit.
assert(has_ctrl(opaq), "should have it");
Node* opaq_ctrl = get_ctrl(opaq);
limit = new (C) Opaque2Node( C, limit );
limit = new Opaque2Node( C, limit );
register_new_node( limit, opaq_ctrl );
}
if (stride_con > 0 && ((limit_type->_lo - stride_con) < limit_type->_lo) ||
stride_con < 0 && ((limit_type->_hi - stride_con) > limit_type->_hi)) {
// No underflow.
new_limit = new (C) SubINode(limit, stride);
new_limit = new SubINode(limit, stride);
} else {
// (limit - stride) may underflow.
// Clamp the adjustment value with MININT or MAXINT:
@ -1315,18 +1315,18 @@ void PhaseIdealLoop::do_unroll( IdealLoopTree *loop, Node_List &old_new, bool ad
old_limit = bol->in(1)->in(1);
// Adjust previous adjusted limit.
adj_limit = limit->in(CMoveNode::IfFalse);
adj_limit = new (C) SubINode(adj_limit, stride);
adj_limit = new SubINode(adj_limit, stride);
} else {
old_limit = limit;
adj_limit = new (C) SubINode(limit, stride);
adj_limit = new SubINode(limit, stride);
}
assert(old_limit != NULL && adj_limit != NULL, "");
register_new_node( adj_limit, ctrl ); // adjust amount
Node* adj_cmp = new (C) CmpINode(old_limit, adj_limit);
Node* adj_cmp = new CmpINode(old_limit, adj_limit);
register_new_node( adj_cmp, ctrl );
Node* adj_bool = new (C) BoolNode(adj_cmp, bt);
Node* adj_bool = new BoolNode(adj_cmp, bt);
register_new_node( adj_bool, ctrl );
new_limit = new (C) CMoveINode(adj_bool, adj_limit, adj_max, TypeInt::INT);
new_limit = new CMoveINode(adj_bool, adj_limit, adj_max, TypeInt::INT);
}
register_new_node(new_limit, ctrl);
}
@ -1388,24 +1388,24 @@ void PhaseIdealLoop::do_unroll( IdealLoopTree *loop, Node_List &old_new, bool ad
// CountedLoop this is exact (stride divides limit-init exactly).
// We are going to double the loop body, so we want to knock off any
// odd iteration: (trip_cnt & ~1). Then back compute a new limit.
Node *span = new (C) SubINode( limit, init );
Node *span = new SubINode( limit, init );
register_new_node( span, ctrl );
Node *trip = new (C) DivINode( 0, span, stride );
Node *trip = new DivINode( 0, span, stride );
register_new_node( trip, ctrl );
Node *mtwo = _igvn.intcon(-2);
set_ctrl(mtwo, C->root());
Node *rond = new (C) AndINode( trip, mtwo );
Node *rond = new AndINode( trip, mtwo );
register_new_node( rond, ctrl );
Node *spn2 = new (C) MulINode( rond, stride );
Node *spn2 = new MulINode( rond, stride );
register_new_node( spn2, ctrl );
new_limit = new (C) AddINode( spn2, init );
new_limit = new AddINode( spn2, init );
register_new_node( new_limit, ctrl );
// Hammer in the new limit
Node *ctrl2 = loop_end->in(0);
Node *cmp2 = new (C) CmpINode( loop_head->incr(), new_limit );
Node *cmp2 = new CmpINode( loop_head->incr(), new_limit );
register_new_node( cmp2, ctrl2 );
Node *bol2 = new (C) BoolNode( cmp2, loop_end->test_trip() );
Node *bol2 = new BoolNode( cmp2, loop_end->test_trip() );
register_new_node( bol2, ctrl2 );
_igvn.hash_delete(loop_end);
loop_end->set_req(CountedLoopEndNode::TestValue, bol2);
@ -1511,15 +1511,15 @@ bool IdealLoopTree::dominates_backedge(Node* ctrl) {
// Helper function for add_constraint().
Node* PhaseIdealLoop::adjust_limit(int stride_con, Node * scale, Node *offset, Node *rc_limit, Node *loop_limit, Node *pre_ctrl) {
// Compute "I :: (limit-offset)/scale"
Node *con = new (C) SubINode(rc_limit, offset);
Node *con = new SubINode(rc_limit, offset);
register_new_node(con, pre_ctrl);
Node *X = new (C) DivINode(0, con, scale);
Node *X = new DivINode(0, con, scale);
register_new_node(X, pre_ctrl);
// Adjust loop limit
loop_limit = (stride_con > 0)
? (Node*)(new (C) MinINode(loop_limit, X))
: (Node*)(new (C) MaxINode(loop_limit, X));
? (Node*)(new MinINode(loop_limit, X))
: (Node*)(new MaxINode(loop_limit, X));
register_new_node(loop_limit, pre_ctrl);
return loop_limit;
}
@ -1580,9 +1580,9 @@ void PhaseIdealLoop::add_constraint( int stride_con, int scale_con, Node *offset
// to avoid problem with scale == -1 (min_int/(-1) == min_int).
Node* shift = _igvn.intcon(31);
set_ctrl(shift, C->root());
Node* sign = new (C) RShiftINode(offset, shift);
Node* sign = new RShiftINode(offset, shift);
register_new_node(sign, pre_ctrl);
offset = new (C) AndINode(offset, sign);
offset = new AndINode(offset, sign);
register_new_node(offset, pre_ctrl);
} else {
assert(low_limit->get_int() == 0, "wrong low limit for range check");
@ -1615,7 +1615,7 @@ void PhaseIdealLoop::add_constraint( int stride_con, int scale_con, Node *offset
Node *one = _igvn.intcon(1);
set_ctrl(one, C->root());
Node *plus_one = new (C) AddINode(offset, one);
Node *plus_one = new AddINode(offset, one);
register_new_node( plus_one, pre_ctrl );
// Pass (-stride) to indicate pre_loop_cond = NOT(main_loop_cond);
*pre_limit = adjust_limit((-stride_con), scale, plus_one, upper_limit, *pre_limit, pre_ctrl);
@ -1633,9 +1633,9 @@ void PhaseIdealLoop::add_constraint( int stride_con, int scale_con, Node *offset
// to avoid problem with scale == -1 (min_int/(-1) == min_int).
Node* shift = _igvn.intcon(31);
set_ctrl(shift, C->root());
Node* sign = new (C) RShiftINode(plus_one, shift);
Node* sign = new RShiftINode(plus_one, shift);
register_new_node(sign, pre_ctrl);
plus_one = new (C) AndINode(plus_one, sign);
plus_one = new AndINode(plus_one, sign);
register_new_node(plus_one, pre_ctrl);
} else {
assert(low_limit->get_int() == 0, "wrong low limit for range check");
@ -1718,7 +1718,7 @@ bool PhaseIdealLoop::is_scaled_iv_plus_offset(Node* exp, Node* iv, int* p_scale,
p_offset != NULL ? &offset2 : NULL, depth+1)) {
if (p_offset != NULL) {
Node *ctrl_off2 = get_ctrl(offset2);
Node* offset = new (C) AddINode(offset2, exp->in(2));
Node* offset = new AddINode(offset2, exp->in(2));
register_new_node(offset, ctrl_off2);
*p_offset = offset;
}
@ -1731,7 +1731,7 @@ bool PhaseIdealLoop::is_scaled_iv_plus_offset(Node* exp, Node* iv, int* p_scale,
Node *zero = _igvn.intcon(0);
set_ctrl(zero, C->root());
Node *ctrl_off = get_ctrl(exp->in(2));
Node* offset = new (C) SubINode(zero, exp->in(2));
Node* offset = new SubINode(zero, exp->in(2));
register_new_node(offset, ctrl_off);
*p_offset = offset;
}
@ -1934,15 +1934,15 @@ void PhaseIdealLoop::do_range_check( IdealLoopTree *loop, Node_List &old_new ) {
case BoolTest::ge:
// Convert (I*scale+offset) >= Limit to (I*(-scale)+(-offset)) <= -Limit
scale_con = -scale_con;
offset = new (C) SubINode( zero, offset );
offset = new SubINode( zero, offset );
register_new_node( offset, pre_ctrl );
limit = new (C) SubINode( zero, limit );
limit = new SubINode( zero, limit );
register_new_node( limit, pre_ctrl );
// Fall into LE case
case BoolTest::le:
if (b_test._test != BoolTest::gt) {
// Convert X <= Y to X < Y+1
limit = new (C) AddINode( limit, one );
limit = new AddINode( limit, one );
register_new_node( limit, pre_ctrl );
}
// Fall into LT case
@ -1993,8 +1993,8 @@ void PhaseIdealLoop::do_range_check( IdealLoopTree *loop, Node_List &old_new ) {
// Update loop limits
if (conditional_rc) {
pre_limit = (stride_con > 0) ? (Node*)new (C) MinINode(pre_limit, orig_limit)
: (Node*)new (C) MaxINode(pre_limit, orig_limit);
pre_limit = (stride_con > 0) ? (Node*)new MinINode(pre_limit, orig_limit)
: (Node*)new MaxINode(pre_limit, orig_limit);
register_new_node(pre_limit, pre_ctrl);
}
_igvn.hash_delete(pre_opaq);
@ -2009,16 +2009,16 @@ void PhaseIdealLoop::do_range_check( IdealLoopTree *loop, Node_List &old_new ) {
Node *ctrl = get_ctrl(main_limit);
Node *stride = cl->stride();
Node *init = cl->init_trip();
Node *span = new (C) SubINode(main_limit,init);
Node *span = new SubINode(main_limit,init);
register_new_node(span,ctrl);
Node *rndup = _igvn.intcon(stride_con + ((stride_con>0)?-1:1));
Node *add = new (C) AddINode(span,rndup);
Node *add = new AddINode(span,rndup);
register_new_node(add,ctrl);
Node *div = new (C) DivINode(0,add,stride);
Node *div = new DivINode(0,add,stride);
register_new_node(div,ctrl);
Node *mul = new (C) MulINode(div,stride);
Node *mul = new MulINode(div,stride);
register_new_node(mul,ctrl);
Node *newlim = new (C) AddINode(mul,init);
Node *newlim = new AddINode(mul,init);
register_new_node(newlim,ctrl);
main_limit = newlim;
}
@ -2189,7 +2189,7 @@ bool IdealLoopTree::policy_do_remove_empty_loop( PhaseIdealLoop *phase ) {
}
// Note: the final value after increment should not overflow since
// counted loop has limit check predicate.
Node *final = new (phase->C) SubINode( exact_limit, cl->stride() );
Node *final = new SubINode( exact_limit, cl->stride() );
phase->register_new_node(final,cl->in(LoopNode::EntryControl));
phase->_igvn.replace_node(phi,final);
phase->C->set_major_progress();
@ -2676,20 +2676,20 @@ bool PhaseIdealLoop::intrinsify_fill(IdealLoopTree* lpt) {
// Build an expression for the beginning of the copy region
Node* index = head->init_trip();
#ifdef _LP64
index = new (C) ConvI2LNode(index);
index = new ConvI2LNode(index);
_igvn.register_new_node_with_optimizer(index);
#endif
if (shift != NULL) {
// byte arrays don't require a shift but others do.
index = new (C) LShiftXNode(index, shift->in(2));
index = new LShiftXNode(index, shift->in(2));
_igvn.register_new_node_with_optimizer(index);
}
index = new (C) AddPNode(base, base, index);
index = new AddPNode(base, base, index);
_igvn.register_new_node_with_optimizer(index);
Node* from = new (C) AddPNode(base, index, offset);
Node* from = new AddPNode(base, index, offset);
_igvn.register_new_node_with_optimizer(from);
// Compute the number of elements to copy
Node* len = new (C) SubINode(head->limit(), head->init_trip());
Node* len = new SubINode(head->limit(), head->init_trip());
_igvn.register_new_node_with_optimizer(len);
BasicType t = store->as_Mem()->memory_type();
@ -2706,17 +2706,17 @@ bool PhaseIdealLoop::intrinsify_fill(IdealLoopTree* lpt) {
// Convert float/double to int/long for fill routines
if (t == T_FLOAT) {
store_value = new (C) MoveF2INode(store_value);
store_value = new MoveF2INode(store_value);
_igvn.register_new_node_with_optimizer(store_value);
} else if (t == T_DOUBLE) {
store_value = new (C) MoveD2LNode(store_value);
store_value = new MoveD2LNode(store_value);
_igvn.register_new_node_with_optimizer(store_value);
}
if (CCallingConventionRequiresIntsAsLongs &&
// See StubRoutines::select_fill_function for types. FLOAT has been converted to INT.
(t == T_FLOAT || t == T_INT || is_subword_type(t))) {
store_value = new (C) ConvI2LNode(store_value);
store_value = new ConvI2LNode(store_value);
_igvn.register_new_node_with_optimizer(store_value);
}
@ -2724,8 +2724,8 @@ bool PhaseIdealLoop::intrinsify_fill(IdealLoopTree* lpt) {
Node* result_ctrl;
Node* result_mem;
const TypeFunc* call_type = OptoRuntime::array_fill_Type();
CallLeafNode *call = new (C) CallLeafNoFPNode(call_type, fill,
fill_name, TypeAryPtr::get_array_body_type(t));
CallLeafNode *call = new CallLeafNoFPNode(call_type, fill,
fill_name, TypeAryPtr::get_array_body_type(t));
uint cnt = 0;
call->init_req(TypeFunc::Parms + cnt++, from);
call->init_req(TypeFunc::Parms + cnt++, store_value);
@ -2733,7 +2733,7 @@ bool PhaseIdealLoop::intrinsify_fill(IdealLoopTree* lpt) {
call->init_req(TypeFunc::Parms + cnt++, C->top());
}
#ifdef _LP64
len = new (C) ConvI2LNode(len);
len = new ConvI2LNode(len);
_igvn.register_new_node_with_optimizer(len);
#endif
call->init_req(TypeFunc::Parms + cnt++, len);
@ -2746,9 +2746,9 @@ bool PhaseIdealLoop::intrinsify_fill(IdealLoopTree* lpt) {
call->init_req(TypeFunc::ReturnAdr, C->start()->proj_out(TypeFunc::ReturnAdr));
call->init_req(TypeFunc::FramePtr, C->start()->proj_out(TypeFunc::FramePtr));
_igvn.register_new_node_with_optimizer(call);
result_ctrl = new (C) ProjNode(call,TypeFunc::Control);
result_ctrl = new ProjNode(call,TypeFunc::Control);
_igvn.register_new_node_with_optimizer(result_ctrl);
result_mem = new (C) ProjNode(call,TypeFunc::Memory);
result_mem = new ProjNode(call,TypeFunc::Memory);
_igvn.register_new_node_with_optimizer(result_mem);
/* Disable following optimization until proper fix (add missing checks).

10
hotspot/src/share/vm/opto/loopUnswitch.cpp
View File

@ -225,15 +225,15 @@ ProjNode* PhaseIdealLoop::create_slow_version_of_loop(IdealLoopTree *loop,
Node *cont = _igvn.intcon(1);
set_ctrl(cont, C->root());
Node* opq = new (C) Opaque1Node(C, cont);
Node* opq = new Opaque1Node(C, cont);
register_node(opq, outer_loop, entry, dom_depth(entry));
Node *bol = new (C) Conv2BNode(opq);
Node *bol = new Conv2BNode(opq);
register_node(bol, outer_loop, entry, dom_depth(entry));
IfNode* iff = new (C) IfNode(entry, bol, PROB_MAX, COUNT_UNKNOWN);
IfNode* iff = new IfNode(entry, bol, PROB_MAX, COUNT_UNKNOWN);
register_node(iff, outer_loop, entry, dom_depth(entry));
ProjNode* iffast = new (C) IfTrueNode(iff);
ProjNode* iffast = new IfTrueNode(iff);
register_node(iffast, outer_loop, iff, dom_depth(iff));
ProjNode* ifslow = new (C) IfFalseNode(iff);
ProjNode* ifslow = new IfFalseNode(iff);
register_node(ifslow, outer_loop, iff, dom_depth(iff));
// Clone the loop body. The clone becomes the fast loop. The

110
hotspot/src/share/vm/opto/loopnode.cpp
View File

@ -443,7 +443,7 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
assert(x->Opcode() == Op_Loop, "regular loops only");
C->print_method(PHASE_BEFORE_CLOOPS, 3);
Node *hook = new (C) Node(6);
Node *hook = new Node(6);
if (LoopLimitCheck) {
@ -506,11 +506,11 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
Node* bol;
if (stride_con > 0) {
cmp_limit = new (C) CmpINode(limit, _igvn.intcon(max_jint - stride_m));
bol = new (C) BoolNode(cmp_limit, BoolTest::le);
cmp_limit = new CmpINode(limit, _igvn.intcon(max_jint - stride_m));
bol = new BoolNode(cmp_limit, BoolTest::le);
} else {
cmp_limit = new (C) CmpINode(limit, _igvn.intcon(min_jint - stride_m));
bol = new (C) BoolNode(cmp_limit, BoolTest::ge);
cmp_limit = new CmpINode(limit, _igvn.intcon(min_jint - stride_m));
bol = new BoolNode(cmp_limit, BoolTest::ge);
}
cmp_limit = _igvn.register_new_node_with_optimizer(cmp_limit);
bol = _igvn.register_new_node_with_optimizer(bol);
@ -547,7 +547,7 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
// is converted to
// i = init; do {} while(++i < limit+1);
//
limit = gvn->transform(new (C) AddINode(limit, stride));
limit = gvn->transform(new AddINode(limit, stride));
}
// Now we need to canonicalize loop condition.
@ -566,7 +566,7 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
// we can convert 'i <= limit' to 'i < limit+1' since stride != 0.
//
Node* one = (stride_con > 0) ? gvn->intcon( 1) : gvn->intcon(-1);
limit = gvn->transform(new (C) AddINode(limit, one));
limit = gvn->transform(new AddINode(limit, one));
if (bt == BoolTest::le)
bt = BoolTest::lt;
else if (bt == BoolTest::ge)
@ -582,7 +582,7 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
// can directly point to the phi; in this case adjust the compare so that
// it points to the incr by adjusting the limit.
if (cmp->in(1) == phi || cmp->in(2) == phi)
limit = gvn->transform(new (C) AddINode(limit,stride));
limit = gvn->transform(new AddINode(limit,stride));
// trip-count for +-tive stride should be: (limit - init_trip + stride - 1)/stride.
// Final value for iterator should be: trip_count * stride + init_trip.
@ -595,16 +595,16 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
ShouldNotReachHere();
case BoolTest::ne: // Ahh, the case we desire
if (stride_con == 1)
trip_count = gvn->transform(new (C) SubINode(limit,init_trip));
trip_count = gvn->transform(new SubINode(limit,init_trip));
else if (stride_con == -1)
trip_count = gvn->transform(new (C) SubINode(init_trip,limit));
trip_count = gvn->transform(new SubINode(init_trip,limit));
else
ShouldNotReachHere();
set_subtree_ctrl(trip_count);
//_loop.map(trip_count->_idx,loop(limit));
break;
case BoolTest::le: // Maybe convert to '<' case
limit = gvn->transform(new (C) AddINode(limit,one_p));
limit = gvn->transform(new AddINode(limit,one_p));
set_subtree_ctrl( limit );
hook->init_req(4, limit);
@ -615,26 +615,26 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
case BoolTest::lt: { // Maybe convert to '!=' case
if (stride_con < 0) // Count down loop rolls through MAXINT
ShouldNotReachHere();
Node *range = gvn->transform(new (C) SubINode(limit,init_trip));
Node *range = gvn->transform(new SubINode(limit,init_trip));
set_subtree_ctrl( range );
hook->init_req(0, range);
Node *bias = gvn->transform(new (C) AddINode(range,stride));
Node *bias = gvn->transform(new AddINode(range,stride));
set_subtree_ctrl( bias );
hook->init_req(1, bias);
Node *bias1 = gvn->transform(new (C) AddINode(bias,one_m));
Node *bias1 = gvn->transform(new AddINode(bias,one_m));
set_subtree_ctrl( bias1 );
hook->init_req(2, bias1);
trip_count = gvn->transform(new (C) DivINode(0,bias1,stride));
trip_count = gvn->transform(new DivINode(0,bias1,stride));
set_subtree_ctrl( trip_count );
hook->init_req(3, trip_count);
break;
}
case BoolTest::ge: // Maybe convert to '>' case
limit = gvn->transform(new (C) AddINode(limit,one_m));
limit = gvn->transform(new AddINode(limit,one_m));
set_subtree_ctrl( limit );
hook->init_req(4 ,limit);
@ -645,30 +645,30 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
case BoolTest::gt: { // Maybe convert to '!=' case
if (stride_con > 0) // count up loop rolls through MININT
ShouldNotReachHere();
Node *range = gvn->transform(new (C) SubINode(limit,init_trip));
Node *range = gvn->transform(new SubINode(limit,init_trip));
set_subtree_ctrl( range );
hook->init_req(0, range);
Node *bias = gvn->transform(new (C) AddINode(range,stride));
Node *bias = gvn->transform(new AddINode(range,stride));
set_subtree_ctrl( bias );
hook->init_req(1, bias);
Node *bias1 = gvn->transform(new (C) AddINode(bias,one_p));
Node *bias1 = gvn->transform(new AddINode(bias,one_p));
set_subtree_ctrl( bias1 );
hook->init_req(2, bias1);
trip_count = gvn->transform(new (C) DivINode(0,bias1,stride));
trip_count = gvn->transform(new DivINode(0,bias1,stride));
set_subtree_ctrl( trip_count );
hook->init_req(3, trip_count);
break;
}
} // switch( bt )
Node *span = gvn->transform(new (C) MulINode(trip_count,stride));
Node *span = gvn->transform(new MulINode(trip_count,stride));
set_subtree_ctrl( span );
hook->init_req(5, span);
limit = gvn->transform(new (C) AddINode(span,init_trip));
limit = gvn->transform(new AddINode(span,init_trip));
set_subtree_ctrl( limit );
} // LoopLimitCheck
@ -717,7 +717,7 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
set_ctrl(test, iff->in(0));
// Replace the old IfNode with a new LoopEndNode
Node *lex = _igvn.register_new_node_with_optimizer(new (C) CountedLoopEndNode( iff->in(0), test, cl_prob, iff->as_If()->_fcnt ));
Node *lex = _igvn.register_new_node_with_optimizer(new CountedLoopEndNode( iff->in(0), test, cl_prob, iff->as_If()->_fcnt ));
IfNode *le = lex->as_If();
uint dd = dom_depth(iff);
set_idom(le, le->in(0), dd); // Update dominance for loop exit
@ -728,8 +728,8 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
// Need to swap loop-exit and loop-back control?
if (iftrue_op == Op_IfFalse) {
Node *ift2=_igvn.register_new_node_with_optimizer(new (C) IfTrueNode (le));
Node *iff2=_igvn.register_new_node_with_optimizer(new (C) IfFalseNode(le));
Node *ift2=_igvn.register_new_node_with_optimizer(new IfTrueNode (le));
Node *iff2=_igvn.register_new_node_with_optimizer(new IfFalseNode(le));
loop->_tail = back_control = ift2;
set_loop(ift2, loop);
@ -755,7 +755,7 @@ bool PhaseIdealLoop::is_counted_loop( Node *x, IdealLoopTree *loop ) {
lazy_replace( iff, le ); // fix 'get_ctrl'
// Now setup a new CountedLoopNode to replace the existing LoopNode
CountedLoopNode *l = new (C) CountedLoopNode(init_control, back_control);
CountedLoopNode *l = new CountedLoopNode(init_control, back_control);
l->set_unswitch_count(x->as_Loop()->unswitch_count()); // Preserve
// The following assert is approximately true, and defines the intention
// of can_be_counted_loop. It fails, however, because phase->type
@ -829,7 +829,7 @@ Node* PhaseIdealLoop::exact_limit( IdealLoopTree *loop ) {
limit = _igvn.intcon(final_int);
} else {
// Create new LoopLimit node to get exact limit (final iv value).
limit = new (C) LoopLimitNode(C, cl->init_trip(), cl->limit(), cl->stride());
limit = new LoopLimitNode(C, cl->init_trip(), cl->limit(), cl->stride());
register_new_node(limit, cl->in(LoopNode::EntryControl));
}
assert(limit != NULL, "sanity");
@ -946,11 +946,11 @@ Node *LoopLimitNode::Ideal(PhaseGVN *phase, bool can_reshape) {
if (range <= max) {
// Convert to integer expression if it is not overflow.
Node* stride_m = phase->intcon(stride_con - (stride_con > 0 ? 1 : -1));
Node *range = phase->transform(new (phase->C) SubINode(in(Limit), in(Init)));
Node *bias = phase->transform(new (phase->C) AddINode(range, stride_m));
Node *trip = phase->transform(new (phase->C) DivINode(0, bias, in(Stride)));
Node *span = phase->transform(new (phase->C) MulINode(trip, in(Stride)));
return new (phase->C) AddINode(span, in(Init)); // exact limit
Node *range = phase->transform(new SubINode(in(Limit), in(Init)));
Node *bias = phase->transform(new AddINode(range, stride_m));
Node *trip = phase->transform(new DivINode(0, bias, in(Stride)));
Node *span = phase->transform(new MulINode(trip, in(Stride)));
return new AddINode(span, in(Init)); // exact limit
}
if (is_power_of_2(stride_p) || // divisor is 2^n
@ -958,13 +958,13 @@ Node *LoopLimitNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// Convert to long expression to avoid integer overflow
// and let igvn optimizer convert this division.
//
Node* init = phase->transform( new (phase->C) ConvI2LNode(in(Init)));
Node* limit = phase->transform( new (phase->C) ConvI2LNode(in(Limit)));
Node* init = phase->transform( new ConvI2LNode(in(Init)));
Node* limit = phase->transform( new ConvI2LNode(in(Limit)));
Node* stride = phase->longcon(stride_con);
Node* stride_m = phase->longcon(stride_con - (stride_con > 0 ? 1 : -1));
Node *range = phase->transform(new (phase->C) SubLNode(limit, init));
Node *bias = phase->transform(new (phase->C) AddLNode(range, stride_m));
Node *range = phase->transform(new SubLNode(limit, init));
Node *bias = phase->transform(new AddLNode(range, stride_m));
Node *span;
if (stride_con > 0 && is_power_of_2(stride_p)) {
// bias >= 0 if stride >0, so if stride is 2^n we can use &(-stride)
@ -975,14 +975,14 @@ Node *LoopLimitNode::Ideal(PhaseGVN *phase, bool can_reshape) {
// only RCE predicate where exact limit is used and the predicate
// will simply fail forcing recompilation.
Node* neg_stride = phase->longcon(-stride_con);
span = phase->transform(new (phase->C) AndLNode(bias, neg_stride));
span = phase->transform(new AndLNode(bias, neg_stride));
} else {
Node *trip = phase->transform(new (phase->C) DivLNode(0, bias, stride));
span = phase->transform(new (phase->C) MulLNode(trip, stride));
Node *trip = phase->transform(new DivLNode(0, bias, stride));
span = phase->transform(new MulLNode(trip, stride));
}
// Convert back to int
Node *span_int = phase->transform(new (phase->C) ConvL2INode(span));
return new (phase->C) AddINode(span_int, in(Init)); // exact limit
Node *span_int = phase->transform(new ConvL2INode(span));
return new AddINode(span_int, in(Init)); // exact limit
}
return NULL; // No progress
@ -1188,7 +1188,7 @@ void IdealLoopTree::split_fall_in( PhaseIdealLoop *phase, int fall_in_cnt ) {
uint i;
// Make a new RegionNode to be the landing pad.
Node *landing_pad = new (phase->C) RegionNode( fall_in_cnt+1 );
Node *landing_pad = new RegionNode( fall_in_cnt+1 );
phase->set_loop(landing_pad,_parent);
// Gather all the fall-in control paths into the landing pad
uint icnt = fall_in_cnt;
@ -1274,7 +1274,7 @@ void IdealLoopTree::split_outer_loop( PhaseIdealLoop *phase ) {
// Make a LoopNode for the outermost loop.
Node *ctl = _head->in(LoopNode::EntryControl);
Node *outer = new (phase->C) LoopNode( ctl, _head->in(outer_idx) );
Node *outer = new LoopNode( ctl, _head->in(outer_idx) );
outer = igvn.register_new_node_with_optimizer(outer, _head);
phase->set_created_loop_node();
@ -1388,7 +1388,7 @@ void IdealLoopTree::merge_many_backedges( PhaseIdealLoop *phase ) {
Node *hot_tail = NULL;
// Make a Region for the merge point
Node *r = new (phase->C) RegionNode(1);
Node *r = new RegionNode(1);
for( i = 2; i < _head->req(); i++ ) {
if( i != hot_idx )
r->add_req( _head->in(i) );
@ -1407,7 +1407,7 @@ void IdealLoopTree::merge_many_backedges( PhaseIdealLoop *phase ) {
PhiNode* n = out->as_Phi();
igvn.hash_delete(n); // Delete from hash before hacking edges
Node *hot_phi = NULL;
Node *phi = new (phase->C) PhiNode(r, n->type(), n->adr_type());
Node *phi = new PhiNode(r, n->type(), n->adr_type());
// Check all inputs for the ones to peel out
uint j = 1;
for( uint i = 2; i < n->req(); i++ ) {
@ -1529,7 +1529,7 @@ bool IdealLoopTree::beautify_loops( PhaseIdealLoop *phase ) {
} else if (!_head->is_Loop() && !_irreducible) {
// Make a new LoopNode to replace the old loop head
Node *l = new (phase->C) LoopNode( _head->in(1), _head->in(2) );
Node *l = new LoopNode( _head->in(1), _head->in(2) );
l = igvn.register_new_node_with_optimizer(l, _head);
phase->set_created_loop_node();
// Go ahead and replace _head
@ -1771,16 +1771,16 @@ void PhaseIdealLoop::replace_parallel_iv(IdealLoopTree *loop) {
// It is scaled by the 'ratio_con'.
Node* ratio = _igvn.intcon(ratio_con);
set_ctrl(ratio, C->root());
Node* ratio_init = new (C) MulINode(init, ratio);
Node* ratio_init = new MulINode(init, ratio);
_igvn.register_new_node_with_optimizer(ratio_init, init);
set_early_ctrl(ratio_init);
Node* diff = new (C) SubINode(init2, ratio_init);
Node* diff = new SubINode(init2, ratio_init);
_igvn.register_new_node_with_optimizer(diff, init2);
set_early_ctrl(diff);
Node* ratio_idx = new (C) MulINode(phi, ratio);
Node* ratio_idx = new MulINode(phi, ratio);
_igvn.register_new_node_with_optimizer(ratio_idx, phi);
set_ctrl(ratio_idx, cl);
Node* add = new (C) AddINode(ratio_idx, diff);
Node* add = new AddINode(ratio_idx, diff);
_igvn.register_new_node_with_optimizer(add);
set_ctrl(add, cl);
_igvn.replace_node( phi2, add );
@ -2888,10 +2888,10 @@ int PhaseIdealLoop::build_loop_tree_impl( Node *n, int pre_order ) {
if (!_verify_only) {
// Insert the NeverBranch between 'm' and it's control user.
NeverBranchNode *iff = new (C) NeverBranchNode( m );
NeverBranchNode *iff = new NeverBranchNode( m );
_igvn.register_new_node_with_optimizer(iff);
set_loop(iff, l);
Node *if_t = new (C) CProjNode( iff, 0 );
Node *if_t = new CProjNode( iff, 0 );
_igvn.register_new_node_with_optimizer(if_t);
set_loop(if_t, l);
@ -2907,16 +2907,16 @@ int PhaseIdealLoop::build_loop_tree_impl( Node *n, int pre_order ) {
cfg->set_req( k, if_t ); // Now point to NeverBranch
// Now create the never-taken loop exit
Node *if_f = new (C) CProjNode( iff, 1 );
Node *if_f = new CProjNode( iff, 1 );
_igvn.register_new_node_with_optimizer(if_f);
set_loop(if_f, l);
// Find frame ptr for Halt. Relies on the optimizer
// V-N'ing. Easier and quicker than searching through
// the program structure.
Node *frame = new (C) ParmNode( C->start(), TypeFunc::FramePtr );
Node *frame = new ParmNode( C->start(), TypeFunc::FramePtr );
_igvn.register_new_node_with_optimizer(frame);
// Halt & Catch Fire
Node *halt = new (C) HaltNode( if_f, frame );
Node *halt = new HaltNode( if_f, frame );
_igvn.register_new_node_with_optimizer(halt);
set_loop(halt, l);
C->root()->add_req(halt);

Some files were not shown because too many files have changed in this diff Show More