8152666: The new Hotspot Build System
Co-authored-by: Magnus Ihse Bursie <magnus.ihse.bursie@oracle.com> Co-authored-by: Ingemar Aberg <ingemar.aberg@oracle.com> Reviewed-by: ihse, dcubed, erikj
This commit is contained in:
Erik Joelsson
parent
c575342c2c
commit
e709aa268d
@ -749,8 +749,8 @@ AC_DEFUN_ONCE([BASIC_SETUP_DEVKIT],
|
||||
BASIC_PREPEND_TO_PATH([PATH],$EXTRA_PATH)
|
||||
|
||||
if test "x$OPENJDK_BUILD_OS" = "xsolaris"; then
|
||||
# Add extra search paths on solaris for utilities like ar and as etc...
|
||||
PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin"
|
||||
# Add extra search paths on solaris for utilities like ar, as, dtrace etc...
|
||||
PATH="$PATH:/usr/ccs/bin:/usr/sfw/bin:/opt/csw/bin:/usr/sbin"
|
||||
fi
|
||||
|
||||
AC_MSG_CHECKING([for sysroot])
|
||||
@ -777,7 +777,7 @@ AC_DEFUN_ONCE([BASIC_SETUP_OUTPUT_DIR],
|
||||
# Create a default ./build/target-variant-debuglevel output root.
|
||||
if test "x${CONF_NAME}" = x; then
|
||||
AC_MSG_RESULT([in default location])
|
||||
CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${ANDED_JVM_VARIANTS}-${DEBUG_LEVEL}"
|
||||
CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${JVM_VARIANTS_WITH_AND}-${DEBUG_LEVEL}"
|
||||
else
|
||||
AC_MSG_RESULT([in build directory with custom name])
|
||||
fi
|
||||
@ -1037,6 +1037,7 @@ AC_DEFUN_ONCE([BASIC_SETUP_COMPLEX_TOOLS],
|
||||
BASIC_PATH_PROGS(HG, hg)
|
||||
BASIC_PATH_PROGS(STAT, stat)
|
||||
BASIC_PATH_PROGS(TIME, time)
|
||||
BASIC_PATH_PROGS(DTRACE, dtrace)
|
||||
BASIC_PATH_PROGS(PATCH, [gpatch patch])
|
||||
# Check if it's GNU time
|
||||
IS_GNU_TIME=`$TIME --version 2>&1 | $GREP 'GNU time'`
|
||||
|
||||
@ -364,6 +364,9 @@ AC_DEFUN_ONCE([BPERF_SETUP_PRECOMPILED_HEADERS],
|
||||
elif test "x$ICECC" != "x"; then
|
||||
AC_MSG_RESULT([no, does not work effectively with icecc])
|
||||
USE_PRECOMPILED_HEADER=0
|
||||
elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
||||
AC_MSG_RESULT([no, does not work with Solaris Studio])
|
||||
USE_PRECOMPILED_HEADER=0
|
||||
else
|
||||
AC_MSG_RESULT([yes])
|
||||
fi
|
||||
|
||||
@ -57,6 +57,12 @@ OPENJDK_TARGET_CPU_BITS := @OPENJDK_BUILD_CPU_BITS@
|
||||
OPENJDK_TARGET_CPU_ENDIAN := @OPENJDK_BUILD_CPU_ENDIAN@
|
||||
OPENJDK_TARGET_CPU_LEGACY := @OPENJDK_BUILD_CPU_LEGACY@
|
||||
|
||||
HOTSPOT_TARGET_OS := @HOTSPOT_BUILD_OS@
|
||||
HOTSPOT_TARGET_OS_TYPE := @HOTSPOT_BUILD_OS_TYPE@
|
||||
HOTSPOT_TARGET_CPU := @HOTSPOT_BUILD_CPU@
|
||||
HOTSPOT_TARGET_CPU_ARCH := @HOTSPOT_BUILD_CPU_ARCH@
|
||||
HOTSPOT_TARGET_CPU_DEFINE := @HOTSPOT_BUILD_CPU_DEFINE@
|
||||
|
||||
CFLAGS_JDKLIB := @OPENJDK_BUILD_CFLAGS_JDKLIB@
|
||||
CXXFLAGS_JDKLIB := @OPENJDK_BUILD_CXXFLAGS_JDKLIB@
|
||||
LDFLAGS_JDKLIB := @OPENJDK_BUILD_LDFLAGS_JDKLIB@
|
||||
@ -65,6 +71,11 @@ CXXFLAGS_JDKEXE := @OPENJDK_BUILD_CXXFLAGS_JDKEXE@
|
||||
LDFLAGS_JDKEXE := @OPENJDK_BUILD_LDFLAGS_JDKEXE@
|
||||
OPENJDK_TARGET_CPU_JLI_CFLAGS := @OPENJDK_BUILD_CPU_JLI_CFLAGS@
|
||||
|
||||
JVM_CFLAGS := @OPENJDK_BUILD_JVM_CFLAGS@
|
||||
JVM_LDFLAGS := @OPENJDK_BUILD_JVM_LDFLAGS@
|
||||
JVM_ASFLAGS := @OPENJDK_BUILD_JVM_ASFLAGS@
|
||||
JVM_LIBS := @OPENJDK_BUILD_JVM_LIBS@
|
||||
|
||||
# The compiler for the build platform is likely not warning compatible with the official
|
||||
# compiler.
|
||||
WARNINGS_AS_ERRORS := false
|
||||
|
||||
@ -34,6 +34,7 @@ export LEGACY_BUILD_DIR=@OPENJDK_TARGET_OS@-@OPENJDK_TARGET_CPU_LEGACY@
|
||||
export OPENJDK_TARGET_OS="@OPENJDK_TARGET_OS@"
|
||||
export OPENJDK_TARGET_CPU="@OPENJDK_TARGET_CPU@"
|
||||
export OPENJDK_TARGET_CPU_LIBDIR="@OPENJDK_TARGET_CPU_LIBDIR@"
|
||||
export DEBUG_LEVEL="@DEBUG_LEVEL@"
|
||||
|
||||
export AWK="@AWK@"
|
||||
export BASH="@BASH@"
|
||||
|
||||
2
common/autoconf/configure
vendored
2
common/autoconf/configure
vendored
@ -283,7 +283,7 @@ Additional (non-autoconf) OpenJDK Options:
|
||||
|
||||
EOT
|
||||
|
||||
# Print additional help, e.g. a list of toolchains.
|
||||
# Print additional help, e.g. a list of toolchains and JVM features.
|
||||
# This must be done by the autoconf script.
|
||||
( CONFIGURE_PRINT_ADDITIONAL_HELP=true . $conf_script_to_run PRINTF=printf )
|
||||
|
||||
|
||||
@ -95,10 +95,8 @@ JDKOPT_SETUP_OPEN_OR_CUSTOM
|
||||
|
||||
# These are needed to be able to create a configuration name (and thus the output directory)
|
||||
JDKOPT_SETUP_JDK_VARIANT
|
||||
HOTSPOT_SETUP_JVM_INTERPRETER
|
||||
HOTSPOT_SETUP_JVM_VARIANTS
|
||||
JDKOPT_SETUP_DEBUG_LEVEL
|
||||
HOTSPOT_SETUP_DEBUG_LEVEL
|
||||
HOTSPOT_SETUP_JVM_VARIANTS
|
||||
|
||||
# With basic setup done, call the custom early hook.
|
||||
CUSTOM_EARLY_HOOK
|
||||
@ -135,7 +133,6 @@ BASIC_SETUP_DEFAULT_MAKE_TARGET
|
||||
# We need build & target for this.
|
||||
JDKOPT_SETUP_JDK_OPTIONS
|
||||
JDKOPT_SETUP_JLINK_OPTIONS
|
||||
HOTSPOT_SETUP_HOTSPOT_OPTIONS
|
||||
JDKVER_SETUP_JDK_VERSION_NUMBERS
|
||||
|
||||
###############################################################################
|
||||
@ -207,6 +204,10 @@ FLAGS_SETUP_COMPILER_FLAGS_MISC
|
||||
JDKOPT_SETUP_DEBUG_SYMBOLS
|
||||
JDKOPT_SETUP_CODE_COVERAGE
|
||||
|
||||
# Need toolchain to setup dtrace
|
||||
HOTSPOT_SETUP_DTRACE
|
||||
HOTSPOT_SETUP_JVM_FEATURES
|
||||
|
||||
###############################################################################
|
||||
#
|
||||
# Check dependencies for external and internal libraries.
|
||||
@ -225,7 +226,7 @@ LIB_SETUP_LIBRARIES
|
||||
#
|
||||
###############################################################################
|
||||
|
||||
HOTSPOT_SETUP_BUILD_TWEAKS
|
||||
HOTSPOT_SETUP_LEGACY_BUILD
|
||||
JDKOPT_DETECT_INTREE_EC
|
||||
|
||||
###############################################################################
|
||||
@ -267,6 +268,9 @@ BASIC_TEST_USABILITY_ISSUES
|
||||
# At the end, call the custom hook. (Dummy macro if no custom sources available)
|
||||
CUSTOM_LATE_HOOK
|
||||
|
||||
# This needs to be done after CUSTOM_LATE_HOOK since we can setup custom features.
|
||||
HOTSPOT_VALIDATE_JVM_FEATURES
|
||||
|
||||
# We're messing a bit with internal autoconf variables to put the config.status
|
||||
# in the output directory instead of the current directory.
|
||||
CONFIG_STATUS="$CONFIGURESUPPORT_OUTPUTDIR/config.status"
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -119,6 +119,8 @@ apt_help() {
|
||||
PKGHANDLER_COMMAND="sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev" ;;
|
||||
ccache)
|
||||
PKGHANDLER_COMMAND="sudo apt-get install ccache" ;;
|
||||
dtrace)
|
||||
PKGHANDLER_COMMAND="sudo apt-get install systemtap-sdt-dev" ;;
|
||||
esac
|
||||
}
|
||||
|
||||
@ -170,6 +172,13 @@ AC_DEFUN_ONCE([HELP_PRINT_ADDITIONAL_HELP_AND_EXIT],
|
||||
TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
|
||||
$PRINTF " %-10s %s\n" $toolchain "$TOOLCHAIN_DESCRIPTION"
|
||||
done
|
||||
$PRINTF "\n"
|
||||
|
||||
# Print available jvm features
|
||||
$PRINTF "The following JVM features are available as arguments to --with-jvm-features.\n"
|
||||
$PRINTF "Which are valid to use depends on the target platform.\n "
|
||||
$PRINTF "%s " $VALID_JVM_FEATURES
|
||||
$PRINTF "\n"
|
||||
|
||||
# And now exit directly
|
||||
exit 0
|
||||
@ -206,7 +215,7 @@ AC_DEFUN_ONCE([HELP_PRINT_SUMMARY_AND_WARNINGS],
|
||||
printf "* Debug level: $DEBUG_LEVEL\n"
|
||||
printf "* HS debug level: $HOTSPOT_DEBUG_LEVEL\n"
|
||||
printf "* JDK variant: $JDK_VARIANT\n"
|
||||
printf "* JVM variants: $with_jvm_variants\n"
|
||||
printf "* JVM variants: $JVM_VARIANTS\n"
|
||||
printf "* OpenJDK target: OS: $OPENJDK_TARGET_OS, CPU architecture: $OPENJDK_TARGET_CPU_ARCH, address length: $OPENJDK_TARGET_CPU_BITS\n"
|
||||
printf "* Version string: $VERSION_STRING ($VERSION_SHORT)\n"
|
||||
|
||||
@ -232,7 +241,7 @@ AC_DEFUN_ONCE([HELP_PRINT_SUMMARY_AND_WARNINGS],
|
||||
fi
|
||||
printf "\n"
|
||||
|
||||
if test "x$BUILDING_MULTIPLE_JVM_VARIANTS" = "xyes"; then
|
||||
if test "x$BUILDING_MULTIPLE_JVM_VARIANTS" = "xtrue"; then
|
||||
printf "NOTE: You have requested to build more than one version of the JVM, which\n"
|
||||
printf "will result in longer build times.\n"
|
||||
printf "\n"
|
||||
|
||||
@ -38,6 +38,16 @@ include $(BASE_SPEC)
|
||||
# Legacy defines controlled by the SUPPORT_HEADLESS and SUPPORT_HEADFUL options.
|
||||
@BUILD_HEADLESS@
|
||||
|
||||
JVM_VARIANTS:=@JVM_VARIANTS_COMMA@
|
||||
|
||||
JVM_VARIANT_SERVER:=@JVM_VARIANT_SERVER@
|
||||
JVM_VARIANT_CLIENT:=@JVM_VARIANT_CLIENT@
|
||||
JVM_VARIANT_MINIMAL1:=@JVM_VARIANT_MINIMAL1@
|
||||
JVM_VARIANT_CORE:=@JVM_VARIANT_CORE@
|
||||
JVM_VARIANT_ZERO:=@JVM_VARIANT_ZERO@
|
||||
JVM_VARIANT_ZEROSHARK:=@JVM_VARIANT_ZEROSHARK@
|
||||
JVM_VARIANT_CUSTOM:=@JVM_VARIANT_HOTSPOT@
|
||||
|
||||
# Legacy setting: OPT or DBG
|
||||
VARIANT:=@VARIANT@
|
||||
# Legacy setting: true or false
|
||||
@ -92,8 +102,7 @@ LLVM_LDFLAGS=@LLVM_LDFLAGS@
|
||||
ALT_OUTPUTDIR=$(HOTSPOT_OUTPUTDIR)
|
||||
ALT_EXPORT_PATH=$(HOTSPOT_DIST)
|
||||
|
||||
JVM_INTERPRETER:=@JVM_INTERPRETER@
|
||||
ifeq ($(JVM_INTERPRETER), cpp)
|
||||
ifeq ($(HOTSPOT_TARGET_CPU), zero)
|
||||
CC_INTERP=true
|
||||
endif
|
||||
|
||||
|
||||
@ -23,170 +23,344 @@
|
||||
# questions.
|
||||
#
|
||||
|
||||
###############################################################################
|
||||
# Check which interpreter of the JVM we want to build.
|
||||
# Currently we have:
|
||||
# template: Template interpreter (the default)
|
||||
# cpp : C++ interpreter
|
||||
AC_DEFUN_ONCE([HOTSPOT_SETUP_JVM_INTERPRETER],
|
||||
[
|
||||
AC_ARG_WITH([jvm-interpreter], [AS_HELP_STRING([--with-jvm-interpreter],
|
||||
[JVM interpreter to build (template, cpp) @<:@template@:>@])])
|
||||
# All valid JVM features, regardless of platform
|
||||
VALID_JVM_FEATURES="compiler1 compiler2 zero shark minimal dtrace jvmti jvmci \
|
||||
fprof vm-structs jni-check services management all-gcs nmt cds static-build"
|
||||
|
||||
AC_MSG_CHECKING([which interpreter of the JVM to build])
|
||||
if test "x$with_jvm_interpreter" = x; then
|
||||
JVM_INTERPRETER="template"
|
||||
else
|
||||
JVM_INTERPRETER="$with_jvm_interpreter"
|
||||
fi
|
||||
AC_MSG_RESULT([$JVM_INTERPRETER])
|
||||
|
||||
if test "x$JVM_INTERPRETER" != xtemplate && test "x$JVM_INTERPRETER" != xcpp; then
|
||||
AC_MSG_ERROR([The available JVM interpreters are: template, cpp])
|
||||
fi
|
||||
|
||||
AC_SUBST(JVM_INTERPRETER)
|
||||
])
|
||||
# All valid JVM variants
|
||||
VALID_JVM_VARIANTS="server client minimal core zero zeroshark custom"
|
||||
|
||||
###############################################################################
|
||||
# Check which variants of the JVM that we want to build.
|
||||
# Currently we have:
|
||||
# server: normal interpreter and a C2 or tiered C1/C2 compiler
|
||||
# client: normal interpreter and C1 (no C2 compiler) (only 32-bit platforms)
|
||||
# minimal1: reduced form of client with optional VM services and features stripped out
|
||||
# zero: no machine code interpreter, no compiler
|
||||
# zeroshark: zero interpreter and shark/llvm compiler backend
|
||||
# core: interpreter only, no compiler (only works on some platforms)
|
||||
# Check if the specified JVM variant should be built. To be used in shell if
|
||||
# constructs, like this:
|
||||
# if HOTSPOT_CHECK_JVM_VARIANT(server); then
|
||||
#
|
||||
# Only valid to use after HOTSPOT_SETUP_JVM_VARIANTS has setup variants.
|
||||
|
||||
# Definition kept in one line to allow inlining in if statements.
|
||||
# Additional [] needed to keep m4 from mangling shell constructs.
|
||||
AC_DEFUN([HOTSPOT_CHECK_JVM_VARIANT],
|
||||
[ [ [[ " $JVM_VARIANTS " =~ " $1 " ]] ] ])
|
||||
|
||||
###############################################################################
|
||||
# Check if the specified JVM features are explicitly enabled. To be used in
|
||||
# shell if constructs, like this:
|
||||
# if HOTSPOT_CHECK_JVM_FEATURE(jvmti); then
|
||||
#
|
||||
# Only valid to use after HOTSPOT_SETUP_JVM_FEATURES has setup features.
|
||||
|
||||
# Definition kept in one line to allow inlining in if statements.
|
||||
# Additional [] needed to keep m4 from mangling shell constructs.
|
||||
AC_DEFUN([HOTSPOT_CHECK_JVM_FEATURE],
|
||||
[ [ [[ " $JVM_FEATURES " =~ " $1 " ]] ] ])
|
||||
|
||||
###############################################################################
|
||||
# Check which variants of the JVM that we want to build. Available variants are:
|
||||
# server: normal interpreter, and a tiered C1/C2 compiler
|
||||
# client: normal interpreter, and C1 (no C2 compiler)
|
||||
# minimal: reduced form of client with optional features stripped out
|
||||
# core: normal interpreter only, no compiler
|
||||
# zero: C++ based interpreter only, no compiler
|
||||
# zeroshark: C++ based interpreter, and a llvm-based compiler
|
||||
# custom: baseline JVM with no default features
|
||||
#
|
||||
AC_DEFUN_ONCE([HOTSPOT_SETUP_JVM_VARIANTS],
|
||||
[
|
||||
AC_MSG_CHECKING([which variants of the JVM to build])
|
||||
AC_ARG_WITH([jvm-variants], [AS_HELP_STRING([--with-jvm-variants],
|
||||
[JVM variants (separated by commas) to build (server, client, minimal1, zero, zeroshark, core) @<:@server@:>@])])
|
||||
[JVM variants (separated by commas) to build (server,client,minimal,core,zero,zeroshark,custom) @<:@server@:>@])])
|
||||
|
||||
if test "x$with_jvm_variants" = x; then
|
||||
with_jvm_variants="server"
|
||||
fi
|
||||
JVM_VARIANTS_OPT="$with_jvm_variants"
|
||||
|
||||
JVM_VARIANTS=",$with_jvm_variants,"
|
||||
TEST_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/server,//' -e 's/client,//' -e 's/minimal1,//' -e 's/zero,//' -e 's/zeroshark,//' -e 's/core,//'`
|
||||
|
||||
if test "x$TEST_VARIANTS" != "x,"; then
|
||||
AC_MSG_ERROR([The available JVM variants are: server, client, minimal1, zero, zeroshark, core])
|
||||
fi
|
||||
AC_MSG_RESULT([$with_jvm_variants])
|
||||
|
||||
JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'`
|
||||
JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'`
|
||||
JVM_VARIANT_MINIMAL1=`$ECHO "$JVM_VARIANTS" | $SED -e '/,minimal1,/!s/.*/false/g' -e '/,minimal1,/s/.*/true/g'`
|
||||
JVM_VARIANT_ZERO=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zero,/!s/.*/false/g' -e '/,zero,/s/.*/true/g'`
|
||||
JVM_VARIANT_ZEROSHARK=`$ECHO "$JVM_VARIANTS" | $SED -e '/,zeroshark,/!s/.*/false/g' -e '/,zeroshark,/s/.*/true/g'`
|
||||
JVM_VARIANT_CORE=`$ECHO "$JVM_VARIANTS" | $SED -e '/,core,/!s/.*/false/g' -e '/,core,/s/.*/true/g'`
|
||||
|
||||
if test "x$JVM_VARIANT_CLIENT" = xtrue; then
|
||||
if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
|
||||
AC_MSG_ERROR([You cannot build a client JVM for a 64-bit machine.])
|
||||
fi
|
||||
fi
|
||||
if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
|
||||
if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
|
||||
AC_MSG_ERROR([You cannot build a minimal JVM for a 64-bit machine.])
|
||||
fi
|
||||
fi
|
||||
|
||||
# Replace the commas with AND for use in the build directory name.
|
||||
ANDED_JVM_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/^,//' -e 's/,$//' -e 's/,/AND/g'`
|
||||
COUNT_VARIANTS=`$ECHO "$JVM_VARIANTS" | $SED -e 's/server,/1/' -e 's/client,/1/' -e 's/minimal1,/1/' -e 's/zero,/1/' -e 's/zeroshark,/1/' -e 's/core,/1/'`
|
||||
if test "x$COUNT_VARIANTS" != "x,1"; then
|
||||
BUILDING_MULTIPLE_JVM_VARIANTS=yes
|
||||
# Has the user listed more than one variant?
|
||||
# Additional [] needed to keep m4 from mangling shell constructs.
|
||||
if [ [[ "$JVM_VARIANTS_OPT" =~ "," ]] ]; then
|
||||
BUILDING_MULTIPLE_JVM_VARIANTS=true
|
||||
else
|
||||
BUILDING_MULTIPLE_JVM_VARIANTS=no
|
||||
BUILDING_MULTIPLE_JVM_VARIANTS=false
|
||||
fi
|
||||
# Replace the commas with AND for use in the build directory name.
|
||||
JVM_VARIANTS_WITH_AND=`$ECHO "$JVM_VARIANTS_OPT" | $SED -e 's/,/AND/g'`
|
||||
|
||||
AC_MSG_CHECKING([which variants of the JVM to build])
|
||||
# JVM_VARIANTS is a space-separated list.
|
||||
# Also use minimal, not minimal1 (which is kept for backwards compatibility).
|
||||
JVM_VARIANTS=`$ECHO $JVM_VARIANTS_OPT | $SED -e 's/,/ /g' -e 's/minimal1/minimal/'`
|
||||
AC_MSG_RESULT([$JVM_VARIANTS])
|
||||
|
||||
# Check that the selected variants are valid
|
||||
|
||||
# grep filter function inspired by a comment to http://stackoverflow.com/a/1617326
|
||||
INVALID_VARIANTS=`$GREP -Fvx "${VALID_JVM_VARIANTS// /$'\n'}" <<< "${JVM_VARIANTS// /$'\n'}"`
|
||||
if test "x$INVALID_VARIANTS" != x; then
|
||||
AC_MSG_NOTICE([Unknown variant(s) specified: $INVALID_VARIANTS])
|
||||
AC_MSG_ERROR([The available JVM variants are: $VALID_JVM_VARIANTS])
|
||||
fi
|
||||
|
||||
if test "x$JVM_VARIANT_ZERO" = xtrue && test "x$BUILDING_MULTIPLE_JVM_VARIANTS" = xyes; then
|
||||
AC_MSG_ERROR([You cannot build multiple variants with zero.])
|
||||
# All "special" variants share the same output directory ("server")
|
||||
VALID_MULTIPLE_JVM_VARIANTS="server client minimal"
|
||||
INVALID_MULTIPLE_VARIANTS=`$GREP -Fvx "${VALID_MULTIPLE_JVM_VARIANTS// /$'\n'}" <<< "${JVM_VARIANTS// /$'\n'}"`
|
||||
if test "x$INVALID_MULTIPLE_VARIANTS" != x && test "x$BUILDING_MULTIPLE_JVM_VARIANTS" = xtrue; then
|
||||
AC_MSG_ERROR([You cannot build multiple variants with anything else than $VALID_MULTIPLE_JVM_VARIANTS.])
|
||||
fi
|
||||
|
||||
AC_SUBST(JVM_VARIANTS)
|
||||
AC_SUBST(JVM_VARIANT_SERVER)
|
||||
AC_SUBST(JVM_VARIANT_CLIENT)
|
||||
AC_SUBST(JVM_VARIANT_MINIMAL1)
|
||||
AC_SUBST(JVM_VARIANT_ZERO)
|
||||
AC_SUBST(JVM_VARIANT_ZEROSHARK)
|
||||
AC_SUBST(JVM_VARIANT_CORE)
|
||||
AC_SUBST(VALID_JVM_VARIANTS)
|
||||
|
||||
if HOTSPOT_CHECK_JVM_VARIANT(zero) || HOTSPOT_CHECK_JVM_VARIANT(zeroshark); then
|
||||
# zero behaves as a platform and rewrites these values. This is really weird. :(
|
||||
# We are guaranteed that we do not build any other variants when building zero.
|
||||
HOTSPOT_TARGET_CPU=zero
|
||||
HOTSPOT_TARGET_CPU_ARCH=zero
|
||||
fi
|
||||
])
|
||||
|
||||
###############################################################################
|
||||
# Check if dtrace should be enabled and has all prerequisites present.
|
||||
#
|
||||
AC_DEFUN_ONCE([HOTSPOT_SETUP_DTRACE],
|
||||
[
|
||||
# Test for dtrace dependencies
|
||||
AC_ARG_ENABLE([dtrace], [AS_HELP_STRING([--enable-dtrace@<:@=yes/no/auto@:>@],
|
||||
[enable dtrace. Default is auto, where dtrace is enabled if all dependencies
|
||||
are present.])])
|
||||
|
||||
DTRACE_DEP_MISSING=false
|
||||
|
||||
AC_MSG_CHECKING([for dtrace tool])
|
||||
if test "x$DTRACE" != "x" && test -x "$DTRACE"; then
|
||||
AC_MSG_RESULT([$DTRACE])
|
||||
else
|
||||
AC_MSG_RESULT([not found, cannot build dtrace])
|
||||
DTRACE_DEP_MISSING=true
|
||||
fi
|
||||
|
||||
AC_CHECK_HEADERS([sys/sdt.h], [DTRACE_HEADERS_OK=yes],[DTRACE_HEADERS_OK=no])
|
||||
if test "x$DTRACE_HEADERS_OK" != "xyes"; then
|
||||
DTRACE_DEP_MISSING=true
|
||||
fi
|
||||
|
||||
AC_MSG_CHECKING([if dtrace should be built])
|
||||
if test "x$enable_dtrace" = "xyes"; then
|
||||
if test "x$DTRACE_DEP_MISSING" = "xtrue"; then
|
||||
AC_MSG_RESULT([no, missing dependencies])
|
||||
HELP_MSG_MISSING_DEPENDENCY([dtrace])
|
||||
AC_MSG_ERROR([Cannot enable dtrace with missing dependencies. See above. $HELP_MSG])
|
||||
else
|
||||
INCLUDE_DTRACE=true
|
||||
AC_MSG_RESULT([yes, forced])
|
||||
fi
|
||||
elif test "x$enable_dtrace" = "xno"; then
|
||||
INCLUDE_DTRACE=false
|
||||
AC_MSG_RESULT([no, forced])
|
||||
elif test "x$enable_dtrace" = "xauto" || test "x$enable_dtrace" = "x"; then
|
||||
if test "x$OPENJDK_TARGET_OS" = "xlinux" && test "x$OPENJDK" != "xtrue"; then
|
||||
INCLUDE_DTRACE=false
|
||||
AC_MSG_RESULT([no, non-open linux build])
|
||||
elif test "x$DTRACE_DEP_MISSING" = "xtrue"; then
|
||||
INCLUDE_DTRACE=false
|
||||
AC_MSG_RESULT([no, missing dependencies])
|
||||
else
|
||||
INCLUDE_DTRACE=true
|
||||
AC_MSG_RESULT([yes, dependencies present])
|
||||
fi
|
||||
else
|
||||
AC_MSG_ERROR([Invalid value for --enable-dtrace: $enable_dtrace])
|
||||
fi
|
||||
AC_SUBST(INCLUDE_DTRACE)
|
||||
])
|
||||
|
||||
###############################################################################
|
||||
# Set up all JVM features for each JVM variant.
|
||||
#
|
||||
AC_DEFUN_ONCE([HOTSPOT_SETUP_JVM_FEATURES],
|
||||
[
|
||||
# The user can in some cases supply additional jvm features. For the custom
|
||||
# variant, this defines the entire variant.
|
||||
AC_ARG_WITH([jvm-features], [AS_HELP_STRING([--with-jvm-features],
|
||||
[additional JVM features to enable (separated by comma), use '--help' to show possible values @<:@none@:>@])])
|
||||
if test "x$with_jvm_features" != x; then
|
||||
AC_MSG_CHECKING([additional JVM features])
|
||||
JVM_FEATURES=`$ECHO $with_jvm_features | $SED -e 's/,/ /g'`
|
||||
AC_MSG_RESULT([$JVM_FEATURES])
|
||||
fi
|
||||
|
||||
# Verify that dependencies are met for explicitly set features.
|
||||
if HOTSPOT_CHECK_JVM_FEATURE(jvmti) && ! HOTSPOT_CHECK_JVM_FEATURE(services); then
|
||||
AC_MSG_ERROR([Specified JVM feature 'jvmti' requires feature 'services'])
|
||||
fi
|
||||
|
||||
if HOTSPOT_CHECK_JVM_FEATURE(management) && ! HOTSPOT_CHECK_JVM_FEATURE(nmt); then
|
||||
AC_MSG_ERROR([Specified JVM feature 'management' requires feature 'nmt'])
|
||||
fi
|
||||
|
||||
if HOTSPOT_CHECK_JVM_FEATURE(jvmci) && ! HOTSPOT_CHECK_JVM_FEATURE(compiler2); then
|
||||
AC_MSG_ERROR([Specified JVM feature 'jvmci' requires feature 'compiler2'])
|
||||
fi
|
||||
|
||||
if HOTSPOT_CHECK_JVM_FEATURE(compiler2) && ! HOTSPOT_CHECK_JVM_FEATURE(all-gcs); then
|
||||
AC_MSG_ERROR([Specified JVM feature 'compiler2' requires feature 'all-gcs'])
|
||||
fi
|
||||
|
||||
if HOTSPOT_CHECK_JVM_FEATURE(vm-structs) && ! HOTSPOT_CHECK_JVM_FEATURE(all-gcs); then
|
||||
AC_MSG_ERROR([Specified JVM feature 'vm-structs' requires feature 'all-gcs'])
|
||||
fi
|
||||
|
||||
# Turn on additional features based on other parts of configure
|
||||
if test "x$INCLUDE_DTRACE" = "xtrue"; then
|
||||
JVM_FEATURES="$JVM_FEATURES dtrace"
|
||||
else
|
||||
if HOTSPOT_CHECK_JVM_FEATURE(dtrace); then
|
||||
AC_MSG_ERROR([To enable dtrace, you must use --enable-dtrace])
|
||||
fi
|
||||
fi
|
||||
|
||||
if test "x$STATIC_BUILD" = "xtrue"; then
|
||||
JVM_FEATURES="$JVM_FEATURES static-build"
|
||||
else
|
||||
if HOTSPOT_CHECK_JVM_FEATURE(static-build); then
|
||||
AC_MSG_ERROR([To enable static-build, you must use --enable-static-build])
|
||||
fi
|
||||
fi
|
||||
|
||||
if ! HOTSPOT_CHECK_JVM_VARIANT(zero) && ! HOTSPOT_CHECK_JVM_VARIANT(zeroshark); then
|
||||
if HOTSPOT_CHECK_JVM_FEATURE(zero); then
|
||||
AC_MSG_ERROR([To enable zero/zeroshark, you must use --with-jvm-variants=zero/zeroshark])
|
||||
fi
|
||||
fi
|
||||
|
||||
if ! HOTSPOT_CHECK_JVM_VARIANT(zeroshark); then
|
||||
if HOTSPOT_CHECK_JVM_FEATURE(shark); then
|
||||
AC_MSG_ERROR([To enable shark, you must use --with-jvm-variants=zeroshark])
|
||||
fi
|
||||
fi
|
||||
|
||||
# Only enable jvmci on x86_64, sparcv9 and aarch64, and only on server.
|
||||
if test "x$OPENJDK_TARGET_CPU" = "xx86_64" || \
|
||||
test "x$OPENJDK_TARGET_CPU" = "xsparcv9" || \
|
||||
test "x$OPENJDK_TARGET_CPU" = "xaarch64" ; then
|
||||
JVM_FEATURES_jvmci="jvmci"
|
||||
else
|
||||
JVM_FEATURES_jvmci=""
|
||||
fi
|
||||
|
||||
# All variants but minimal (and custom) get these features
|
||||
NON_MINIMAL_FEATURES="$NON_MINIMAL_FEATURES jvmti fprof vm-structs jni-check services management all-gcs nmt cds"
|
||||
|
||||
# Enable features depending on variant.
|
||||
JVM_FEATURES_server="compiler1 compiler2 $NON_MINIMAL_FEATURES $JVM_FEATURES $JVM_FEATURES_jvmci"
|
||||
JVM_FEATURES_client="compiler1 $NON_MINIMAL_FEATURES $JVM_FEATURES"
|
||||
JVM_FEATURES_core="$NON_MINIMAL_FEATURES $JVM_FEATURES"
|
||||
JVM_FEATURES_minimal="compiler1 minimal $JVM_FEATURES"
|
||||
JVM_FEATURES_zero="zero $NON_MINIMAL_FEATURES $JVM_FEATURES"
|
||||
JVM_FEATURES_zeroshark="zero shark $NON_MINIMAL_FEATURES $JVM_FEATURES"
|
||||
JVM_FEATURES_custom="$JVM_FEATURES"
|
||||
|
||||
AC_SUBST(JVM_FEATURES_server)
|
||||
AC_SUBST(JVM_FEATURES_client)
|
||||
AC_SUBST(JVM_FEATURES_core)
|
||||
AC_SUBST(JVM_FEATURES_minimal)
|
||||
AC_SUBST(JVM_FEATURES_zero)
|
||||
AC_SUBST(JVM_FEATURES_zeroshark)
|
||||
AC_SUBST(JVM_FEATURES_custom)
|
||||
|
||||
# Used for verification of Makefiles by check-jvm-feature
|
||||
AC_SUBST(VALID_JVM_FEATURES)
|
||||
|
||||
# We don't support --with-jvm-interpreter anymore, use zero instead.
|
||||
BASIC_DEPRECATED_ARG_WITH(jvm-interpreter)
|
||||
])
|
||||
|
||||
###############################################################################
|
||||
# Validate JVM features once all setup is complete, including custom setup.
|
||||
#
|
||||
AC_DEFUN_ONCE([HOTSPOT_VALIDATE_JVM_FEATURES],
|
||||
[
|
||||
# Keep feature lists sorted and free of duplicates
|
||||
JVM_FEATURES_server="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_server | $SORT -u))"
|
||||
JVM_FEATURES_client="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_client | $SORT -u))"
|
||||
JVM_FEATURES_core="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_core | $SORT -u))"
|
||||
JVM_FEATURES_minimal="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_minimal | $SORT -u))"
|
||||
JVM_FEATURES_zero="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_zero | $SORT -u))"
|
||||
JVM_FEATURES_zeroshark="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_zeroshark | $SORT -u))"
|
||||
JVM_FEATURES_custom="$($ECHO $($PRINTF '%s\n' $JVM_FEATURES_custom | $SORT -u))"
|
||||
|
||||
# Validate features
|
||||
for variant in $JVM_VARIANTS; do
|
||||
AC_MSG_CHECKING([JVM features for JVM variant '$variant'])
|
||||
features_var_name=JVM_FEATURES_$variant
|
||||
JVM_FEATURES_TO_TEST=${!features_var_name}
|
||||
AC_MSG_RESULT([$JVM_FEATURES_TO_TEST])
|
||||
INVALID_FEATURES=`$GREP -Fvx "${VALID_JVM_FEATURES// /$'\n'}" <<< "${JVM_FEATURES_TO_TEST// /$'\n'}"`
|
||||
if test "x$INVALID_FEATURES" != x; then
|
||||
AC_MSG_ERROR([Invalid JVM feature(s): $INVALID_FEATURES])
|
||||
fi
|
||||
done
|
||||
])
|
||||
|
||||
###############################################################################
|
||||
# Support for old hotspot build. Remove once new hotspot build has proven
|
||||
# to work satisfactory.
|
||||
#
|
||||
AC_DEFUN_ONCE([HOTSPOT_SETUP_LEGACY_BUILD],
|
||||
[
|
||||
AC_ARG_ENABLE(new-hotspot-build, [AS_HELP_STRING([--disable-new-hotspot-build],
|
||||
[disable the new hotspot build system (use the old) @<:@enabled@:>@])])
|
||||
|
||||
if test "x$enable_new_hotspot_build" = "x" || test "x$enable_new_hotspot_build" = "xyes"; then
|
||||
USE_NEW_HOTSPOT_BUILD=true
|
||||
else
|
||||
USE_NEW_HOTSPOT_BUILD=false
|
||||
fi
|
||||
AC_SUBST(USE_NEW_HOTSPOT_BUILD)
|
||||
|
||||
case $HOTSPOT_DEBUG_LEVEL in
|
||||
product )
|
||||
VARIANT="OPT"
|
||||
FASTDEBUG="false"
|
||||
DEBUG_CLASSFILES="false"
|
||||
;;
|
||||
fastdebug )
|
||||
VARIANT="DBG"
|
||||
FASTDEBUG="true"
|
||||
DEBUG_CLASSFILES="true"
|
||||
;;
|
||||
debug )
|
||||
VARIANT="DBG"
|
||||
FASTDEBUG="false"
|
||||
DEBUG_CLASSFILES="true"
|
||||
;;
|
||||
optimized )
|
||||
VARIANT="OPT"
|
||||
FASTDEBUG="false"
|
||||
DEBUG_CLASSFILES="false"
|
||||
;;
|
||||
esac
|
||||
AC_SUBST(VARIANT)
|
||||
AC_SUBST(FASTDEBUG)
|
||||
AC_SUBST(DEBUG_CLASSFILES)
|
||||
|
||||
if test "x$OPENJDK_TARGET_OS" = "xmacosx"; then
|
||||
MACOSX_UNIVERSAL="true"
|
||||
fi
|
||||
|
||||
AC_SUBST(MACOSX_UNIVERSAL)
|
||||
])
|
||||
|
||||
# Make sure JVM_VARIANTS_COMMA use minimal1 for backwards compatibility
|
||||
JVM_VARIANTS_COMMA=`$ECHO ,$JVM_VARIANTS_OPT, | $SED -e 's/,minimal,/,minimal1,/'`
|
||||
|
||||
###############################################################################
|
||||
# Setup legacy vars/targets and new vars to deal with different debug levels.
|
||||
#
|
||||
# release: no debug information, all optimizations, no asserts.
|
||||
# optimized: no debug information, all optimizations, no asserts, HotSpot target is 'optimized'.
|
||||
# fastdebug: debug information (-g), all optimizations, all asserts
|
||||
# slowdebug: debug information (-g), no optimizations, all asserts
|
||||
#
|
||||
AC_DEFUN_ONCE([HOTSPOT_SETUP_DEBUG_LEVEL],
|
||||
[
|
||||
case $DEBUG_LEVEL in
|
||||
release )
|
||||
VARIANT="OPT"
|
||||
FASTDEBUG="false"
|
||||
DEBUG_CLASSFILES="false"
|
||||
BUILD_VARIANT_RELEASE=""
|
||||
HOTSPOT_DEBUG_LEVEL="product"
|
||||
HOTSPOT_EXPORT="product"
|
||||
;;
|
||||
fastdebug )
|
||||
VARIANT="DBG"
|
||||
FASTDEBUG="true"
|
||||
DEBUG_CLASSFILES="true"
|
||||
BUILD_VARIANT_RELEASE="-fastdebug"
|
||||
HOTSPOT_DEBUG_LEVEL="fastdebug"
|
||||
HOTSPOT_EXPORT="fastdebug"
|
||||
;;
|
||||
slowdebug )
|
||||
VARIANT="DBG"
|
||||
FASTDEBUG="false"
|
||||
DEBUG_CLASSFILES="true"
|
||||
BUILD_VARIANT_RELEASE="-debug"
|
||||
HOTSPOT_DEBUG_LEVEL="debug"
|
||||
HOTSPOT_EXPORT="debug"
|
||||
;;
|
||||
optimized )
|
||||
VARIANT="OPT"
|
||||
FASTDEBUG="false"
|
||||
DEBUG_CLASSFILES="false"
|
||||
BUILD_VARIANT_RELEASE="-optimized"
|
||||
HOTSPOT_DEBUG_LEVEL="optimized"
|
||||
HOTSPOT_EXPORT="optimized"
|
||||
;;
|
||||
esac
|
||||
|
||||
# The debug level 'optimized' is a little special because it is currently only
|
||||
# applicable to the HotSpot build where it means to build a completely
|
||||
# optimized version of the VM without any debugging code (like for the
|
||||
# 'release' debug level which is called 'product' in the HotSpot build) but
|
||||
# with the exception that it can contain additional code which is otherwise
|
||||
# protected by '#ifndef PRODUCT' macros. These 'optimized' builds are used to
|
||||
# test new and/or experimental features which are not intended for customer
|
||||
# shipment. Because these new features need to be tested and benchmarked in
|
||||
# real world scenarios, we want to build the containing JDK at the 'release'
|
||||
# debug level.
|
||||
if test "x$DEBUG_LEVEL" = xoptimized; then
|
||||
DEBUG_LEVEL="release"
|
||||
fi
|
||||
JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS_COMMA" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'`
|
||||
JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS_COMMA" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'`
|
||||
JVM_VARIANT_MINIMAL1=`$ECHO "$JVM_VARIANTS_COMMA" | $SED -e '/,minimal1\?,/!s/.*/false/g' -e '/,minimal1\?,/s/.*/true/g'`
|
||||
JVM_VARIANT_CORE=`$ECHO "$JVM_VARIANTS_COMMA" | $SED -e '/,core,/!s/.*/false/g' -e '/,core,/s/.*/true/g'`
|
||||
JVM_VARIANT_ZERO=`$ECHO "$JVM_VARIANTS_COMMA" | $SED -e '/,zero,/!s/.*/false/g' -e '/,zero,/s/.*/true/g'`
|
||||
JVM_VARIANT_ZEROSHARK=`$ECHO "$JVM_VARIANTS_COMMA" | $SED -e '/,zeroshark,/!s/.*/false/g' -e '/,zeroshark,/s/.*/true/g'`
|
||||
JVM_VARIANT_CUSTOM=`$ECHO "$JVM_VARIANTS_COMMA" | $SED -e '/,custom,/!s/.*/false/g' -e '/,custom,/s/.*/true/g'`
|
||||
|
||||
#####
|
||||
# Generate the legacy makefile targets for hotspot.
|
||||
# The hotspot api for selecting the build artifacts, really, needs to be improved.
|
||||
# JDK-7195896 will fix this on the hotspot side by using the JVM_VARIANT_* variables to
|
||||
# determine what needs to be built. All we will need to set here is all_product, all_fastdebug etc
|
||||
# But until then ...
|
||||
HOTSPOT_TARGET=""
|
||||
|
||||
if test "x$JVM_VARIANT_SERVER" = xtrue; then
|
||||
@ -213,27 +387,19 @@ AC_DEFUN_ONCE([HOTSPOT_SETUP_DEBUG_LEVEL],
|
||||
HOTSPOT_TARGET="$HOTSPOT_TARGET${HOTSPOT_DEBUG_LEVEL}core "
|
||||
fi
|
||||
|
||||
HOTSPOT_TARGET="$HOTSPOT_TARGET docs export_$HOTSPOT_EXPORT"
|
||||
HOTSPOT_TARGET="$HOTSPOT_TARGET docs export_$HOTSPOT_DEBUG_LEVEL"
|
||||
|
||||
# On Macosx universal binaries are produced, but they only contain
|
||||
# 64 bit intel. This invalidates control of which jvms are built
|
||||
# from configure, but only server is valid anyway. Fix this
|
||||
# when hotspot makefiles are rewritten.
|
||||
if test "x$MACOSX_UNIVERSAL" = xtrue; then
|
||||
HOTSPOT_TARGET=universal_${HOTSPOT_EXPORT}
|
||||
HOTSPOT_TARGET=universal_${HOTSPOT_DEBUG_LEVEL}
|
||||
fi
|
||||
|
||||
#####
|
||||
HOTSPOT_MAKE_ARGS="$HOTSPOT_TARGET"
|
||||
AC_SUBST(HOTSPOT_MAKE_ARGS)
|
||||
|
||||
AC_SUBST(DEBUG_LEVEL)
|
||||
AC_SUBST(VARIANT)
|
||||
AC_SUBST(FASTDEBUG)
|
||||
AC_SUBST(DEBUG_CLASSFILES)
|
||||
AC_SUBST(BUILD_VARIANT_RELEASE)
|
||||
])
|
||||
|
||||
AC_DEFUN_ONCE([HOTSPOT_SETUP_HOTSPOT_OPTIONS],
|
||||
[
|
||||
# Control wether Hotspot runs Queens test after build.
|
||||
AC_ARG_ENABLE([hotspot-test-in-build], [AS_HELP_STRING([--enable-hotspot-test-in-build],
|
||||
[run the Queens test after Hotspot build @<:@disabled@:>@])],,
|
||||
@ -244,10 +410,29 @@ AC_DEFUN_ONCE([HOTSPOT_SETUP_HOTSPOT_OPTIONS],
|
||||
TEST_IN_BUILD=false
|
||||
fi
|
||||
AC_SUBST(TEST_IN_BUILD)
|
||||
])
|
||||
|
||||
AC_DEFUN_ONCE([HOTSPOT_SETUP_BUILD_TWEAKS],
|
||||
[
|
||||
HOTSPOT_MAKE_ARGS="$HOTSPOT_TARGET"
|
||||
AC_SUBST(HOTSPOT_MAKE_ARGS)
|
||||
if test "x$USE_NEW_HOTSPOT_BUILD" = xfalse; then
|
||||
if test "x$JVM_VARIANT_CLIENT" = xtrue; then
|
||||
if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
|
||||
AC_MSG_ERROR([You cannot build a client JVM for a 64-bit machine.])
|
||||
fi
|
||||
fi
|
||||
if test "x$JVM_VARIANT_MINIMAL1" = xtrue; then
|
||||
if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
|
||||
AC_MSG_ERROR([You cannot build a minimal JVM for a 64-bit machine.])
|
||||
fi
|
||||
fi
|
||||
if test "x$JVM_VARIANT_CUSTOM" = xtrue; then
|
||||
AC_MSG_ERROR([You cannot build a custom JVM using the old hotspot build system.])
|
||||
fi
|
||||
fi
|
||||
|
||||
AC_SUBST(JVM_VARIANTS_COMMA)
|
||||
AC_SUBST(JVM_VARIANT_SERVER)
|
||||
AC_SUBST(JVM_VARIANT_CLIENT)
|
||||
AC_SUBST(JVM_VARIANT_MINIMAL1)
|
||||
AC_SUBST(JVM_VARIANT_HOTSPOT)
|
||||
AC_SUBST(JVM_VARIANT_ZERO)
|
||||
AC_SUBST(JVM_VARIANT_ZEROSHARK)
|
||||
AC_SUBST(JVM_VARIANT_CORE)
|
||||
])
|
||||
|
||||
@ -81,6 +81,31 @@ AC_DEFUN_ONCE([JDKOPT_SETUP_DEBUG_LEVEL],
|
||||
test "x$DEBUG_LEVEL" != xslowdebug; then
|
||||
AC_MSG_ERROR([Allowed debug levels are: release, fastdebug, slowdebug and optimized])
|
||||
fi
|
||||
|
||||
# Translate DEBUG_LEVEL to debug level used by Hotspot
|
||||
HOTSPOT_DEBUG_LEVEL="$DEBUG_LEVEL"
|
||||
if test "x$DEBUG_LEVEL" = xrelease; then
|
||||
HOTSPOT_DEBUG_LEVEL="product"
|
||||
elif test "x$DEBUG_LEVEL" = xslowdebug; then
|
||||
HOTSPOT_DEBUG_LEVEL="debug"
|
||||
fi
|
||||
|
||||
if test "x$DEBUG_LEVEL" = xoptimized; then
|
||||
# The debug level 'optimized' is a little special because it is currently only
|
||||
# applicable to the HotSpot build where it means to build a completely
|
||||
# optimized version of the VM without any debugging code (like for the
|
||||
# 'release' debug level which is called 'product' in the HotSpot build) but
|
||||
# with the exception that it can contain additional code which is otherwise
|
||||
# protected by '#ifndef PRODUCT' macros. These 'optimized' builds are used to
|
||||
# test new and/or experimental features which are not intended for customer
|
||||
# shipment. Because these new features need to be tested and benchmarked in
|
||||
# real world scenarios, we want to build the containing JDK at the 'release'
|
||||
# debug level.
|
||||
DEBUG_LEVEL="release"
|
||||
fi
|
||||
|
||||
AC_SUBST(HOTSPOT_DEBUG_LEVEL)
|
||||
AC_SUBST(DEBUG_LEVEL)
|
||||
])
|
||||
|
||||
###############################################################################
|
||||
@ -178,10 +203,7 @@ AC_DEFUN_ONCE([JDKOPT_SETUP_JDK_OPTIONS],
|
||||
|
||||
# Should we build the serviceability agent (SA)?
|
||||
INCLUDE_SA=true
|
||||
if test "x$JVM_VARIANT_ZERO" = xtrue ; then
|
||||
INCLUDE_SA=false
|
||||
fi
|
||||
if test "x$JVM_VARIANT_ZEROSHARK" = xtrue ; then
|
||||
if HOTSPOT_CHECK_JVM_VARIANT(zero) || HOTSPOT_CHECK_JVM_VARIANT(zeroshark); then
|
||||
INCLUDE_SA=false
|
||||
fi
|
||||
if test "x$OPENJDK_TARGET_OS" = xaix ; then
|
||||
|
||||
@ -72,6 +72,7 @@ AC_DEFUN_ONCE([JDKVER_SETUP_JDK_VERSION_NUMBERS],
|
||||
AC_SUBST(PRODUCT_SUFFIX)
|
||||
AC_SUBST(JDK_RC_PLATFORM_NAME)
|
||||
AC_SUBST(COMPANY_NAME)
|
||||
AC_SUBST(HOTSPOT_VM_DISTRO)
|
||||
AC_SUBST(MACOSX_BUNDLE_NAME_BASE)
|
||||
AC_SUBST(MACOSX_BUNDLE_ID_BASE)
|
||||
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
#
|
||||
# Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
|
||||
# Copyright (c) 2011, 2016, 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
|
||||
@ -88,13 +88,25 @@ AC_DEFUN_ONCE([LIB_SETUP_STD_LIBS],
|
||||
# If dynamic was requested, it's available since it would fail above otherwise.
|
||||
# If dynamic wasn't requested, go with static unless it isn't available.
|
||||
AC_MSG_CHECKING([how to link with libstdc++])
|
||||
if test "x$with_stdc__lib" = xdynamic || test "x$has_static_libstdcxx" = xno || test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then
|
||||
if test "x$with_stdc__lib" = xdynamic || test "x$has_static_libstdcxx" = xno || HOTSPOT_CHECK_JVM_VARIANT(zeroshark); then
|
||||
LIBCXX="$LIBCXX -lstdc++"
|
||||
# To help comparisons with old build, put stdc++ first in JVM_LIBS
|
||||
JVM_LIBS="-lstdc++ $JVM_LIBS"
|
||||
# Ideally, we should test stdc++ for the BUILD toolchain separately. For now
|
||||
# just use the same setting as for the TARGET toolchain.
|
||||
OPENJDK_BUILD_JVM_LIBS="-lstdc++ $OPENJDK_BUILD_JVM_LIBS"
|
||||
LDCXX="$CXX"
|
||||
STATIC_CXX_SETTING="STATIC_CXX=false"
|
||||
AC_MSG_RESULT([dynamic])
|
||||
else
|
||||
LIBCXX="$LIBCXX $STATIC_STDCXX_FLAGS"
|
||||
JVM_LDFLAGS="$JVM_LDFLAGS -static-libgcc"
|
||||
# To help comparisons with old build, put stdc++ first in JVM_LIBS
|
||||
JVM_LIBS="-Wl,-Bstatic -lstdc++ -Wl,-Bdynamic $JVM_LIBS"
|
||||
# Ideally, we should test stdc++ for the BUILD toolchain separately. For now
|
||||
# just use the same setting as for the TARGET toolchain.
|
||||
OPENJDK_BUILD_JVM_LDFLAGS="$OPENJDK_BUILD_JVM_LDFLAGS -static-libgcc"
|
||||
OPENJDK_BUILD_JVM_LIBS="-Wl,-Bstatic -lstdc++ -Wl,-Bdynamic $OPENJDK_BUILD_JVM_LIBS"
|
||||
LDCXX="$CC"
|
||||
STATIC_CXX_SETTING="STATIC_CXX=true"
|
||||
AC_MSG_RESULT([static])
|
||||
|
||||
@ -74,7 +74,7 @@ AC_DEFUN_ONCE([LIB_DETERMINE_DEPENDENCIES],
|
||||
fi
|
||||
|
||||
# Check if ffi is needed
|
||||
if test "x$JVM_VARIANT_ZERO" = xtrue || test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then
|
||||
if HOTSPOT_CHECK_JVM_VARIANT(zero) || HOTSPOT_CHECK_JVM_VARIANT(zeroshark); then
|
||||
NEEDS_LIB_FFI=true
|
||||
else
|
||||
NEEDS_LIB_FFI=false
|
||||
@ -102,7 +102,7 @@ AC_DEFUN_ONCE([LIB_SETUP_LIBRARIES],
|
||||
################################################################################
|
||||
AC_DEFUN_ONCE([LIB_SETUP_LLVM],
|
||||
[
|
||||
if test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then
|
||||
if HOTSPOT_CHECK_JVM_VARIANT(zeroshark); then
|
||||
AC_CHECK_PROG([LLVM_CONFIG], [llvm-config], [llvm-config])
|
||||
|
||||
if test "x$LLVM_CONFIG" != xllvm-config; then
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
#
|
||||
# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
|
||||
# Copyright (c) 2011, 2016, 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
|
||||
@ -273,169 +273,169 @@ AC_DEFUN([PLATFORM_SETUP_TARGET_CPU_BITS],
|
||||
# Setup the legacy variables, for controlling the old makefiles.
|
||||
#
|
||||
AC_DEFUN([PLATFORM_SETUP_LEGACY_VARS],
|
||||
[
|
||||
PLATFORM_SETUP_LEGACY_VARS_HELPER([TARGET])
|
||||
PLATFORM_SETUP_LEGACY_VARS_HELPER([BUILD])
|
||||
|
||||
# ZERO_ARCHDEF is used to enable architecture-specific code.
|
||||
# This is used in legacy hotspot build.
|
||||
ZERO_ARCHDEF="$HOTSPOT_TARGET_CPU_DEFINE"
|
||||
AC_SUBST(ZERO_ARCHDEF)
|
||||
|
||||
])
|
||||
|
||||
# $1 - Either TARGET or BUILD to setup the variables for.
|
||||
AC_DEFUN([PLATFORM_SETUP_LEGACY_VARS_HELPER],
|
||||
[
|
||||
# Also store the legacy naming of the cpu.
|
||||
# Ie i586 and amd64 instead of x86 and x86_64
|
||||
OPENJDK_TARGET_CPU_LEGACY="$OPENJDK_TARGET_CPU"
|
||||
if test "x$OPENJDK_TARGET_CPU" = xx86; then
|
||||
OPENJDK_TARGET_CPU_LEGACY="i586"
|
||||
elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
|
||||
OPENJDK_$1_CPU_LEGACY="$OPENJDK_$1_CPU"
|
||||
if test "x$OPENJDK_$1_CPU" = xx86; then
|
||||
OPENJDK_$1_CPU_LEGACY="i586"
|
||||
elif test "x$OPENJDK_$1_OS" != xmacosx && test "x$OPENJDK_$1_CPU" = xx86_64; then
|
||||
# On all platforms except MacOSX replace x86_64 with amd64.
|
||||
OPENJDK_TARGET_CPU_LEGACY="amd64"
|
||||
OPENJDK_$1_CPU_LEGACY="amd64"
|
||||
fi
|
||||
AC_SUBST(OPENJDK_TARGET_CPU_LEGACY)
|
||||
AC_SUBST(OPENJDK_$1_CPU_LEGACY)
|
||||
|
||||
# And the second legacy naming of the cpu.
|
||||
# Ie i386 and amd64 instead of x86 and x86_64.
|
||||
OPENJDK_TARGET_CPU_LEGACY_LIB="$OPENJDK_TARGET_CPU"
|
||||
if test "x$OPENJDK_TARGET_CPU" = xx86; then
|
||||
OPENJDK_TARGET_CPU_LEGACY_LIB="i386"
|
||||
elif test "x$OPENJDK_TARGET_CPU" = xx86_64; then
|
||||
OPENJDK_TARGET_CPU_LEGACY_LIB="amd64"
|
||||
OPENJDK_$1_CPU_LEGACY_LIB="$OPENJDK_$1_CPU"
|
||||
if test "x$OPENJDK_$1_CPU" = xx86; then
|
||||
OPENJDK_$1_CPU_LEGACY_LIB="i386"
|
||||
elif test "x$OPENJDK_$1_CPU" = xx86_64; then
|
||||
OPENJDK_$1_CPU_LEGACY_LIB="amd64"
|
||||
fi
|
||||
AC_SUBST(OPENJDK_TARGET_CPU_LEGACY_LIB)
|
||||
AC_SUBST(OPENJDK_$1_CPU_LEGACY_LIB)
|
||||
|
||||
# This is the name of the cpu (but using i386 and amd64 instead of
|
||||
# x86 and x86_64, respectively), preceeded by a /, to be used when
|
||||
# locating libraries. On macosx, it's empty, though.
|
||||
OPENJDK_TARGET_CPU_LIBDIR="/$OPENJDK_TARGET_CPU_LEGACY_LIB"
|
||||
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
||||
OPENJDK_TARGET_CPU_LIBDIR=""
|
||||
OPENJDK_$1_CPU_LIBDIR="/$OPENJDK_$1_CPU_LEGACY_LIB"
|
||||
if test "x$OPENJDK_$1_OS" = xmacosx; then
|
||||
OPENJDK_$1_CPU_LIBDIR=""
|
||||
fi
|
||||
AC_SUBST(OPENJDK_TARGET_CPU_LIBDIR)
|
||||
AC_SUBST(OPENJDK_$1_CPU_LIBDIR)
|
||||
|
||||
# Now do the same for OPENJDK_BUILD_CPU...
|
||||
# Also store the legacy naming of the cpu.
|
||||
# Ie i586 and amd64 instead of x86 and x86_64
|
||||
OPENJDK_BUILD_CPU_LEGACY="$OPENJDK_BUILD_CPU"
|
||||
if test "x$OPENJDK_BUILD_CPU" = xx86; then
|
||||
OPENJDK_BUILD_CPU_LEGACY="i586"
|
||||
elif test "x$OPENJDK_BUILD_OS" != xmacosx && test "x$OPENJDK_BUILD_CPU" = xx86_64; then
|
||||
# On all platforms except MacOSX replace x86_64 with amd64.
|
||||
OPENJDK_BUILD_CPU_LEGACY="amd64"
|
||||
fi
|
||||
AC_SUBST(OPENJDK_BUILD_CPU_LEGACY)
|
||||
|
||||
# And the second legacy naming of the cpu.
|
||||
# Ie i386 and amd64 instead of x86 and x86_64.
|
||||
OPENJDK_BUILD_CPU_LEGACY_LIB="$OPENJDK_BUILD_CPU"
|
||||
if test "x$OPENJDK_BUILD_CPU" = xx86; then
|
||||
OPENJDK_BUILD_CPU_LEGACY_LIB="i386"
|
||||
elif test "x$OPENJDK_BUILD_CPU" = xx86_64; then
|
||||
OPENJDK_BUILD_CPU_LEGACY_LIB="amd64"
|
||||
fi
|
||||
AC_SUBST(OPENJDK_BUILD_CPU_LEGACY_LIB)
|
||||
|
||||
# This is the name of the cpu (but using i386 and amd64 instead of
|
||||
# x86 and x86_64, respectively), preceeded by a /, to be used when
|
||||
# locating libraries. On macosx, it's empty, though.
|
||||
OPENJDK_BUILD_CPU_LIBDIR="/$OPENJDK_BUILD_CPU_LEGACY_LIB"
|
||||
if test "x$OPENJDK_BUILD_OS" = xmacosx; then
|
||||
OPENJDK_BUILD_CPU_LIBDIR=""
|
||||
fi
|
||||
AC_SUBST(OPENJDK_BUILD_CPU_LIBDIR)
|
||||
|
||||
# OPENJDK_TARGET_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
|
||||
# OPENJDK_$1_CPU_ISADIR is normally empty. On 64-bit Solaris systems, it is set to
|
||||
# /amd64 or /sparcv9. This string is appended to some library paths, like this:
|
||||
# /usr/lib${OPENJDK_TARGET_CPU_ISADIR}/libexample.so
|
||||
OPENJDK_TARGET_CPU_ISADIR=""
|
||||
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
|
||||
if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
|
||||
OPENJDK_TARGET_CPU_ISADIR="/amd64"
|
||||
elif test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
|
||||
OPENJDK_TARGET_CPU_ISADIR="/sparcv9"
|
||||
# /usr/lib${OPENJDK_$1_CPU_ISADIR}/libexample.so
|
||||
OPENJDK_$1_CPU_ISADIR=""
|
||||
if test "x$OPENJDK_$1_OS" = xsolaris; then
|
||||
if test "x$OPENJDK_$1_CPU" = xx86_64; then
|
||||
OPENJDK_$1_CPU_ISADIR="/amd64"
|
||||
elif test "x$OPENJDK_$1_CPU" = xsparcv9; then
|
||||
OPENJDK_$1_CPU_ISADIR="/sparcv9"
|
||||
fi
|
||||
fi
|
||||
AC_SUBST(OPENJDK_TARGET_CPU_ISADIR)
|
||||
AC_SUBST(OPENJDK_$1_CPU_ISADIR)
|
||||
|
||||
# Setup OPENJDK_TARGET_CPU_OSARCH, which is used to set the os.arch Java system property
|
||||
OPENJDK_TARGET_CPU_OSARCH="$OPENJDK_TARGET_CPU"
|
||||
if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$OPENJDK_TARGET_CPU" = xx86; then
|
||||
# Setup OPENJDK_$1_CPU_OSARCH, which is used to set the os.arch Java system property
|
||||
OPENJDK_$1_CPU_OSARCH="$OPENJDK_$1_CPU"
|
||||
if test "x$OPENJDK_$1_OS" = xlinux && test "x$OPENJDK_$1_CPU" = xx86; then
|
||||
# On linux only, we replace x86 with i386.
|
||||
OPENJDK_TARGET_CPU_OSARCH="i386"
|
||||
elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
|
||||
OPENJDK_$1_CPU_OSARCH="i386"
|
||||
elif test "x$OPENJDK_$1_OS" != xmacosx && test "x$OPENJDK_$1_CPU" = xx86_64; then
|
||||
# On all platforms except macosx, we replace x86_64 with amd64.
|
||||
OPENJDK_TARGET_CPU_OSARCH="amd64"
|
||||
OPENJDK_$1_CPU_OSARCH="amd64"
|
||||
fi
|
||||
AC_SUBST(OPENJDK_TARGET_CPU_OSARCH)
|
||||
AC_SUBST(OPENJDK_$1_CPU_OSARCH)
|
||||
|
||||
OPENJDK_TARGET_CPU_JLI="$OPENJDK_TARGET_CPU"
|
||||
if test "x$OPENJDK_TARGET_CPU" = xx86; then
|
||||
OPENJDK_TARGET_CPU_JLI="i386"
|
||||
elif test "x$OPENJDK_TARGET_OS" != xmacosx && test "x$OPENJDK_TARGET_CPU" = xx86_64; then
|
||||
OPENJDK_$1_CPU_JLI="$OPENJDK_$1_CPU"
|
||||
if test "x$OPENJDK_$1_CPU" = xx86; then
|
||||
OPENJDK_$1_CPU_JLI="i386"
|
||||
elif test "x$OPENJDK_$1_OS" != xmacosx && test "x$OPENJDK_$1_CPU" = xx86_64; then
|
||||
# On all platforms except macosx, we replace x86_64 with amd64.
|
||||
OPENJDK_TARGET_CPU_JLI="amd64"
|
||||
OPENJDK_$1_CPU_JLI="amd64"
|
||||
fi
|
||||
# Now setup the -D flags for building libjli.
|
||||
OPENJDK_TARGET_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_TARGET_CPU_JLI\"'"
|
||||
if test "x$OPENJDK_TARGET_OS" = xsolaris; then
|
||||
if test "x$OPENJDK_TARGET_CPU_ARCH" = xsparc; then
|
||||
OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
|
||||
elif test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then
|
||||
OPENJDK_TARGET_CPU_JLI_CFLAGS="$OPENJDK_TARGET_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
|
||||
OPENJDK_$1_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_$1_CPU_JLI\"'"
|
||||
if test "x$OPENJDK_$1_OS" = xsolaris; then
|
||||
if test "x$OPENJDK_$1_CPU_ARCH" = xsparc; then
|
||||
OPENJDK_$1_CPU_JLI_CFLAGS="$OPENJDK_$1_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
|
||||
elif test "x$OPENJDK_$1_CPU_ARCH" = xx86; then
|
||||
OPENJDK_$1_CPU_JLI_CFLAGS="$OPENJDK_$1_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
|
||||
fi
|
||||
fi
|
||||
AC_SUBST(OPENJDK_TARGET_CPU_JLI_CFLAGS)
|
||||
AC_SUBST(OPENJDK_$1_CPU_JLI_CFLAGS)
|
||||
|
||||
OPENJDK_BUILD_CPU_JLI="$OPENJDK_BUILD_CPU"
|
||||
if test "x$OPENJDK_BUILD_CPU" = xx86; then
|
||||
OPENJDK_BUILD_CPU_JLI="i386"
|
||||
elif test "x$OPENJDK_BUILD_OS" != xmacosx && test "x$OPENJDK_BUILD_CPU" = xx86_64; then
|
||||
# On all platforms except macosx, we replace x86_64 with amd64.
|
||||
OPENJDK_BUILD_CPU_JLI="amd64"
|
||||
fi
|
||||
# Now setup the -D flags for building libjli.
|
||||
OPENJDK_BUILD_CPU_JLI_CFLAGS="-DLIBARCHNAME='\"$OPENJDK_BUILD_CPU_JLI\"'"
|
||||
if test "x$OPENJDK_BUILD_OS" = xsolaris; then
|
||||
if test "x$OPENJDK_BUILD_CPU_ARCH" = xsparc; then
|
||||
OPENJDK_BUILD_CPU_JLI_CFLAGS="$OPENJDK_BUILD_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"sparc\"' -DLIBARCH64NAME='\"sparcv9\"'"
|
||||
elif test "x$OPENJDK_BUILD_CPU_ARCH" = xx86; then
|
||||
OPENJDK_BUILD_CPU_JLI_CFLAGS="$OPENJDK_BUILD_CPU_JLI_CFLAGS -DLIBARCH32NAME='\"i386\"' -DLIBARCH64NAME='\"amd64\"'"
|
||||
fi
|
||||
fi
|
||||
AC_SUBST(OPENJDK_BUILD_CPU_JLI_CFLAGS)
|
||||
|
||||
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
||||
OPENJDK_TARGET_OS_EXPORT_DIR=macosx
|
||||
if test "x$OPENJDK_$1_OS" = xmacosx; then
|
||||
OPENJDK_$1_OS_EXPORT_DIR=macosx
|
||||
else
|
||||
OPENJDK_TARGET_OS_EXPORT_DIR=${OPENJDK_TARGET_OS_TYPE}
|
||||
OPENJDK_$1_OS_EXPORT_DIR=${OPENJDK_$1_OS_TYPE}
|
||||
fi
|
||||
AC_SUBST(OPENJDK_TARGET_OS_EXPORT_DIR)
|
||||
AC_SUBST(OPENJDK_$1_OS_EXPORT_DIR)
|
||||
|
||||
if test "x$OPENJDK_TARGET_CPU_BITS" = x64; then
|
||||
if test "x$OPENJDK_$1_CPU_BITS" = x64; then
|
||||
A_LP64="LP64:="
|
||||
# -D_LP64=1 is only set on linux and mac. Setting on windows causes diff in
|
||||
# unpack200.exe
|
||||
if test "x$OPENJDK_TARGET_OS" = xlinux || test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
||||
ADD_LP64="-D_LP64=1"
|
||||
if test "x$OPENJDK_$1_OS" = xlinux || test "x$OPENJDK_$1_OS" = xmacosx; then
|
||||
OPENJDK_$1_ADD_LP64="-D_LP64=1"
|
||||
fi
|
||||
fi
|
||||
AC_SUBST(LP64,$A_LP64)
|
||||
if test "x$OPENJDK_BUILD_CPU_BITS" = x64; then
|
||||
if test "x$OPENJDK_BUILD_OS" = xlinux || test "x$OPENJDK_BUILD_OS" = xmacosx; then
|
||||
OPENJDK_BUILD_ADD_LP64="-D_LP64=1"
|
||||
fi
|
||||
fi
|
||||
|
||||
if test "x$COMPILE_TYPE" = "xcross"; then
|
||||
# FIXME: ... or should this include reduced builds..?
|
||||
DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_TARGET_CPU_LEGACY"
|
||||
DEFINE_CROSS_COMPILE_ARCH="CROSS_COMPILE_ARCH:=$OPENJDK_$1_CPU_LEGACY"
|
||||
else
|
||||
DEFINE_CROSS_COMPILE_ARCH=""
|
||||
fi
|
||||
AC_SUBST(DEFINE_CROSS_COMPILE_ARCH)
|
||||
|
||||
# ZERO_ARCHDEF is used to enable architecture-specific code
|
||||
case "${OPENJDK_TARGET_CPU}" in
|
||||
ppc) ZERO_ARCHDEF=PPC32 ;;
|
||||
ppc64) ZERO_ARCHDEF=PPC64 ;;
|
||||
s390*) ZERO_ARCHDEF=S390 ;;
|
||||
sparc*) ZERO_ARCHDEF=SPARC ;;
|
||||
x86_64*) ZERO_ARCHDEF=AMD64 ;;
|
||||
x86) ZERO_ARCHDEF=IA32 ;;
|
||||
*) ZERO_ARCHDEF=$(echo "${OPENJDK_TARGET_CPU_LEGACY_LIB}" | tr a-z A-Z)
|
||||
esac
|
||||
AC_SUBST(ZERO_ARCHDEF)
|
||||
# Convert openjdk platform names to hotspot names
|
||||
|
||||
HOTSPOT_$1_OS=${OPENJDK_$1_OS}
|
||||
if test "x$OPENJDK_$1_OS" = xmacosx; then
|
||||
HOTSPOT_$1_OS=bsd
|
||||
fi
|
||||
AC_SUBST(HOTSPOT_$1_OS)
|
||||
|
||||
HOTSPOT_$1_OS_TYPE=${OPENJDK_$1_OS_TYPE}
|
||||
if test "x$OPENJDK_$1_OS_TYPE" = xunix; then
|
||||
HOTSPOT_$1_OS_TYPE=posix
|
||||
fi
|
||||
AC_SUBST(HOTSPOT_$1_OS_TYPE)
|
||||
|
||||
HOTSPOT_$1_CPU=${OPENJDK_$1_CPU}
|
||||
if test "x$OPENJDK_$1_CPU" = xx86; then
|
||||
HOTSPOT_$1_CPU=x86_32
|
||||
elif test "x$OPENJDK_$1_CPU" = xsparcv9; then
|
||||
HOTSPOT_$1_CPU=sparc
|
||||
elif test "x$OPENJDK_$1_CPU" = xppc64; then
|
||||
HOTSPOT_$1_CPU=ppc_64
|
||||
fi
|
||||
AC_SUBST(HOTSPOT_$1_CPU)
|
||||
|
||||
# This is identical with OPENJDK_*, but define anyway for consistency.
|
||||
HOTSPOT_$1_CPU_ARCH=${OPENJDK_$1_CPU_ARCH}
|
||||
AC_SUBST(HOTSPOT_$1_CPU_ARCH)
|
||||
|
||||
# Setup HOTSPOT_$1_CPU_DEFINE
|
||||
if test "x$OPENJDK_$1_CPU" = xx86; then
|
||||
HOTSPOT_$1_CPU_DEFINE=IA32
|
||||
elif test "x$OPENJDK_$1_CPU" = xx86_64; then
|
||||
HOTSPOT_$1_CPU_DEFINE=AMD64
|
||||
elif test "x$OPENJDK_$1_CPU" = xsparcv9; then
|
||||
HOTSPOT_$1_CPU_DEFINE=SPARC
|
||||
elif test "x$OPENJDK_$1_CPU" = xaarch64; then
|
||||
HOTSPOT_$1_CPU_DEFINE=AARCH64
|
||||
elif test "x$OPENJDK_$1_CPU" = xppc64; then
|
||||
HOTSPOT_$1_CPU_DEFINE=PPC64
|
||||
|
||||
# The cpu defines below are for zero, we don't support them directly.
|
||||
elif test "x$OPENJDK_$1_CPU" = xsparc; then
|
||||
HOTSPOT_$1_CPU_DEFINE=SPARC
|
||||
elif test "x$OPENJDK_$1_CPU" = xppc; then
|
||||
HOTSPOT_$1_CPU_DEFINE=PPC32
|
||||
elif test "x$OPENJDK_$1_CPU" = xs390; then
|
||||
HOTSPOT_$1_CPU_DEFINE=S390
|
||||
elif test "x$OPENJDK_$1_CPU" = ss390x; then
|
||||
HOTSPOT_$1_CPU_DEFINE=S390
|
||||
fi
|
||||
AC_SUBST(HOTSPOT_$1_CPU_DEFINE)
|
||||
|
||||
])
|
||||
|
||||
AC_DEFUN([PLATFORM_SET_RELEASE_FILE_OS_VALUES],
|
||||
@ -521,6 +521,10 @@ AC_DEFUN([PLATFORM_SET_COMPILER_TARGET_BITS_FLAGS],
|
||||
CFLAGS_JDK="${CFLAGS_JDK}${ADDED_CFLAGS}"
|
||||
CXXFLAGS_JDK="${CXXFLAGS_JDK}${ADDED_CXXFLAGS}"
|
||||
LDFLAGS_JDK="${LDFLAGS_JDK}${ADDED_LDFLAGS}"
|
||||
|
||||
JVM_CFLAGS="$JVM_CFLAGS $ADDED_CFLAGS"
|
||||
JVM_LDFLAGS="$JVM_LDFLAGS $ADDED_LDFLAGS"
|
||||
JVM_ASFLAGS="$JVM_ASFLAGS $ADDED_CFLAGS"
|
||||
])
|
||||
|
||||
AC_DEFUN_ONCE([PLATFORM_SETUP_OPENJDK_TARGET_BITS],
|
||||
@ -542,6 +546,11 @@ AC_DEFUN_ONCE([PLATFORM_SETUP_OPENJDK_TARGET_BITS],
|
||||
PLATFORM_SET_COMPILER_TARGET_BITS_FLAGS
|
||||
fi
|
||||
fi
|
||||
if test "x$OPENJDK_TARGET_OS" = xmacosx; then
|
||||
JVM_CFLAGS="$JVM_CFLAGS ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
|
||||
JVM_LDFLAGS="$JVM_LDFLAGS ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
|
||||
JVM_ASFLAGS="$JVM_ASFLAGS ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}"
|
||||
fi
|
||||
|
||||
# Make compilation sanity check
|
||||
AC_CHECK_HEADERS([stdio.h], , [
|
||||
|
||||
@ -82,6 +82,13 @@ OPENJDK_TARGET_CPU_OSARCH:=@OPENJDK_TARGET_CPU_OSARCH@
|
||||
OPENJDK_TARGET_CPU_JLI_CFLAGS:=@OPENJDK_TARGET_CPU_JLI_CFLAGS@
|
||||
OPENJDK_TARGET_OS_EXPORT_DIR:=@OPENJDK_TARGET_OS_EXPORT_DIR@
|
||||
|
||||
HOTSPOT_TARGET_OS := @HOTSPOT_TARGET_OS@
|
||||
HOTSPOT_TARGET_OS_TYPE := @HOTSPOT_TARGET_OS_TYPE@
|
||||
|
||||
HOTSPOT_TARGET_CPU := @HOTSPOT_TARGET_CPU@
|
||||
HOTSPOT_TARGET_CPU_ARCH := @HOTSPOT_TARGET_CPU_ARCH@
|
||||
HOTSPOT_TARGET_CPU_DEFINE := @HOTSPOT_TARGET_CPU_DEFINE@
|
||||
|
||||
# We are building on this build system.
|
||||
# When not cross-compiling, it is the same as the target.
|
||||
OPENJDK_BUILD_OS:=@OPENJDK_BUILD_OS@
|
||||
@ -192,6 +199,7 @@ PRODUCT_NAME:=@PRODUCT_NAME@
|
||||
PRODUCT_SUFFIX:=@PRODUCT_SUFFIX@
|
||||
JDK_RC_PLATFORM_NAME:=@JDK_RC_PLATFORM_NAME@
|
||||
COMPANY_NAME:=@COMPANY_NAME@
|
||||
HOTSPOT_VM_DISTRO:=@HOTSPOT_VM_DISTRO@
|
||||
MACOSX_BUNDLE_NAME_BASE=@MACOSX_BUNDLE_NAME_BASE@
|
||||
MACOSX_BUNDLE_ID_BASE=@MACOSX_BUNDLE_ID_BASE@
|
||||
USERNAME:=@USERNAME@
|
||||
@ -201,11 +209,32 @@ RUNTIME_NAME=$(PRODUCT_NAME) $(PRODUCT_SUFFIX)
|
||||
|
||||
# How to compile the code: release, fastdebug or slowdebug
|
||||
DEBUG_LEVEL:=@DEBUG_LEVEL@
|
||||
HOTSPOT_DEBUG_LEVEL:=@HOTSPOT_DEBUG_LEVEL@
|
||||
|
||||
# This is the JDK variant to build.
|
||||
# The JDK variant is a name for a specific set of modules to be compiled for the JDK.
|
||||
JDK_VARIANT:=@JDK_VARIANT@
|
||||
|
||||
# Which JVM variants to build (space-separated list)
|
||||
JVM_VARIANTS := @JVM_VARIANTS@
|
||||
|
||||
# Lists of features per variant. Only relevant for the variants listed in
|
||||
# JVM_VARIANTS.
|
||||
JVM_FEATURES_server := @JVM_FEATURES_server@
|
||||
JVM_FEATURES_client := @JVM_FEATURES_client@
|
||||
JVM_FEATURES_core := @JVM_FEATURES_core@
|
||||
JVM_FEATURES_minimal := @JVM_FEATURES_minimal@
|
||||
JVM_FEATURES_zero := @JVM_FEATURES_zero@
|
||||
JVM_FEATURES_zeroshark := @JVM_FEATURES_zeroshark@
|
||||
JVM_FEATURES_custom := @JVM_FEATURES_custom@
|
||||
|
||||
# Used for make-time verifications
|
||||
VALID_JVM_FEATURES := @VALID_JVM_FEATURES@
|
||||
VALID_JVM_VARIANTS := @VALID_JVM_VARIANTS@
|
||||
|
||||
# Control use of precompiled header in hotspot libjvm build
|
||||
USE_PRECOMPILED_HEADER := @USE_PRECOMPILED_HEADER@
|
||||
|
||||
# Should we compile support for running with a graphical UI? (ie headful)
|
||||
# Should we compile support for running without? (ie headless)
|
||||
SUPPORT_HEADFUL:=@SUPPORT_HEADFUL@
|
||||
@ -213,25 +242,11 @@ SUPPORT_HEADLESS:=@SUPPORT_HEADLESS@
|
||||
# Legacy defines controlled by the SUPPORT_HEADLESS and SUPPORT_HEADFUL options.
|
||||
@BUILD_HEADLESS@
|
||||
|
||||
# These are the libjvms that we want to build.
|
||||
# The java launcher uses the default.
|
||||
# The others can be selected by specifying -client -server -minimal1 -zero or -zeroshark
|
||||
# on the java launcher command line.
|
||||
JVM_VARIANTS:=@JVM_VARIANTS@
|
||||
JVM_VARIANT_SERVER:=@JVM_VARIANT_SERVER@
|
||||
JVM_VARIANT_CLIENT:=@JVM_VARIANT_CLIENT@
|
||||
JVM_VARIANT_MINIMAL1:=@JVM_VARIANT_MINIMAL1@
|
||||
JVM_VARIANT_ZERO:=@JVM_VARIANT_ZERO@
|
||||
JVM_VARIANT_ZEROSHARK:=@JVM_VARIANT_ZEROSHARK@
|
||||
JVM_VARIANT_CORE:=@JVM_VARIANT_CORE@
|
||||
# Legacy support
|
||||
USE_NEW_HOTSPOT_BUILD:=@USE_NEW_HOTSPOT_BUILD@
|
||||
|
||||
# Universal binaries on macosx
|
||||
MACOSX_UNIVERSAL=@MACOSX_UNIVERSAL@
|
||||
|
||||
# Legacy setting: -debug or -fastdebug
|
||||
# Still used in version string...
|
||||
BUILD_VARIANT_RELEASE:=@BUILD_VARIANT_RELEASE@
|
||||
|
||||
# JDK_OUTPUTDIR specifies where a working jvm is built.
|
||||
# You can run $(JDK_OUTPUTDIR)/bin/java
|
||||
# Though the layout of the contents of $(JDK_OUTPUTDIR) is not
|
||||
@ -318,6 +333,11 @@ MACOSX_VERSION_MIN=@MACOSX_VERSION_MIN@
|
||||
# Toolchain type: gcc, clang, solstudio, lxc, microsoft...
|
||||
TOOLCHAIN_TYPE:=@TOOLCHAIN_TYPE@
|
||||
TOOLCHAIN_VERSION := @TOOLCHAIN_VERSION@
|
||||
CC_VERSION_NUMBER := @CC_VERSION_NUMBER@
|
||||
CXX_VERSION_NUMBER := @CXX_VERSION_NUMBER@
|
||||
|
||||
# Legacy support
|
||||
HOTSPOT_TOOLCHAIN_TYPE := @HOTSPOT_TOOLCHAIN_TYPE@
|
||||
|
||||
# Option used to tell the compiler whether to create 32- or 64-bit executables
|
||||
COMPILER_TARGET_BITS_FLAG:=@COMPILER_TARGET_BITS_FLAG@
|
||||
@ -336,14 +356,18 @@ LD_OUT_OPTION:=@LD_OUT_OPTION@
|
||||
AR_OUT_OPTION:=@AR_OUT_OPTION@
|
||||
|
||||
# Flags used for overriding the default opt setting for a C/C++ source file.
|
||||
C_O_FLAG_HIGHEST_JVM:=@C_O_FLAG_HIGHEST_JVM@
|
||||
C_O_FLAG_HIGHEST:=@C_O_FLAG_HIGHEST@
|
||||
C_O_FLAG_HI:=@C_O_FLAG_HI@
|
||||
C_O_FLAG_NORM:=@C_O_FLAG_NORM@
|
||||
C_O_FLAG_NONE:=@C_O_FLAG_NONE@
|
||||
C_O_FLAG_SIZE:=@C_O_FLAG_SIZE@
|
||||
CXX_O_FLAG_HIGHEST_JVM:=@CXX_O_FLAG_HIGHEST_JVM@
|
||||
CXX_O_FLAG_HIGHEST:=@CXX_O_FLAG_HIGHEST@
|
||||
CXX_O_FLAG_HI:=@CXX_O_FLAG_HI@
|
||||
CXX_O_FLAG_NORM:=@CXX_O_FLAG_NORM@
|
||||
CXX_O_FLAG_NONE:=@CXX_O_FLAG_NONE@
|
||||
CXX_O_FLAG_SIZE:=@CXX_O_FLAG_SIZE@
|
||||
|
||||
C_FLAG_DEPS:=@C_FLAG_DEPS@
|
||||
CXX_FLAG_DEPS:=@CXX_FLAG_DEPS@
|
||||
@ -372,6 +396,23 @@ CXXFLAGS_JDKEXE:=@CXXFLAGS_JDKEXE@
|
||||
|
||||
LDFLAGS_HASH_STYLE := @LDFLAGS_HASH_STYLE@
|
||||
|
||||
JVM_CFLAGS := @JVM_CFLAGS@
|
||||
JVM_CFLAGS_SYMBOLS := @JVM_CFLAGS_SYMBOLS@
|
||||
JVM_LDFLAGS := @JVM_LDFLAGS@
|
||||
JVM_ASFLAGS := @JVM_ASFLAGS@
|
||||
JVM_LIBS := @JVM_LIBS@
|
||||
JVM_RCFLAGS := @JVM_RCFLAGS@
|
||||
|
||||
# Flags for zeroshark
|
||||
LLVM_CFLAGS := @LLVM_CFLAGS@
|
||||
LLVM_LIBS := @LLVM_LIBS@
|
||||
LLVM_LDFLAGS := @LLVM_LDFLAGS@
|
||||
|
||||
# These flags might contain variables set by a custom extension that is included later.
|
||||
EXTRA_CFLAGS = @EXTRA_CFLAGS@
|
||||
EXTRA_CXXFLAGS = @EXTRA_CXXFLAGS@
|
||||
EXTRA_LDFLAGS = @EXTRA_LDFLAGS@
|
||||
|
||||
CXX:=@FIXPATH@ @CCACHE@ @ICECC@ @CXX@
|
||||
|
||||
CPP:=@FIXPATH@ @CPP@
|
||||
@ -628,6 +669,7 @@ XATTR:=@XATTR@
|
||||
JT_HOME:=@JT_HOME@
|
||||
JTREGEXE:=@JTREGEXE@
|
||||
XCODEBUILD=@XCODEBUILD@
|
||||
DTRACE := @DTRACE@
|
||||
FIXPATH:=@FIXPATH@
|
||||
|
||||
# Build setup
|
||||
|
||||
@ -930,6 +930,17 @@ AC_DEFUN_ONCE([TOOLCHAIN_MISC_CHECKS],
|
||||
rm -rf version-script.map main.c a.out
|
||||
fi
|
||||
AC_SUBST(USING_BROKEN_SUSE_LD)
|
||||
|
||||
# Setup hotspot lecagy names for toolchains
|
||||
HOTSPOT_TOOLCHAIN_TYPE=$TOOLCHAIN_TYPE
|
||||
if test "x$TOOLCHAIN_TYPE" = xclang; then
|
||||
HOTSPOT_TOOLCHAIN_TYPE=gcc
|
||||
elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
|
||||
HOTSPOT_TOOLCHAIN_TYPE=sparcWorks
|
||||
elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
|
||||
HOTSPOT_TOOLCHAIN_TYPE=visCPP
|
||||
fi
|
||||
AC_SUBST(HOTSPOT_TOOLCHAIN_TYPE)
|
||||
])
|
||||
|
||||
# Setup the JTReg Regression Test Harness.
|
||||
|
||||
@ -32,6 +32,7 @@ PRODUCT_NAME=OpenJDK
|
||||
PRODUCT_SUFFIX="Runtime Environment"
|
||||
JDK_RC_PLATFORM_NAME=Platform
|
||||
COMPANY_NAME=N/A
|
||||
HOTSPOT_VM_DISTRO="OpenJDK"
|
||||
|
||||
# Might need better names for these
|
||||
MACOSX_BUNDLE_NAME_BASE="OpenJDK"
|
||||
|
||||
@ -732,6 +732,13 @@ compare_bin_file() {
|
||||
SYM_SORT_CMD="cat"
|
||||
fi
|
||||
|
||||
if [ -n "$SYMBOLS_DIFF_FILTER" ] && [ -z "$NEED_SYMBOLS_DIFF_FILTER" ] \
|
||||
|| [[ "$NEED_SYMBOLS_DIFF_FILTER" = *"$BIN_FILE"* ]]; then
|
||||
this_SYMBOLS_DIFF_FILTER="$SYMBOLS_DIFF_FILTER"
|
||||
else
|
||||
this_SYMBOLS_DIFF_FILTER="$CAT"
|
||||
fi
|
||||
|
||||
# Check symbols
|
||||
if [ "$OPENJDK_TARGET_OS" = "windows" ]; then
|
||||
# The output from dumpbin on windows differs depending on if the debug symbol
|
||||
@ -750,8 +757,16 @@ compare_bin_file() {
|
||||
$NM -j $ORIG_OTHER_FILE 2> /dev/null | $SYM_SORT_CMD > $WORK_FILE_BASE.symbols.other
|
||||
$NM -j $ORIG_THIS_FILE 2> /dev/null | $SYM_SORT_CMD > $WORK_FILE_BASE.symbols.this
|
||||
else
|
||||
$NM -a $ORIG_OTHER_FILE 2> /dev/null | $GREP -v $NAME | $AWK '{print $2, $3, $4, $5}' | $SYM_SORT_CMD > $WORK_FILE_BASE.symbols.other
|
||||
$NM -a $ORIG_THIS_FILE 2> /dev/null | $GREP -v $NAME | $AWK '{print $2, $3, $4, $5}' | $SYM_SORT_CMD > $WORK_FILE_BASE.symbols.this
|
||||
$NM -a $ORIG_OTHER_FILE 2> /dev/null | $GREP -v $NAME \
|
||||
| $AWK '{print $2, $3, $4, $5}' \
|
||||
| eval "$this_SYMBOLS_DIFF_FILTER" \
|
||||
| $SYM_SORT_CMD \
|
||||
> $WORK_FILE_BASE.symbols.other
|
||||
$NM -a $ORIG_THIS_FILE 2> /dev/null | $GREP -v $NAME \
|
||||
| $AWK '{print $2, $3, $4, $5}' \
|
||||
| eval "$this_SYMBOLS_DIFF_FILTER" \
|
||||
| $SYM_SORT_CMD \
|
||||
> $WORK_FILE_BASE.symbols.this
|
||||
fi
|
||||
|
||||
LC_ALL=C $DIFF $WORK_FILE_BASE.symbols.other $WORK_FILE_BASE.symbols.this > $WORK_FILE_BASE.symbols.diff
|
||||
@ -828,9 +843,10 @@ compare_bin_file() {
|
||||
FULLDUMP_DIFF_FILTER="$CAT"
|
||||
fi
|
||||
$FULLDUMP_CMD $OTHER_FILE | eval "$BUILD_ID_FILTER" | eval "$FULLDUMP_DIFF_FILTER" \
|
||||
> $WORK_FILE_BASE.fulldump.other 2>&1
|
||||
> $WORK_FILE_BASE.fulldump.other 2>&1 &
|
||||
$FULLDUMP_CMD $THIS_FILE | eval "$BUILD_ID_FILTER" | eval "$FULLDUMP_DIFF_FILTER" \
|
||||
> $WORK_FILE_BASE.fulldump.this 2>&1
|
||||
> $WORK_FILE_BASE.fulldump.this 2>&1 &
|
||||
wait
|
||||
|
||||
LC_ALL=C $DIFF $WORK_FILE_BASE.fulldump.other $WORK_FILE_BASE.fulldump.this \
|
||||
> $WORK_FILE_BASE.fulldump.diff
|
||||
@ -854,18 +870,19 @@ compare_bin_file() {
|
||||
FULLDUMP_MSG=" "
|
||||
DIFF_FULLDUMP=
|
||||
if [[ "$KNOWN_FULLDUMP_DIFF $ACCEPTED_FULLDUMP_DIFF" = *"$BIN_FILE"* ]]; then
|
||||
FULLDUMP_MSG=" ! "
|
||||
FULLDUMP_MSG=" ! "
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
|
||||
# Compare disassemble output
|
||||
if [ -n "$DIS_CMD" ] && [ -z "$SKIP_DIS_DIFF" ]; then
|
||||
# By default we filter out differences that include references to symbols.
|
||||
# To get a raw diff with the complete disassembly, set
|
||||
# DIS_DIFF_FILTER="$CAT"
|
||||
if [ -z "$DIS_DIFF_FILTER" ]; then
|
||||
DIS_DIFF_FILTER="$GREP -v ' # .* <.*>$' | $SED -r -e 's/(\b|x)([0-9a-fA-F]+)(\b|:|>)/X/g'"
|
||||
this_DIS_DIFF_FILTER="$CAT"
|
||||
if [ -n "$DIS_DIFF_FILTER" ]; then
|
||||
if [ -z "$NEED_DIS_DIFF_FILTER" ] \
|
||||
|| [[ "$NEED_DIS_DIFF_FILTER" = *"$BIN_FILE"* ]]; then
|
||||
this_DIS_DIFF_FILTER="$DIS_DIFF_FILTER"
|
||||
fi
|
||||
fi
|
||||
if [ "$OPENJDK_TARGET_OS" = "windows" ]; then
|
||||
DIS_GREP_ARG=-a
|
||||
@ -873,9 +890,10 @@ compare_bin_file() {
|
||||
DIS_GREP_ARG=
|
||||
fi
|
||||
$DIS_CMD $OTHER_FILE | $GREP $DIS_GREP_ARG -v $NAME \
|
||||
| eval "$DIS_DIFF_FILTER" > $WORK_FILE_BASE.dis.other 2>&1
|
||||
| eval "$this_DIS_DIFF_FILTER" > $WORK_FILE_BASE.dis.other 2>&1 &
|
||||
$DIS_CMD $THIS_FILE | $GREP $DIS_GREP_ARG -v $NAME \
|
||||
| eval "$DIS_DIFF_FILTER" > $WORK_FILE_BASE.dis.this 2>&1
|
||||
| eval "$this_DIS_DIFF_FILTER" > $WORK_FILE_BASE.dis.this 2>&1 &
|
||||
wait
|
||||
|
||||
LC_ALL=C $DIFF $WORK_FILE_BASE.dis.other $WORK_FILE_BASE.dis.this > $WORK_FILE_BASE.dis.diff
|
||||
|
||||
@ -884,11 +902,15 @@ compare_bin_file() {
|
||||
DIS_MSG=$($PRINTF "%8d" $DIS_DIFF_SIZE)
|
||||
if [[ "$ACCEPTED_DIS_DIFF" != *"$BIN_FILE"* ]]; then
|
||||
DIFF_DIS=true
|
||||
if [[ "$KNOWN_DIS_DIFF" != *"$BIN_FILE"* ]]; then
|
||||
if [ "$MAX_KNOWN_DIS_DIFF_SIZE" = "" ]; then
|
||||
MAX_KNOWN_DIS_DIFF_SIZE="0"
|
||||
fi
|
||||
if [[ "$KNOWN_DIS_DIFF" = *"$BIN_FILE"* ]] \
|
||||
&& [ "$DIS_DIFF_SIZE" -lt "$MAX_KNOWN_DIS_DIFF_SIZE" ]; then
|
||||
DIS_MSG=" $DIS_MSG "
|
||||
else
|
||||
DIS_MSG="*$DIS_MSG*"
|
||||
REGRESSIONS=true
|
||||
else
|
||||
DIS_MSG=" $DIS_MSG "
|
||||
fi
|
||||
else
|
||||
DIS_MSG="($DIS_MSG)"
|
||||
|
||||
@ -113,21 +113,36 @@ if [ "$OPENJDK_TARGET_OS" = "linux" ]; then
|
||||
./bin/xjc
|
||||
"
|
||||
|
||||
# Issue with __FILE__ usage in generated header files prevent clean fulldump diff of
|
||||
# server jvm with old hotspot build.
|
||||
KNOWN_FULLDUMP_DIFF="
|
||||
./lib$OPENJDK_TARGET_CPU_LIBDIR/client/libjvm.so
|
||||
./lib$OPENJDK_TARGET_CPU_LIBDIR/server/libjvm.so
|
||||
./lib$OPENJDK_TARGET_CPU_LIBDIR/minimal/libjvm.so
|
||||
"
|
||||
|
||||
if [ "$OPENJDK_TARGET_CPU" = "x86" ]; then
|
||||
KNOWN_DIS_DIFF="
|
||||
./lib$OPENJDK_TARGET_CPU_LIBDIR/server/libjvm.so
|
||||
if [ "$OPENJDK_TARGET_CPU" = "arm" ]; then
|
||||
# NOTE: When comparing the old and new hotspot builds, the link time
|
||||
# optimization makes good comparisons impossible. Fulldump compare always
|
||||
# fails and disassembly can end up with some functions in different order.
|
||||
# So for now, accept the difference but put a limit on the size. The
|
||||
# different order of functions shouldn't result in a very big diff.
|
||||
KNOWN_FULLDUMP_DIFF="
|
||||
./lib$OPENJDK_TARGET_CPU_LIBDIR/minimal/libjvm.so
|
||||
"
|
||||
|
||||
# Link time optimization adds random numbers to symbol names
|
||||
NEED_DIS_DIFF_FILTER="
|
||||
./lib$OPENJDK_TARGET_CPU_LIBDIR/minimal/libjvm.so
|
||||
"
|
||||
DIS_DIFF_FILTER="$SED -r \
|
||||
-e 's/\.[0-9]+/.X/g' \
|
||||
-e 's/\t[0-9a-f]{4} [0-9a-f]{4} /\tXXXX XXXX /' \
|
||||
-e 's/\t[0-9a-f]{5,} /\t<HEX> /' \
|
||||
"
|
||||
KNOWN_DIS_DIFF="
|
||||
./lib$OPENJDK_TARGET_CPU_LIBDIR/minimal/libjvm.so
|
||||
"
|
||||
MAX_KNOWN_DIS_DIFF_SIZE="3000"
|
||||
|
||||
NEED_SYMBOLS_DIFF_FILTER="
|
||||
./lib$OPENJDK_TARGET_CPU_LIBDIR/minimal/libjvm.so
|
||||
"
|
||||
SYMBOLS_DIFF_FILTER="$SED -r \
|
||||
-e 's/\.[0-9]+/.X/g'
|
||||
"
|
||||
DIS_DIFF_FILTER="$SED \
|
||||
-e 's/\(:\t\)\([0-9a-z]\{2,2\} \)\{1,7\}/\1<hex>/g' \
|
||||
-e 's/0x[0-9a-z]\{2,9\}/<hex>/g'"
|
||||
fi
|
||||
fi
|
||||
|
||||
@ -250,15 +265,10 @@ if [ "$OPENJDK_TARGET_OS" = "solaris" ] && [ "$OPENJDK_TARGET_CPU" = "x86_64" ];
|
||||
|
||||
SKIP_FULLDUMP_DIFF="true"
|
||||
|
||||
# Filter random C++ symbol strings.
|
||||
# Some numbers differ randomly.
|
||||
# Random strings looking like this differ: <.XAKoKoPIac2W0OA.
|
||||
DIS_DIFF_FILTER="$SED \
|
||||
-e 's/\.[a-zA-Z0-9_\$]\{15\}/<SYM>/g' \
|
||||
-e 's/\(\# \)[0-9a-f]*\( <\)/\1<HEX>\2/g' \
|
||||
-e 's/0x[0-9a-f]*$/<HEX>/g' \
|
||||
-e 's/0x[0-9a-f]*\([,(>]\)/<HEX>\1/g' \
|
||||
-e 's/: [0-9a-f][0-9a-f]\( [0-9a-f][0-9a-f]\)\{2,10\}/: <NUMS>/g' \
|
||||
-e 's/ [\.A-Za-z0-9%@]\{16\}$/ <BIN>/g'"
|
||||
-e 's/<\.[A-Za-z0-9]\{\15}\./<.SYM./' \
|
||||
"
|
||||
|
||||
fi
|
||||
|
||||
@ -380,23 +390,18 @@ if [ "$OPENJDK_TARGET_OS" = "solaris" ] && [ "$OPENJDK_TARGET_CPU" = "sparcv9" ]
|
||||
./bin/xjc
|
||||
"
|
||||
|
||||
# Some numbers differ randomly.
|
||||
DIS_DIFF_FILTER="$SED \
|
||||
-e 's/\$[a-zA-Z0-9_\$]\{15\}/<SYM>/g' \
|
||||
-e 's/: [0-9a-f][0-9a-f]\( [0-9a-f][0-9a-f]\)\{2,10\}/: <NUMS>/g' \
|
||||
-e 's/, [0-9a-fx\-]\{1,8\}/, <CONST>/g' \
|
||||
-e 's/call [0-9a-f]\{7\}/call <ADDR>/g' \
|
||||
-e 's/^[0-9a-f]\{16\}/<ADDR>:/' \
|
||||
-e 's/^ *[0-9a-f]\{3,8\}:/ <ADDR>:/' \
|
||||
-e 's/: [0-9a-f][0-9a-f]\( [0-9a-f][0-9a-f]\)\{2,10\}/: <NUMS>/' \
|
||||
-e 's/\$[a-zA-Z0-9_\$]\{15\}\./<SYM>./' \
|
||||
-e 's/0x[0-9a-f]\{1,8\}/<HEX>/g' \
|
||||
-e 's/\! [0-9a-f]\{1,8\} /! <ADDR> /g'"
|
||||
-e 's/\! [0-9a-f]\{1,8\} /! <ADDR> /' \
|
||||
-e 's/, [0-9a-fx\-]\{1,8\}/, <ADDR>/g' \
|
||||
-e 's/call [0-9a-f]\{4,7\}/call <ADDR>/' \
|
||||
"
|
||||
|
||||
# libjvm.so
|
||||
# __FILE__ macro usage in debug.hpp causes differences between old and new
|
||||
# hotspot builds in ad_sparc.o and ad_sparc_clone.o. The .o files compare
|
||||
# equal when stripped, but at link time differences appear. Removing
|
||||
# __FILE__ from ShouldNotCallThis() and ShouldNotReachHere() removes
|
||||
# the differences.
|
||||
KNOWN_DIS_DIFF="
|
||||
./lib/sparcv9/server/libjvm.so
|
||||
./lib/sparcv9/libsaproc.so
|
||||
"
|
||||
|
||||
@ -419,6 +424,7 @@ if [ "$OPENJDK_TARGET_OS" = "windows" ]; then
|
||||
./demo/jvmti/minst/lib/minst.dll
|
||||
./bin/attach.dll
|
||||
./bin/jsoundds.dll
|
||||
./bin/client/jvm.dll
|
||||
./bin/server/jvm.dll
|
||||
./bin/appletviewer.exe
|
||||
./bin/idlj.exe
|
||||
@ -469,22 +475,39 @@ if [ "$OPENJDK_TARGET_OS" = "windows" ]; then
|
||||
./bin/jabswitch.exe
|
||||
"
|
||||
|
||||
# On windows, there are unavoidable allignment issues making
|
||||
# a perfect disasm diff impossible. Filter out the following:
|
||||
# * Random parts of C++ symbols (this is a bit greedy, but does the trick)
|
||||
# @XXXXX
|
||||
# * Hexadecimal addresses that are sometimes alligned differently.
|
||||
# * Dates in version strings XXXX_XX_XX.
|
||||
DIS_DIFF_FILTER="$SED \
|
||||
-e 's/^ [0-9A-F]\{16\}: //g' \
|
||||
-e 's/[@?][A-Za-z0-9_]\{1,25\}/<SYM>/g' \
|
||||
-e 's/\([\[+]\)[0-9A-F]\{4,16\}h\]/\1<HEXSTR>]/g' \
|
||||
-e 's/_[0-9]\{4\}_[0-9]\{2\}_[0-9]\{2\}/_<DATE>/g'"
|
||||
#DIS_DIFF_FILTER="$CAT"
|
||||
if [ "$OPENJDK_TARGET_CPU" = "x86" ]; then
|
||||
DIS_DIFF_FILTER="$SED -r \
|
||||
-e 's/^ [0-9A-F]{16}: //' \
|
||||
-e 's/^ [0-9A-F]{8}: / <ADDR>: /' \
|
||||
-e 's/(offset \?\?)_C@_.*/\1<SYM>/' \
|
||||
-e 's/[@?][A-Za-z0-9_]{1,25}/<SYM>/' \
|
||||
-e 's/([-,+])[0-9A-F]{2,16}/\1<HEXSTR>/g' \
|
||||
-e 's/\[[0-9A-F]{4,16}h\]/[<HEXSTR>]/' \
|
||||
-e 's/: ([a-z]{2}[a-z ]{2}) [0-9A-F]{2,16}h?$/: \1 <HEXSTR>/' \
|
||||
-e 's/_20[0-9]{2}_[0-1][0-9]_[0-9]{2}/_<DATE>/' \
|
||||
"
|
||||
elif [ "$OPENJDK_TARGET_CPU" = "x86_64" ]; then
|
||||
DIS_DIFF_FILTER="$SED -r \
|
||||
-e 's/^ [0-9A-F]{16}: //' \
|
||||
-e 's/\[[0-9A-F]{4,16}h\]/[<HEXSTR>]/' \
|
||||
-e 's/([,+])[0-9A-F]{2,16}h/\1<HEXSTR>/' \
|
||||
-e 's/([a-z]{2}[a-z ]{2}) [0-9A-F]{4,16}$/\1 <HEXSTR>/' \
|
||||
-e 's/\[\?\?_C@_.*/[<SYM>]/' \
|
||||
"
|
||||
fi
|
||||
|
||||
SKIP_BIN_DIFF="true"
|
||||
SKIP_FULLDUMP_DIFF="true"
|
||||
|
||||
# NOTE: When comparing the old and new hotspot builds, the server jvm.dll
|
||||
# cannot be made equal in disassembly. Some functions just always end up
|
||||
# in different order. So for now, accept the difference but put a limit
|
||||
# on the size. The different order of functions shouldn't result in a very
|
||||
# big diff.
|
||||
KNOWN_DIS_DIFF="
|
||||
./bin/server/jvm.dll
|
||||
"
|
||||
MAX_KNOWN_DIS_DIFF_SIZE="2000000"
|
||||
fi
|
||||
|
||||
|
||||
@ -565,6 +588,7 @@ if [ "$OPENJDK_TARGET_OS" = "macosx" ]; then
|
||||
./Contents/Home/lib/libverify.dylib
|
||||
./Contents/Home/lib/libsaproc.dylib
|
||||
./Contents/Home/lib/libsplashscreen.dylib
|
||||
./Contents/Home/lib/server/libjsig.dylib
|
||||
./Contents/Home/lib/server/libjvm.dylib
|
||||
./Contents/Home/lib/deploy/JavaControlPanel.prefPane/Contents/MacOS/JavaControlPanel
|
||||
./Contents/Resources/JavaControlPanelHelper
|
||||
@ -590,6 +614,7 @@ if [ "$OPENJDK_TARGET_OS" = "macosx" ]; then
|
||||
./lib/libverify.dylib
|
||||
./lib/libsaproc.dylib
|
||||
./lib/libsplashscreen.dylib
|
||||
./lib/server/libjsig.dylib
|
||||
./lib/server/libjvm.dylib
|
||||
./lib/deploy/JavaControlPanel.prefPane/Contents/MacOS/JavaControlPanel
|
||||
./Versions/A/Resources/finish_installation.app/Contents/MacOS/finish_installation
|
||||
@ -606,7 +631,8 @@ if [ "$OPENJDK_TARGET_OS" = "macosx" ]; then
|
||||
|
||||
DIS_DIFF_FILTER="LANG=C $SED \
|
||||
-e 's/0x[0-9a-f]\{3,16\}/<HEXSTR>/g' -e 's/^[0-9a-f]\{12,20\}/<ADDR>/' \
|
||||
-e 's/## literal pool for: .Java HotSpot(TM) 64-Bit Server VM.*/<COMMENT>/g'
|
||||
-e 's/-20[0-9][0-9]-[0-1][0-9]-[0-3][0-9]-[0-2][0-9]\{5\}/<DATE>/g' \
|
||||
-e 's/), built on .*/), <DATE>/' \
|
||||
"
|
||||
|
||||
fi
|
||||
|
||||
@ -241,7 +241,7 @@ var getJibProfilesProfiles = function (input, common) {
|
||||
target_os: "linux",
|
||||
target_cpu: "x64",
|
||||
dependencies: concat(common.dependencies, "devkit"),
|
||||
configure_args: concat(common.configure_args, "--with-zlib=system"),
|
||||
configure_args: concat(common.configure_args, "--with-zlib=system"),
|
||||
make_args: common.make_args
|
||||
},
|
||||
|
||||
@ -259,7 +259,7 @@ var getJibProfilesProfiles = function (input, common) {
|
||||
target_os: "macosx",
|
||||
target_cpu: "x64",
|
||||
dependencies: concat(common.dependencies, "devkit"),
|
||||
configure_args: concat(common.configure_args, "--with-zlib=system"),
|
||||
configure_args: concat(common.configure_args, "--with-zlib=system"),
|
||||
make_args: common.make_args
|
||||
},
|
||||
|
||||
@ -267,7 +267,7 @@ var getJibProfilesProfiles = function (input, common) {
|
||||
target_os: "solaris",
|
||||
target_cpu: "x64",
|
||||
dependencies: concat(common.dependencies, "devkit", "cups"),
|
||||
configure_args: concat(common.configure_args, "--with-zlib=system"),
|
||||
configure_args: concat(common.configure_args, "--with-zlib=system"),
|
||||
make_args: common.make_args
|
||||
},
|
||||
|
||||
@ -275,7 +275,7 @@ var getJibProfilesProfiles = function (input, common) {
|
||||
target_os: "solaris",
|
||||
target_cpu: "sparcv9",
|
||||
dependencies: concat(common.dependencies, "devkit", "cups"),
|
||||
configure_args: concat(common.configure_args, "--with-zlib=system"),
|
||||
configure_args: concat(common.configure_args, "--with-zlib=system"),
|
||||
make_args: common.make_args
|
||||
},
|
||||
|
||||
|
||||
@ -108,7 +108,9 @@ SRC_JDK_MACOSX_BUNDLE_DIR := $(JDK_MACOSX_BUNDLE_DIR)
|
||||
SRC_JRE_MACOSX_BUNDLE_DIR := $(JRE_MACOSX_BUNDLE_DIR)
|
||||
|
||||
# Bundle up the images
|
||||
bundles: all
|
||||
JPRT_TARGET ?= all
|
||||
ifeq ($(JPRT_TARGET), all)
|
||||
bundles: $(JPRT_TARGET)
|
||||
@$(call TargetEnter)
|
||||
$(MKDIR) -p $(BUILD_OUTPUT)/bundles
|
||||
$(CD) $(SRC_JDK_IMAGE_DIR) && $(ZIP) -y -q -r \
|
||||
@ -128,9 +130,24 @@ bundles: all
|
||||
$(BUILD_OUTPUT)/bundles/$(SYMBOLS_IMAGE_SUBDIR).zip . ; \
|
||||
fi
|
||||
@$(call TargetExit)
|
||||
else
|
||||
# Just fake the bundles
|
||||
bundles: $(JPRT_TARGET)
|
||||
@$(call TargetEnter)
|
||||
$(MKDIR) -p $(BUILD_OUTPUT)/bundles
|
||||
$(CD) $(TOPDIR) && $(ZIP) -y -q -r \
|
||||
$(BUILD_OUTPUT)/bundles/$(JDK_IMAGE_SUBDIR).zip README
|
||||
$(CD) $(TOPDIR) && $(ZIP) -y -q -r \
|
||||
$(BUILD_OUTPUT)/bundles/$(JRE_IMAGE_SUBDIR).zip README
|
||||
$(CD) $(TOPDIR) && $(ZIP) -y -q -r \
|
||||
$(BUILD_OUTPUT)/bundles/$(TEST_IMAGE_SUBDIR).zip README
|
||||
$(CD) $(TOPDIR) && $(ZIP) -y -q -r \
|
||||
$(BUILD_OUTPUT)/bundles/modules.zip README
|
||||
@$(call TargetExit)
|
||||
endif
|
||||
|
||||
# Copy images to one unified location regardless of platform etc.
|
||||
final-images: all
|
||||
final-images: $(JPRT_TARGET)
|
||||
@$(call TargetEnter)
|
||||
$(RM) -r $(BUILD_OUTPUT)/final-images
|
||||
$(MKDIR) -p $(BUILD_OUTPUT)/final-images/$(JDK_IMAGE_SUBDIR)
|
||||
|
||||
@ -229,10 +229,17 @@ ALL_TARGETS += $(LAUNCHER_TARGETS)
|
||||
|
||||
ifeq ($(BUILD_HOTSPOT),true)
|
||||
hotspot:
|
||||
+($(CD) $(SRC_ROOT)/make && $(MAKE) $(MAKE_ARGS) -f HotspotWrapper.gmk)
|
||||
ifeq ($(USE_NEW_HOTSPOT_BUILD), true)
|
||||
+($(CD) $(HOTSPOT_TOPDIR)/makefiles && $(MAKE) $(MAKE_ARGS) -f BuildHotspot.gmk)
|
||||
else
|
||||
+($(CD) $(SRC_ROOT)/make && $(MAKE) $(MAKE_ARGS) -f HotspotWrapper.gmk)
|
||||
endif
|
||||
endif
|
||||
|
||||
ALL_TARGETS += hotspot
|
||||
hotspot-ide-project:
|
||||
+($(CD) $(HOTSPOT_TOPDIR)/makefiles && $(MAKE) $(MAKE_ARGS) -f ide/CreateVSProject.gmk)
|
||||
|
||||
ALL_TARGETS += hotspot hotspot-ide-project
|
||||
|
||||
################################################################################
|
||||
# Build demos and samples targets
|
||||
@ -462,6 +469,8 @@ else
|
||||
|
||||
$(JAVA_TARGETS): interim-langtools
|
||||
|
||||
hotspot-ide-project: hotspot exploded-image
|
||||
|
||||
import-hotspot: hotspot
|
||||
|
||||
generate-exported-symbols: java.base-libs jdk.jdwp.agent-libs
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
#
|
||||
# Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
|
||||
# Copyright (c) 2011, 2016, 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
|
||||
@ -730,6 +730,16 @@ endif
|
||||
PathList = \
|
||||
"$(subst $(SPACE),$(PATH_SEP),$(strip $1))"
|
||||
|
||||
################################################################################
|
||||
# Check if a specified hotspot variant is being built, or at least one of a
|
||||
# list of variants. Will return 'true' or 'false'.
|
||||
# $1 - the variant to test for
|
||||
check-jvm-variant = \
|
||||
$(strip \
|
||||
$(if $(filter-out $(VALID_JVM_VARIANTS), $1), \
|
||||
$(error Internal error: Invalid variant tested: $1)) \
|
||||
$(if $(filter $1, $(JVM_VARIANTS)), true, false))
|
||||
|
||||
################################################################################
|
||||
|
||||
# Hook to include the corresponding custom file, if present.
|
||||
|
||||
@ -197,14 +197,51 @@ define add_native_source
|
||||
$1_$2_THIS_FILE = -DTHIS_FILE='"$$(<F)"'
|
||||
endif
|
||||
|
||||
ifeq ($$($1_$(notdir $2)_OPTIMIZATION), )
|
||||
$1_$(notdir $2)_OPT_CFLAGS := $$($1_OPT_CFLAGS)
|
||||
$1_$(notdir $2)_OPT_CXXFLAGS := $$($1_OPT_CXXFLAGS)
|
||||
else
|
||||
ifeq (NONE, $$($1_$(notdir $2)_OPTIMIZATION))
|
||||
$1_$(notdir $2)_OPT_CFLAGS := $(C_O_FLAG_NONE)
|
||||
$1_$(notdir $2)_OPT_CXXFLAGS := $(CXX_O_FLAG_NONE)
|
||||
else ifeq (LOW, $$($1_$(notdir $2)_OPTIMIZATION))
|
||||
$1_$(notdir $2)_OPT_CFLAGS := $(C_O_FLAG_NORM)
|
||||
$1_$(notdir $2)_OPT_CXXFLAGS := $(CXX_O_FLAG_NORM)
|
||||
else ifeq (HIGH, $$($1_$(notdir $2)_OPTIMIZATION))
|
||||
$1_$(notdir $2)_OPT_CFLAGS := $(C_O_FLAG_HI)
|
||||
$1_$(notdir $2)_OPT_CXXFLAGS := $(CXX_O_FLAG_HI)
|
||||
else ifeq (HIGHEST, $$($1_$(notdir $2)_OPTIMIZATION))
|
||||
$1_$(notdir $2)_OPT_CFLAGS := $(C_O_FLAG_HIGHEST)
|
||||
$1_$(notdir $2)_OPT_CXXFLAGS := $(CXX_O_FLAG_HIGHEST)
|
||||
else ifeq (HIGHEST_JVM, $$($1_$(notdir $2)_OPTIMIZATION))
|
||||
$1_$(notdir $2)_OPT_CFLAGS := $(C_O_FLAG_HIGHEST_JVM)
|
||||
$1_$(notdir $2)_OPT_CXXFLAGS := $(CXX_O_FLAG_HIGHEST_JVM)
|
||||
else ifeq (SIZE, $$($1_$(notdir $2)_OPTIMIZATION))
|
||||
$1_$(notdir $2)_OPT_CFLAGS := $(C_O_FLAG_SIZE)
|
||||
$1_$(notdir $2)_OPT_CXXFLAGS := $(CXX_O_FLAG_SIZE)
|
||||
else
|
||||
$$(error Unknown value for OPTIMIZATION: $$($1_$(notdir $2)_OPTIMIZATION))
|
||||
endif
|
||||
endif
|
||||
|
||||
ifneq ($$($1_PRECOMPILED_HEADER), )
|
||||
ifeq ($$(filter $$(notdir $2), $$($1_PRECOMPILED_HEADER_EXCLUDE)), )
|
||||
$1_$2_USE_PCH_FLAGS := $$($1_USE_PCH_FLAGS)
|
||||
endif
|
||||
endif
|
||||
|
||||
ifneq (,$$(filter %.c,$2))
|
||||
# Compile as a C file
|
||||
$1_$2_FLAGS=$(CFLAGS_CCACHE) $4 $$($1_$(notdir $2)_CFLAGS) $$($1_$2_THIS_FILE) -c
|
||||
$1_$2_FLAGS=$(CFLAGS_CCACHE) $$($1_$2_USE_PCH_FLAGS) $4 \
|
||||
$$($1_$(notdir $2)_OPT_CFLAGS) \
|
||||
$$($1_$(notdir $2)_CFLAGS) $$($1_$2_THIS_FILE) -c
|
||||
$1_$2_COMP=$5
|
||||
$1_$2_DEP_FLAG:=$(C_FLAG_DEPS)
|
||||
else ifneq (,$$(filter %.m,$2))
|
||||
# Compile as an Objective-C file
|
||||
$1_$2_FLAGS=-x objective-c $(CFLAGS_CCACHE) $4 $$($1_$(notdir $2)_CFLAGS) $$($1_$2_THIS_FILE) -c
|
||||
$1_$2_FLAGS=-x objective-c $(CFLAGS_CCACHE) $$($1_$2_USE_PCH_FLAGS) $4 \
|
||||
$$($1_$(notdir $2)_OPT_CFLAGS) \
|
||||
$$($1_$(notdir $2)_CFLAGS) $$($1_$2_THIS_FILE) -c
|
||||
$1_$2_COMP=$5
|
||||
$1_$2_DEP_FLAG:=$(C_FLAG_DEPS)
|
||||
else ifneq (,$$(filter %.s %.S,$2))
|
||||
@ -214,7 +251,9 @@ define add_native_source
|
||||
$1_$2_DEP_FLAG:=
|
||||
else ifneq (,$$(filter %.cpp,$2)$$(filter %.cc,$2)$$(filter %.mm,$2))
|
||||
# Compile as a C++ or Objective-C++ file
|
||||
$1_$2_FLAGS=$(CFLAGS_CCACHE) $6 $$($1_$(notdir $2)_CXXFLAGS) $$($1_$2_THIS_FILE) -c
|
||||
$1_$2_FLAGS=$(CFLAGS_CCACHE) $$($1_$2_USE_PCH_FLAGS) $6 \
|
||||
$$($1_$(notdir $2)_OPT_CXXFLAGS) \
|
||||
$$($1_$(notdir $2)_CXXFLAGS) $$($1_$2_THIS_FILE) -c
|
||||
$1_$2_COMP=$7
|
||||
$1_$2_DEP_FLAG:=$(CXX_FLAG_DEPS)
|
||||
else
|
||||
@ -245,8 +284,10 @@ define add_native_source
|
||||
endif
|
||||
endif
|
||||
|
||||
ifneq ($$($1_$(notdir $2)_CFLAGS)$$($1_$(notdir $2)_CXXFLAGS), )
|
||||
$1_$2_VARDEPS := $$($1_$(notdir $2)_CFLAGS) $$($1_$(notdir $2)_CXXFLAGS)
|
||||
ifneq ($$(strip $$($1_$(notdir $2)_CFLAGS) $$($1_$(notdir $2)_CXXFLAGS) \
|
||||
$$($1_$(notdir $2)_OPTIMIZATION)), )
|
||||
$1_$2_VARDEPS := $$($1_$(notdir $2)_CFLAGS) $$($1_$(notdir $2)_CXXFLAGS) \
|
||||
$$($1_$(notdir $2)_OPT_CFLAGS) $$($1_$(notdir $2)_OPT_CXXFLAGS)
|
||||
$1_$2_VARDEPS_FILE := $$(call DependOnVariable, $1_$2_VARDEPS, \
|
||||
$$(patsubst %$(OBJ_SUFFIX),%.vardeps,$$($1_$2_OBJ)))
|
||||
endif
|
||||
@ -323,7 +364,7 @@ endef
|
||||
# mapfile for the output symbols file
|
||||
# CC the compiler to use, default is $(CC)
|
||||
# LD the linker to use, default is $(LD)
|
||||
# OPTIMIZATION sets optimization level to NONE, LOW, HIGH, HIGHEST
|
||||
# OPTIMIZATION sets optimization level to NONE, LOW, HIGH, HIGHEST, HIGHEST_JVM, SIZE
|
||||
# DISABLED_WARNINGS_<toolchain> Disable the given warnings for the specified toolchain
|
||||
# DISABLED_WARNINGS_C_<toolchain> Disable the given warnings for the specified toolchain
|
||||
# when compiling C code
|
||||
@ -331,7 +372,11 @@ endef
|
||||
# toolchain when compiling C++ code
|
||||
# STRIP_SYMBOLS Set to true to strip the final binary if the toolchain allows for it
|
||||
# DEBUG_SYMBOLS Set to false to disable generation of debug symbols
|
||||
# CFLAGS_DEBUG_SYMBOLS Overrides the default cflags for enabling debug symbols
|
||||
# CXXFLAGS_DEBUG_SYMBOLS Overrides the default cxxflags for enabling debug symbols
|
||||
# STRIPFLAGS Optionally change the flags given to the strip command
|
||||
# PRECOMPILED_HEADER Header file to use as precompiled header
|
||||
# PRECOMPILED_HEADER_EXCLUDE List of source files that should not use PCH
|
||||
SetupNativeCompilation = $(NamedParamsMacroTemplate)
|
||||
define SetupNativeCompilationBody
|
||||
|
||||
@ -556,8 +601,10 @@ define SetupNativeCompilationBody
|
||||
endif
|
||||
|
||||
ifeq ($(COMPILE_WITH_DEBUG_SYMBOLS), true)
|
||||
$1_EXTRA_CFLAGS += $(CFLAGS_DEBUG_SYMBOLS)
|
||||
$1_EXTRA_CXXFLAGS += $(CXXFLAGS_DEBUG_SYMBOLS)
|
||||
$$(call SetIfEmpty, $1_CFLAGS_DEBUG_SYMBOLS, $(CFLAGS_DEBUG_SYMBOLS))
|
||||
$$(call SetIfEmpty, $1_CXXFLAGS_DEBUG_SYMBOLS, $(CXXFLAGS_DEBUG_SYMBOLS))
|
||||
$1_EXTRA_CFLAGS += $$($1_CFLAGS_DEBUG_SYMBOLS)
|
||||
$1_EXTRA_CXXFLAGS += $$($1_CXXFLAGS_DEBUG_SYMBOLS)
|
||||
endif
|
||||
|
||||
ifneq (,$$($1_REORDER))
|
||||
@ -597,17 +644,23 @@ define SetupNativeCompilationBody
|
||||
endif
|
||||
|
||||
ifeq (NONE, $$($1_OPTIMIZATION))
|
||||
$1_EXTRA_CFLAGS += $(C_O_FLAG_NONE)
|
||||
$1_EXTRA_CXXFLAGS += $(CXX_O_FLAG_NONE)
|
||||
$1_OPT_CFLAGS := $(C_O_FLAG_NONE)
|
||||
$1_OPT_CXXFLAGS := $(CXX_O_FLAG_NONE)
|
||||
else ifeq (LOW, $$($1_OPTIMIZATION))
|
||||
$1_EXTRA_CFLAGS += $(C_O_FLAG_NORM)
|
||||
$1_EXTRA_CXXFLAGS += $(CXX_O_FLAG_NORM)
|
||||
$1_OPT_CFLAGS := $(C_O_FLAG_NORM)
|
||||
$1_OPT_CXXFLAGS := $(CXX_O_FLAG_NORM)
|
||||
else ifeq (HIGH, $$($1_OPTIMIZATION))
|
||||
$1_EXTRA_CFLAGS += $(C_O_FLAG_HI)
|
||||
$1_EXTRA_CXXFLAGS += $(CXX_O_FLAG_HI)
|
||||
$1_OPT_CFLAGS := $(C_O_FLAG_HI)
|
||||
$1_OPT_CXXFLAGS := $(CXX_O_FLAG_HI)
|
||||
else ifeq (HIGHEST, $$($1_OPTIMIZATION))
|
||||
$1_EXTRA_CFLAGS += $(C_O_FLAG_HIGHEST)
|
||||
$1_EXTRA_CXXFLAGS += $(CXX_O_FLAG_HIGHEST)
|
||||
$1_OPT_CFLAGS := $(C_O_FLAG_HIGHEST)
|
||||
$1_OPT_CXXFLAGS := $(CXX_O_FLAG_HIGHEST)
|
||||
else ifeq (HIGHEST_JVM, $$($1_OPTIMIZATION))
|
||||
$1_OPT_CFLAGS := $(C_O_FLAG_HIGHEST_JVM)
|
||||
$1_OPT_CXXFLAGS := $(CXX_O_FLAG_HIGHEST_JVM)
|
||||
else ifeq (SIZE, $$($1_OPTIMIZATION))
|
||||
$1_OPT_CFLAGS := $(C_O_FLAG_SIZE)
|
||||
$1_OPT_CXXFLAGS := $(CXX_O_FLAG_SIZE)
|
||||
else ifneq (, $$($1_OPTIMIZATION))
|
||||
$$(error Unknown value for OPTIMIZATION: $$($1_OPTIMIZATION))
|
||||
endif
|
||||
@ -618,11 +671,65 @@ define SetupNativeCompilationBody
|
||||
# lines for all object files in this setup. This includes at least all the
|
||||
# variables used in the call to add_native_source below.
|
||||
$1_COMPILE_VARDEPS := $$($1_CFLAGS) $$($1_EXTRA_CFLAGS) $$($1_SYSROOT_CFLAGS) \
|
||||
$$($1_CXXFLAGS) $$($1_EXTRA_CXXFLAGS) \
|
||||
$$($1_CXXFLAGS) $$($1_EXTRA_CXXFLAGS) $$($1_OPT_CFLAGS) $$($1_OPT_CXXFLAGS) \
|
||||
$$($1_CC) $$($1_CXX) $$($1_AS) $$($1_ASFLAGS)
|
||||
$1_COMPILE_VARDEPS_FILE := $$(call DependOnVariable, $1_COMPILE_VARDEPS, \
|
||||
$$($1_OBJECT_DIR)/$$($1_NOSUFFIX).comp.vardeps)
|
||||
|
||||
ifneq ($$($1_PRECOMPILED_HEADER), )
|
||||
ifeq ($(USE_PRECOMPILED_HEADER), 1)
|
||||
ifeq ($(TOOLCHAIN_TYPE), microsoft)
|
||||
$1_PCH_FILE := $$($1_OBJECT_DIR)/$1.pch
|
||||
$1_GENERATED_PCH_SRC := $$($1_OBJECT_DIR)/$1_pch.cpp
|
||||
$1_GENERATED_PCH_OBJ := $$($1_OBJECT_DIR)/$1_pch.obj
|
||||
|
||||
$$(eval $$(call add_native_source,$1,$$($1_GENERATED_PCH_SRC), \
|
||||
$$($1_OBJECT_DIR),,, \
|
||||
$$($1_CXXFLAGS) $$($1_EXTRA_CXXFLAGS) $$($1_SYSROOT_CFLAGS) \
|
||||
-Fp$$($1_PCH_FILE) -Yc$$(notdir $$($1_PRECOMPILED_HEADER)), \
|
||||
$$($1_CXX),,no_this_file))
|
||||
|
||||
$1_USE_PCH_FLAGS := \
|
||||
-Fp$$($1_PCH_FILE) -Yu$$(notdir $$($1_PRECOMPILED_HEADER))
|
||||
|
||||
$$($1_ALL_OBJS): $$($1_GENERATED_PCH_OBJ)
|
||||
|
||||
# Explicitly add the pch obj file first to ease comparing to old
|
||||
# hotspot build.
|
||||
$1_ALL_OBJS := $$($1_GENERATED_PCH_OBJ) $$($1_ALL_OBJS)
|
||||
|
||||
$$($1_GENERATED_PCH_SRC):
|
||||
$(ECHO) "#include \"$$(notdir $$($1_PRECOMPILED_HEADER))\"" > $$@
|
||||
|
||||
else ifneq ($(findstring $(TOOLCHAIN_TYPE), gcc clang), )
|
||||
ifeq ($(TOOLCHAIN_TYPE), gcc)
|
||||
$1_PCH_FILE := $$($1_OBJECT_DIR)/precompiled/$$(notdir $$($1_PRECOMPILED_HEADER)).gch
|
||||
$1_USE_PCH_FLAGS := -I$$($1_OBJECT_DIR)/precompiled
|
||||
else ifeq ($(TOOLCHAIN_TYPE), clang)
|
||||
$1_PCH_FILE := $$($1_OBJECT_DIR)/precompiled/$$(notdir $$($1_PRECOMPILED_HEADER)).pch
|
||||
$1_USE_PCH_FLAGS := -include-pch $$($1_PCH_FILE)
|
||||
endif
|
||||
$1_PCH_DEP := $$($1_PCH_FILE).d
|
||||
$1_PCH_DEP_TARGETS := $$($1_PCH_FILE).d.targets
|
||||
|
||||
-include $$($1_PCH_DEP)
|
||||
-include $$($1_PCH_DEP_TARGETS)
|
||||
|
||||
$$($1_PCH_FILE): $$($1_PRECOMPILED_HEADER) $$($1_COMPILE_VARDEPS_FILE)
|
||||
$$(call LogInfo, Generating precompiled header)
|
||||
$$(call MakeDir, $$(@D))
|
||||
$$(call ExecuteWithLog, $$@, \
|
||||
$$($1_CC) $$($1_CFLAGS) $$($1_EXTRA_CFLAGS) $$($1_SYSROOT_CFLAGS) \
|
||||
$$($1_OPT_CFLAGS) \
|
||||
-x c++-header -c $(C_FLAG_DEPS) $$($1_PCH_DEP) $$< -o $$@)
|
||||
$(SED) $(DEPENDENCY_TARGET_SED_PATTERN) $$($1_PCH_DEP) > $$($1_PCH_DEP_TARGETS)
|
||||
|
||||
$$($1_ALL_OBJS): $$($1_PCH_FILE)
|
||||
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
|
||||
# Now call add_native_source for each source file we are going to compile.
|
||||
$$(foreach p,$$($1_SRCS), \
|
||||
$$(eval $$(call add_native_source,$1,$$p,$$($1_OBJECT_DIR), \
|
||||
|
||||
@ -129,9 +129,15 @@ jprt.build.flavor.optimized.target=jprt_bundle
|
||||
jprt.build.flavor.optimizedOpen.target=jprt_bundle
|
||||
jprt.build.flavor.slowdebug.target=jprt_bundle
|
||||
|
||||
# Use these configure args to define debug level
|
||||
# Use these configure args to define debug level or provide specific
|
||||
# configuration details not covered by Jib profiles.
|
||||
jprt.slowdebug.build.configure.args=
|
||||
jprt.fastdebug.build.configure.args=--disable-precompiled-headers
|
||||
# Don't disable precompiled headers on windows. It's simply too slow.
|
||||
jprt.windows_i586.fastdebug.build.configure.args=
|
||||
jprt.windows_x64.fastdebug.build.configure.args=
|
||||
jprt.windows_i586.fastdebugOpen.build.configure.args=
|
||||
jprt.windows_x64.fastdebugOpen.build.configure.args=
|
||||
jprt.product.build.configure.args=
|
||||
jprt.optimized.build.configure.args=--with-debug-level=optimized
|
||||
jprt.slowdebugOpen.build.configure.args=${jprt.slowdebug.build.configure.args}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user