| # | |
| # Copyright (c) 2011, 2025, Oracle and/or its affiliates. All rights reserved. | |
| # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
| # | |
| # This code is free software; you can redistribute it and/or modify it | |
| # under the terms of the GNU General Public License version 2 only, as | |
| # published by the Free Software Foundation. Oracle designates this | |
| # particular file as subject to the "Classpath" exception as provided | |
| # by Oracle in the LICENSE file that accompanied this code. | |
| # | |
| # This code is distributed in the hope that it will be useful, but WITHOUT | |
| # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| # version 2 for more details (a copy is included in the LICENSE file that | |
| # accompanied this code). | |
| # | |
| # You should have received a copy of the GNU General Public License version | |
| # 2 along with this work; if not, write to the Free Software Foundation, | |
| # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| # | |
| # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
| # or visit www.oracle.com if you need additional information or have any | |
| # questions. | |
| # | |
| ################################################################################ | |
| # Set the debug level | |
| # 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([JDKOPT_SETUP_DEBUG_LEVEL], | |
| [ | |
| DEBUG_LEVEL="release" | |
| UTIL_ARG_ENABLE(NAME: debug, DEFAULT: false, RESULT: ENABLE_DEBUG, | |
| DESC: [enable debugging (shorthand for --with-debug-level=fastdebug)], | |
| IF_ENABLED: [ DEBUG_LEVEL="fastdebug" ]) | |
| AC_MSG_CHECKING([which debug level to use]) | |
| AC_ARG_WITH([debug-level], [AS_HELP_STRING([--with-debug-level], | |
| [set the debug level (release, fastdebug, slowdebug, optimized) @<:@release@:>@])], | |
| [ | |
| DEBUG_LEVEL="${withval}" | |
| if test "x$ENABLE_DEBUG" = xtrue; then | |
| AC_MSG_ERROR([You cannot use both --enable-debug and --with-debug-level at the same time.]) | |
| fi | |
| ]) | |
| AC_MSG_RESULT([$DEBUG_LEVEL]) | |
| if test "x$DEBUG_LEVEL" != xrelease && \ | |
| test "x$DEBUG_LEVEL" != xoptimized && \ | |
| test "x$DEBUG_LEVEL" != xfastdebug && \ | |
| 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) | |
| ]) | |
| ################################################################################ | |
| # | |
| # Should we build only OpenJDK even if closed sources are present? | |
| # | |
| AC_DEFUN_ONCE([JDKOPT_SETUP_OPEN_OR_CUSTOM], | |
| [ | |
| UTIL_ARG_ENABLE(NAME: openjdk-only, DEFAULT: false, | |
| RESULT: SUPPRESS_CUSTOM_EXTENSIONS, | |
| DESC: [suppress building custom source even if present], | |
| CHECKING_MSG: [if custom source is suppressed (openjdk-only)]) | |
| ]) | |
| AC_DEFUN_ONCE([JDKOPT_SETUP_JDK_OPTIONS], | |
| [ | |
| # Should we build a JDK without a graphical UI? | |
| UTIL_ARG_ENABLE(NAME: headless-only, DEFAULT: false, | |
| RESULT: ENABLE_HEADLESS_ONLY, | |
| DESC: [only build headless (no GUI) support], | |
| CHECKING_MSG: [if we should build headless-only (no GUI)]) | |
| AC_SUBST(ENABLE_HEADLESS_ONLY) | |
| # should we linktime gc unused code sections in the JDK build ? | |
| if test "x$OPENJDK_TARGET_OS" = "xlinux" && test "x$OPENJDK_TARGET_CPU" = xs390x; then | |
| LINKTIME_GC_DEFAULT=true | |
| else | |
| LINKTIME_GC_DEFAULT=false | |
| fi | |
| UTIL_ARG_ENABLE(NAME: linktime-gc, DEFAULT: $LINKTIME_GC_DEFAULT, | |
| DEFAULT_DESC: [auto], RESULT: ENABLE_LINKTIME_GC, | |
| DESC: [use link time gc on unused code sections in the JDK build], | |
| CHECKING_MSG: [if linker should clean out unused code (linktime-gc)]) | |
| AC_SUBST(ENABLE_LINKTIME_GC) | |
| # Check for full doc dependencies | |
| FULL_DOCS_AVAILABLE=true | |
| AC_MSG_CHECKING([for graphviz dot]) | |
| if test "x$DOT" != "x"; then | |
| AC_MSG_RESULT([yes]) | |
| else | |
| AC_MSG_RESULT([no, cannot generate full docs or man pages]) | |
| FULL_DOCS_AVAILABLE=false | |
| fi | |
| AC_MSG_CHECKING([for pandoc]) | |
| if test "x$ENABLE_PANDOC" = "xtrue"; then | |
| AC_MSG_RESULT([yes]) | |
| else | |
| AC_MSG_RESULT([no, cannot generate full docs or man pages]) | |
| FULL_DOCS_AVAILABLE=false | |
| fi | |
| # Should we build the complete docs, or just a lightweight version? | |
| UTIL_ARG_ENABLE(NAME: full-docs, DEFAULT: auto, RESULT: ENABLE_FULL_DOCS, | |
| AVAILABLE: $FULL_DOCS_AVAILABLE, DESC: [build complete documentation], | |
| DEFAULT_DESC: [enabled if all tools found]) | |
| AC_SUBST(ENABLE_FULL_DOCS) | |
| # Choose cacerts source file | |
| AC_ARG_WITH(cacerts-file, [AS_HELP_STRING([--with-cacerts-file], | |
| [specify alternative cacerts file])]) | |
| AC_MSG_CHECKING([for cacerts file]) | |
| if test "x$with_cacerts_file" == x; then | |
| AC_MSG_RESULT([default]) | |
| else | |
| CACERTS_FILE=$with_cacerts_file | |
| if test ! -f "$CACERTS_FILE"; then | |
| AC_MSG_RESULT([fail]) | |
| AC_MSG_ERROR([Specified cacerts file "$CACERTS_FILE" does not exist]) | |
| fi | |
| AC_MSG_RESULT([$CACERTS_FILE]) | |
| fi | |
| AC_SUBST(CACERTS_FILE) | |
| # Choose cacerts source folder for user provided PEM files | |
| AC_ARG_WITH(cacerts-src, [AS_HELP_STRING([--with-cacerts-src], | |
| [specify alternative cacerts source folder containing certificates])]) | |
| CACERTS_SRC="" | |
| AC_MSG_CHECKING([for cacerts source]) | |
| if test "x$with_cacerts_src" == x; then | |
| AC_MSG_RESULT([default]) | |
| else | |
| CACERTS_SRC=$with_cacerts_src | |
| if test ! -d "$CACERTS_SRC"; then | |
| AC_MSG_RESULT([fail]) | |
| AC_MSG_ERROR([Specified cacerts source folder "$CACERTS_SRC" does not exist]) | |
| fi | |
| AC_MSG_RESULT([$CACERTS_SRC]) | |
| fi | |
| AC_SUBST(CACERTS_SRC) | |
| # Enable or disable unlimited crypto | |
| UTIL_ARG_ENABLE(NAME: unlimited-crypto, DEFAULT: true, RESULT: UNLIMITED_CRYPTO, | |
| DESC: [enable unlimited crypto policy]) | |
| AC_SUBST(UNLIMITED_CRYPTO) | |
| # Should we build the serviceability agent (SA)? | |
| INCLUDE_SA=true | |
| if HOTSPOT_CHECK_JVM_VARIANT(zero); then | |
| INCLUDE_SA=false | |
| fi | |
| if test "x$OPENJDK_TARGET_OS" = xaix ; then | |
| INCLUDE_SA=false | |
| fi | |
| if test "x$OPENJDK_TARGET_CPU" = xs390x ; then | |
| INCLUDE_SA=false | |
| fi | |
| AC_SUBST(INCLUDE_SA) | |
| # Setup default CDS alignment. On platforms where one build may run on machines with different | |
| # page sizes, the JVM choses a compatible alignment to fit all possible page sizes. This slightly | |
| # increases archive size. | |
| # The only platform having this problem at the moment is Linux on aarch64, which may encounter | |
| # three different page sizes: 4K, 64K, and if run on Mac m1 hardware, 16K. | |
| COMPATIBLE_CDS_ALIGNMENT_DEFAULT=false | |
| if test "x$OPENJDK_TARGET_OS" = "xlinux" && test "x$OPENJDK_TARGET_CPU" = "xaarch64"; then | |
| COMPATIBLE_CDS_ALIGNMENT_DEFAULT=auto | |
| fi | |
| # Compress jars | |
| COMPRESS_JARS=false | |
| AC_SUBST(COMPRESS_JARS) | |
| # Setup default copyright year. Mostly overridden when building close to a new year. | |
| AC_ARG_WITH(copyright-year, [AS_HELP_STRING([--with-copyright-year], | |
| [Set copyright year value for build @<:@current year/source-date@:>@])]) | |
| if test "x$with_copyright_year" = xyes; then | |
| AC_MSG_ERROR([Copyright year must have a value]) | |
| elif test "x$with_copyright_year" != x; then | |
| COPYRIGHT_YEAR="$with_copyright_year" | |
| elif test "x$SOURCE_DATE" != xupdated; then | |
| if test "x$IS_GNU_DATE" = xyes; then | |
| COPYRIGHT_YEAR=`$DATE --date=@$SOURCE_DATE +%Y` | |
| else | |
| COPYRIGHT_YEAR=`$DATE -j -f %s $SOURCE_DATE +%Y` | |
| fi | |
| else | |
| COPYRIGHT_YEAR=`$DATE +'%Y'` | |
| fi | |
| AC_SUBST(COPYRIGHT_YEAR) | |
| # Override default library path | |
| AC_ARG_WITH([jni-libpath], [AS_HELP_STRING([--with-jni-libpath], | |
| [override default JNI library search path])]) | |
| AC_MSG_CHECKING([for jni library path]) | |
| if test "x${with_jni_libpath}" = "x" || test "x${with_jni_libpath}" = "xno"; then | |
| AC_MSG_RESULT([default]) | |
| elif test "x${with_jni_libpath}" = "xyes"; then | |
| AC_MSG_RESULT([invalid]) | |
| AC_MSG_ERROR([The --with-jni-libpath option requires an argument.]) | |
| else | |
| HOTSPOT_OVERRIDE_LIBPATH=${with_jni_libpath} | |
| if test "x$OPENJDK_TARGET_OS" != "xlinux" && | |
| test "x$OPENJDK_TARGET_OS" != "xbsd" && | |
| test "x$OPENJDK_TARGET_OS" != "xaix"; then | |
| AC_MSG_RESULT([fail]) | |
| AC_MSG_ERROR([Overriding JNI library path is supported only on Linux, BSD and AIX.]) | |
| fi | |
| AC_MSG_RESULT(${HOTSPOT_OVERRIDE_LIBPATH}) | |
| fi | |
| AC_SUBST(HOTSPOT_OVERRIDE_LIBPATH) | |
| ]) | |
| ################################################################################ | |
| AC_DEFUN_ONCE([JDKOPT_SETUP_DEBUG_SYMBOLS], | |
| [ | |
| # | |
| # Native debug symbols. | |
| # This must be done after the toolchain is setup, since we're looking at objcopy. | |
| # | |
| AC_MSG_CHECKING([what type of native debug symbols to use]) | |
| AC_ARG_WITH([native-debug-symbols], | |
| [AS_HELP_STRING([--with-native-debug-symbols], | |
| [set the native debug symbol configuration (none, internal, external, zipped) @<:@varying@:>@])], | |
| [ | |
| if test "x$OPENJDK_TARGET_OS" = xwindows; then | |
| if test "x$withval" = xinternal; then | |
| AC_MSG_ERROR([Windows does not support the parameter 'internal' for --with-native-debug-symbols]) | |
| fi | |
| fi | |
| ], | |
| [ | |
| with_native_debug_symbols="external" | |
| ]) | |
| AC_MSG_RESULT([$with_native_debug_symbols]) | |
| if test "x$with_native_debug_symbols" = xnone; then | |
| COMPILE_WITH_DEBUG_SYMBOLS=false | |
| COPY_DEBUG_SYMBOLS=false | |
| ZIP_EXTERNAL_DEBUG_SYMBOLS=false | |
| elif test "x$with_native_debug_symbols" = xinternal; then | |
| COMPILE_WITH_DEBUG_SYMBOLS=true | |
| COPY_DEBUG_SYMBOLS=false | |
| ZIP_EXTERNAL_DEBUG_SYMBOLS=false | |
| elif test "x$with_native_debug_symbols" = xexternal; then | |
| if test "x$OPENJDK_TARGET_OS" = xlinux; then | |
| if test "x$OBJCOPY" = x; then | |
| # enabling of enable-debug-symbols and can't find objcopy | |
| # this is an error | |
| AC_MSG_ERROR([Unable to find objcopy, cannot enable native debug symbols]) | |
| fi | |
| fi | |
| COMPILE_WITH_DEBUG_SYMBOLS=true | |
| COPY_DEBUG_SYMBOLS=true | |
| ZIP_EXTERNAL_DEBUG_SYMBOLS=false | |
| elif test "x$with_native_debug_symbols" = xzipped; then | |
| if test "x$OPENJDK_TARGET_OS" = xlinux; then | |
| if test "x$OBJCOPY" = x; then | |
| # enabling of enable-debug-symbols and can't find objcopy | |
| # this is an error | |
| AC_MSG_ERROR([Unable to find objcopy, cannot enable native debug symbols]) | |
| fi | |
| fi | |
| COMPILE_WITH_DEBUG_SYMBOLS=true | |
| COPY_DEBUG_SYMBOLS=true | |
| ZIP_EXTERNAL_DEBUG_SYMBOLS=true | |
| else | |
| AC_MSG_ERROR([Allowed native debug symbols are: none, internal, external, zipped]) | |
| fi | |
| AC_SUBST(COMPILE_WITH_DEBUG_SYMBOLS) | |
| AC_SUBST(COPY_DEBUG_SYMBOLS) | |
| AC_SUBST(ZIP_EXTERNAL_DEBUG_SYMBOLS) | |
| # Should we add external native debug symbols to the shipped bundles? | |
| AC_MSG_CHECKING([if we should add external native debug symbols to the shipped bundles]) | |
| AC_ARG_WITH([external-symbols-in-bundles], | |
| [AS_HELP_STRING([--with-external-symbols-in-bundles], | |
| [which type of external native debug symbol information shall be shipped in product bundles (none, public, full) | |
| (e.g. ship full/stripped pdbs on Windows) @<:@none@:>@])]) | |
| if test "x$with_external_symbols_in_bundles" = x || test "x$with_external_symbols_in_bundles" = xnone ; then | |
| AC_MSG_RESULT([no]) | |
| elif test "x$with_external_symbols_in_bundles" = xfull || test "x$with_external_symbols_in_bundles" = xpublic ; then | |
| if test "x$OPENJDK_TARGET_OS" != xwindows ; then | |
| AC_MSG_ERROR([--with-external-symbols-in-bundles currently only works on windows!]) | |
| elif test "x$COPY_DEBUG_SYMBOLS" != xtrue ; then | |
| AC_MSG_ERROR([--with-external-symbols-in-bundles only works when --with-native-debug-symbols=external is used!]) | |
| elif test "x$with_external_symbols_in_bundles" = xfull ; then | |
| AC_MSG_RESULT([full]) | |
| SHIP_DEBUG_SYMBOLS=full | |
| else | |
| AC_MSG_RESULT([public]) | |
| SHIP_DEBUG_SYMBOLS=public | |
| fi | |
| else | |
| AC_MSG_ERROR([$with_external_symbols_in_bundles is an unknown value for --with-external-symbols-in-bundles]) | |
| fi | |
| AC_SUBST(SHIP_DEBUG_SYMBOLS) | |
| ]) | |
| ################################################################################ | |
| # | |
| # Native and Java code coverage | |
| # | |
| AC_DEFUN_ONCE([JDKOPT_SETUP_CODE_COVERAGE], | |
| [ | |
| UTIL_ARG_ENABLE(NAME: native-coverage, DEFAULT: false, RESULT: GCOV_ENABLED, | |
| DESC: [enable native compilation with code coverage data], | |
| CHECK_AVAILABLE: [ | |
| AC_MSG_CHECKING([if native coverage is available]) | |
| if test "x$TOOLCHAIN_TYPE" = "xgcc" || | |
| test "x$TOOLCHAIN_TYPE" = "xclang"; then | |
| AC_MSG_RESULT([yes]) | |
| else | |
| AC_MSG_RESULT([no]) | |
| AVAILABLE=false | |
| fi | |
| ], | |
| IF_ENABLED: [ | |
| GCOV_CFLAGS="-fprofile-arcs -ftest-coverage -fno-inline" | |
| GCOV_LDFLAGS="-fprofile-arcs" | |
| JVM_CFLAGS="$JVM_CFLAGS $GCOV_CFLAGS" | |
| JVM_LDFLAGS="$JVM_LDFLAGS $GCOV_LDFLAGS" | |
| CFLAGS_JDKLIB="$CFLAGS_JDKLIB $GCOV_CFLAGS" | |
| CFLAGS_JDKEXE="$CFLAGS_JDKEXE $GCOV_CFLAGS" | |
| CXXFLAGS_JDKLIB="$CXXFLAGS_JDKLIB $GCOV_CFLAGS" | |
| CXXFLAGS_JDKEXE="$CXXFLAGS_JDKEXE $GCOV_CFLAGS" | |
| LDFLAGS_JDKLIB="$LDFLAGS_JDKLIB $GCOV_LDFLAGS" | |
| LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE $GCOV_LDFLAGS" | |
| LDFLAGS_STATIC_JDK="$LDFLAGS_STATIC_JDK $GCOV_LDFLAGS" | |
| ]) | |
| AC_SUBST(GCOV_ENABLED) | |
| AC_ARG_WITH(jcov, [AS_HELP_STRING([--with-jcov], | |
| [jcov library location])]) | |
| AC_ARG_WITH(jcov-input-jdk, [AS_HELP_STRING([--with-jcov-input-jdk], | |
| [jdk image to instrument])]) | |
| AC_ARG_WITH(jcov-filters, [AS_HELP_STRING([--with-jcov-filters], | |
| [filters to limit code for jcov instrumentation and report generation])]) | |
| JCOV_HOME= | |
| JCOV_INPUT_JDK= | |
| JCOV_ENABLED= | |
| JCOV_FILTERS= | |
| if test "x$with_jcov" = "x" ; then | |
| JCOV_ENABLED="false" | |
| else | |
| JCOV_HOME="$with_jcov" | |
| if test ! -f "$JCOV_HOME/lib/jcov.jar"; then | |
| AC_MSG_RESULT([fail]) | |
| AC_MSG_ERROR([Invalid JCov bundle: "$JCOV_HOME/lib/jcov.jar" does not exist]) | |
| fi | |
| JCOV_ENABLED="true" | |
| UTIL_FIXUP_PATH(JCOV_HOME) | |
| if test "x$with_jcov_input_jdk" != "x" ; then | |
| JCOV_INPUT_JDK="$with_jcov_input_jdk" | |
| if test ! -f "$JCOV_INPUT_JDK/bin/java" && test ! -f "$JCOV_INPUT_JDK/bin/java.exe"; then | |
| AC_MSG_RESULT([fail]) | |
| AC_MSG_ERROR([Invalid JDK bundle: "$JCOV_INPUT_JDK/bin/java" does not exist]) | |
| fi | |
| UTIL_FIXUP_PATH(JCOV_INPUT_JDK) | |
| fi | |
| if test "x$with_jcov_filters" != "x" ; then | |
| JCOV_FILTERS="$with_jcov_filters" | |
| fi | |
| fi | |
| UTIL_ARG_WITH(NAME: jcov-modules, TYPE: string, | |
| DEFAULT: [], RESULT: JCOV_MODULES_COMMMA_SEPARATED, | |
| DESC: [which modules to include in jcov (comma-separated)], | |
| OPTIONAL: true) | |
| # Replace "," with " ". | |
| JCOV_MODULES=${JCOV_MODULES_COMMMA_SEPARATED//,/ } | |
| AC_SUBST(JCOV_ENABLED) | |
| AC_SUBST(JCOV_HOME) | |
| AC_SUBST(JCOV_INPUT_JDK) | |
| AC_SUBST(JCOV_FILTERS) | |
| AC_SUBST(JCOV_MODULES) | |
| ]) | |
| ################################################################################ | |
| # | |
| # AddressSanitizer | |
| # | |
| AC_DEFUN_ONCE([JDKOPT_SETUP_ADDRESS_SANITIZER], | |
| [ | |
| UTIL_ARG_ENABLE(NAME: asan, DEFAULT: false, RESULT: ASAN_ENABLED, | |
| DESC: [enable AddressSanitizer], | |
| CHECK_AVAILABLE: [ | |
| AC_MSG_CHECKING([if AddressSanitizer (asan) is available]) | |
| if test "x$TOOLCHAIN_TYPE" = "xgcc" || | |
| test "x$TOOLCHAIN_TYPE" = "xclang" || | |
| test "x$TOOLCHAIN_TYPE" = "xmicrosoft"; then | |
| AC_MSG_RESULT([yes]) | |
| else | |
| AC_MSG_RESULT([no]) | |
| AVAILABLE=false | |
| fi | |
| ], | |
| IF_ENABLED: [ | |
| if test "x$TOOLCHAIN_TYPE" = "xgcc" || | |
| test "x$TOOLCHAIN_TYPE" = "xclang"; then | |
| # ASan is simply incompatible with gcc -Wstringop-truncation. See | |
| # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85650 | |
| # It's harmless to be suppressed in clang as well. | |
| ASAN_CFLAGS="-fsanitize=address -Wno-stringop-truncation -fno-omit-frame-pointer -fno-common -DADDRESS_SANITIZER" | |
| ASAN_LDFLAGS="-fsanitize=address" | |
| # detect_stack_use_after_return causes ASAN to offload stack-local | |
| # variables to c-heap and therefore breaks assumptions in hotspot | |
| # that rely on data (e.g. Marks) living in thread stacks. | |
| if test "x$TOOLCHAIN_TYPE" = "xgcc"; then | |
| ASAN_CFLAGS="$ASAN_CFLAGS --param asan-use-after-return=0" | |
| fi | |
| if test "x$TOOLCHAIN_TYPE" = "xclang"; then | |
| ASAN_CFLAGS="$ASAN_CFLAGS -fsanitize-address-use-after-return=never" | |
| ASAN_LDFLAGS="$ASAN_LDFLAGS -shared-libasan" | |
| fi | |
| elif test "x$TOOLCHAIN_TYPE" = "xmicrosoft"; then | |
| # -Oy- is equivalent to -fno-omit-frame-pointer in GCC/Clang. | |
| ASAN_CFLAGS="-fsanitize=address -Oy- -DADDRESS_SANITIZER" | |
| # MSVC produces a warning if you pass -fsanitize=address to the linker. It also complains | |
| $ if -DEBUG is not passed to the linker when building with ASan. | |
| ASAN_LDFLAGS="-debug" | |
| # -fsanitize-address-use-after-return is off by default in MS Visual Studio 22 (19.37.32824). | |
| # cl : Command line warning D9002 : ignoring unknown option '-fno-sanitize-address-use-after-return' | |
| fi | |
| JVM_CFLAGS="$JVM_CFLAGS $ASAN_CFLAGS" | |
| JVM_LDFLAGS="$JVM_LDFLAGS $ASAN_LDFLAGS" | |
| CFLAGS_JDKLIB="$CFLAGS_JDKLIB $ASAN_CFLAGS" | |
| CFLAGS_JDKEXE="$CFLAGS_JDKEXE $ASAN_CFLAGS" | |
| CXXFLAGS_JDKLIB="$CXXFLAGS_JDKLIB $ASAN_CFLAGS" | |
| CXXFLAGS_JDKEXE="$CXXFLAGS_JDKEXE $ASAN_CFLAGS" | |
| LDFLAGS_JDKLIB="$LDFLAGS_JDKLIB $ASAN_LDFLAGS" | |
| LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE $ASAN_LDFLAGS" | |
| LDFLAGS_STATIC_JDK="$LDFLAGS_STATIC_JDK $ASAN_LDFLAGS" | |
| ]) | |
| AC_SUBST(ASAN_ENABLED) | |
| ]) | |
| ################################################################################ | |
| # | |
| # Static analyzer | |
| # | |
| AC_DEFUN_ONCE([JDKOPT_SETUP_STATIC_ANALYZER], | |
| [ | |
| UTIL_ARG_ENABLE(NAME: static-analyzer, DEFAULT: false, RESULT: STATIC_ANALYZER_ENABLED, | |
| DESC: [enable the GCC static analyzer], | |
| CHECK_AVAILABLE: [ | |
| AC_MSG_CHECKING([if static analyzer is available]) | |
| if test "x$TOOLCHAIN_TYPE" = "xgcc"; then | |
| AC_MSG_RESULT([yes]) | |
| else | |
| AC_MSG_RESULT([no]) | |
| AVAILABLE=false | |
| fi | |
| ], | |
| IF_ENABLED: [ | |
| STATIC_ANALYZER_CFLAGS="-fanalyzer -Wno-analyzer-fd-leak" | |
| CFLAGS_JDKLIB="$CFLAGS_JDKLIB $STATIC_ANALYZER_CFLAGS" | |
| CFLAGS_JDKEXE="$CFLAGS_JDKEXE $STATIC_ANALYZER_CFLAGS" | |
| ]) | |
| AC_SUBST(STATIC_ANALYZER_ENABLED) | |
| ]) | |
| ################################################################################ | |
| # | |
| # LeakSanitizer | |
| # | |
| AC_DEFUN_ONCE([JDKOPT_SETUP_LEAK_SANITIZER], | |
| [ | |
| UTIL_ARG_ENABLE(NAME: lsan, DEFAULT: false, RESULT: LSAN_ENABLED, | |
| DESC: [enable LeakSanitizer], | |
| CHECK_AVAILABLE: [ | |
| AC_MSG_CHECKING([if LeakSanitizer (lsan) is available]) | |
| if test "x$TOOLCHAIN_TYPE" = "xgcc" || | |
| test "x$TOOLCHAIN_TYPE" = "xclang"; then | |
| AC_MSG_RESULT([yes]) | |
| else | |
| AC_MSG_RESULT([no]) | |
| AVAILABLE=false | |
| fi | |
| ], | |
| IF_ENABLED: [ | |
| LSAN_CFLAGS="-fsanitize=leak -fno-omit-frame-pointer -DLEAK_SANITIZER" | |
| LSAN_LDFLAGS="-fsanitize=leak" | |
| JVM_CFLAGS="$JVM_CFLAGS $LSAN_CFLAGS" | |
| JVM_LDFLAGS="$JVM_LDFLAGS $LSAN_LDFLAGS" | |
| CFLAGS_JDKLIB="$CFLAGS_JDKLIB $LSAN_CFLAGS" | |
| CFLAGS_JDKEXE="$CFLAGS_JDKEXE $LSAN_CFLAGS" | |
| CXXFLAGS_JDKLIB="$CXXFLAGS_JDKLIB $LSAN_CFLAGS" | |
| CXXFLAGS_JDKEXE="$CXXFLAGS_JDKEXE $LSAN_CFLAGS" | |
| LDFLAGS_JDKLIB="$LDFLAGS_JDKLIB $LSAN_LDFLAGS" | |
| LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE $LSAN_LDFLAGS" | |
| LDFLAGS_STATIC_JDK="$LDFLAGS_STATIC_JDK $LSAN_LDFLAGS" | |
| ]) | |
| AC_SUBST(LSAN_ENABLED) | |
| ]) | |
| ################################################################################ | |
| # | |
| # UndefinedBehaviorSanitizer | |
| # | |
| AC_DEFUN_ONCE([JDKOPT_SETUP_UNDEFINED_BEHAVIOR_SANITIZER], | |
| [ | |
| UTIL_ARG_WITH(NAME: additional-ubsan-checks, TYPE: string, | |
| DEFAULT: [], | |
| DESC: [Customizes the ubsan checks], | |
| OPTIONAL: true) | |
| # GCC reports lots of likely false positives for stringop-truncation and format-overflow. | |
| # GCC 13 also for array-bounds and stringop-overflow | |
| # Silence them for now. | |
| UBSAN_CHECKS="-fsanitize=undefined -fsanitize=float-divide-by-zero -fno-sanitize=shift-base -fno-sanitize=alignment \ | |
| $ADDITIONAL_UBSAN_CHECKS" | |
| UBSAN_CFLAGS="$UBSAN_CHECKS -Wno-array-bounds -fno-omit-frame-pointer -DUNDEFINED_BEHAVIOR_SANITIZER" | |
| if test "x$TOOLCHAIN_TYPE" = "xgcc"; then | |
| UBSAN_CFLAGS="$UBSAN_CFLAGS -Wno-format-overflow -Wno-stringop-overflow -Wno-stringop-truncation" | |
| fi | |
| UBSAN_LDFLAGS="$UBSAN_CHECKS" | |
| # On AIX, the llvm_symbolizer is not found out of the box, so we have to provide the | |
| # full qualified llvm_symbolizer path in the __ubsan_default_options() function in | |
| # make/data/ubsan/ubsan_default_options.c. To get it there we compile our sources | |
| # with an additional define LLVM_SYMBOLIZER, which we set here. | |
| # To calculate the correct llvm_symbolizer path we can use the location of the compiler, because | |
| # their relation is fixed. | |
| if test "x$TOOLCHAIN_TYPE" = "xclang" && test "x$OPENJDK_TARGET_OS" = "xaix"; then | |
| UBSAN_CFLAGS="$UBSAN_CFLAGS -fno-sanitize=function,vptr -DLLVM_SYMBOLIZER=$(dirname $(dirname $CC))/tools/ibm-llvm-symbolizer" | |
| UBSAN_LDFLAGS="$UBSAN_LDFLAGS -fno-sanitize=function,vptr -Wl,-bbigtoc" | |
| fi | |
| UTIL_ARG_ENABLE(NAME: ubsan, DEFAULT: false, RESULT: UBSAN_ENABLED, | |
| DESC: [enable UndefinedBehaviorSanitizer], | |
| CHECK_AVAILABLE: [ | |
| AC_MSG_CHECKING([if UndefinedBehaviorSanitizer (ubsan) is available]) | |
| if test "x$TOOLCHAIN_TYPE" = "xgcc" || | |
| test "x$TOOLCHAIN_TYPE" = "xclang"; then | |
| AC_MSG_RESULT([yes]) | |
| else | |
| AC_MSG_RESULT([no]) | |
| AVAILABLE=false | |
| fi | |
| ], | |
| IF_ENABLED: [ | |
| JVM_CFLAGS="$JVM_CFLAGS $UBSAN_CFLAGS" | |
| JVM_LDFLAGS="$JVM_LDFLAGS $UBSAN_LDFLAGS" | |
| CFLAGS_JDKLIB="$CFLAGS_JDKLIB $UBSAN_CFLAGS" | |
| CFLAGS_JDKEXE="$CFLAGS_JDKEXE $UBSAN_CFLAGS" | |
| CXXFLAGS_JDKLIB="$CXXFLAGS_JDKLIB $UBSAN_CFLAGS" | |
| CXXFLAGS_JDKEXE="$CXXFLAGS_JDKEXE $UBSAN_CFLAGS" | |
| LDFLAGS_JDKLIB="$LDFLAGS_JDKLIB $UBSAN_LDFLAGS" | |
| LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE $UBSAN_LDFLAGS" | |
| LDFLAGS_STATIC_JDK="$LDFLAGS_STATIC_JDK $UBSAN_LDFLAGS" | |
| ]) | |
| if test "x$UBSAN_ENABLED" = xfalse; then | |
| UBSAN_CFLAGS="" | |
| UBSAN_LDFLAGS="" | |
| fi | |
| AC_SUBST(UBSAN_CFLAGS) | |
| AC_SUBST(UBSAN_LDFLAGS) | |
| AC_SUBST(UBSAN_ENABLED) | |
| ]) | |
| ################################################################################ | |
| # | |
| # jmod options. | |
| # | |
| AC_DEFUN_ONCE([JDKOPT_SETUP_JMOD_OPTIONS], | |
| [ | |
| # Final JMODs are recompiled often during development, and java.base JMOD | |
| # includes the JVM libraries. In release mode, prefer to compress JMODs fully. | |
| # In debug mode, pay with a little extra space, but win a lot of CPU time back | |
| # with the lightest (but still some) compression. | |
| if test "x$DEBUG_LEVEL" = xrelease; then | |
| DEFAULT_JMOD_COMPRESS="zip-6" | |
| else | |
| DEFAULT_JMOD_COMPRESS="zip-1" | |
| fi | |
| UTIL_ARG_WITH(NAME: jmod-compress, TYPE: literal, | |
| VALID_VALUES: [zip-0 zip-1 zip-2 zip-3 zip-4 zip-5 zip-6 zip-7 zip-8 zip-9], | |
| DEFAULT: $DEFAULT_JMOD_COMPRESS, | |
| CHECKING_MSG: [for JMOD compression type], | |
| DESC: [specify JMOD compression type (zip-[0-9])] | |
| ) | |
| AC_SUBST(JMOD_COMPRESS) | |
| ]) | |
| ################################################################################ | |
| # | |
| # jlink options. | |
| # | |
| AC_DEFUN_ONCE([JDKOPT_SETUP_JLINK_OPTIONS], | |
| [ | |
| ################################################################################ | |
| # | |
| # Configure option for building a JDK that is suitable for linking from the | |
| # run-time image without JMODs. | |
| # | |
| # Determines whether or not a suitable run-time image is being produced from | |
| # packaged modules. If set to 'true, changes the *default* of packaged | |
| # modules to 'false'. | |
| # | |
| UTIL_ARG_ENABLE(NAME: linkable-runtime, DEFAULT: false, | |
| RESULT: JLINK_PRODUCE_LINKABLE_RUNTIME, | |
| DESC: [enable a JDK build suitable for linking from the run-time image], | |
| CHECKING_MSG: [whether or not a JDK suitable for linking from the run-time image should be produced]) | |
| AC_SUBST(JLINK_PRODUCE_LINKABLE_RUNTIME) | |
| if test "x$JLINK_PRODUCE_LINKABLE_RUNTIME" = xtrue; then | |
| DEFAULT_PACKAGED_MODULES=false | |
| else | |
| DEFAULT_PACKAGED_MODULES=true | |
| fi | |
| ################################################################################ | |
| # | |
| # Configure option for packaged modules | |
| # | |
| # We keep packaged modules in the JDK image unless --enable-linkable-runtime is | |
| # requested. | |
| # | |
| UTIL_ARG_ENABLE(NAME: keep-packaged-modules, DEFAULT: $DEFAULT_PACKAGED_MODULES, | |
| RESULT: JLINK_KEEP_PACKAGED_MODULES, | |
| DESC: [enable keeping of packaged modules in jdk image], | |
| DEFAULT_DESC: [enabled by default unless --enable-linkable-runtime is set], | |
| CHECKING_MSG: [if packaged modules are kept]) | |
| AC_SUBST(JLINK_KEEP_PACKAGED_MODULES) | |
| ################################################################################ | |
| # | |
| # Extra jlink options to be (optionally) passed to the JDK build | |
| # | |
| UTIL_ARG_WITH(NAME: extra-jlink-flags, TYPE: string, | |
| DEFAULT: [], | |
| DESC: [extra flags to be passed to jlink during the build], | |
| OPTIONAL: true) | |
| JLINK_USER_EXTRA_FLAGS="$EXTRA_JLINK_FLAGS" | |
| AC_SUBST(JLINK_USER_EXTRA_FLAGS) | |
| ]) | |
| ################################################################################ | |
| # | |
| # Enable or disable generation of the classlist at build time | |
| # | |
| AC_DEFUN_ONCE([JDKOPT_ENABLE_DISABLE_GENERATE_CLASSLIST], | |
| [ | |
| # In GenerateLinkOptData.gmk, DumpLoadedClassList is used to generate the | |
| # classlist file. It never will work if CDS is disabled, since the VM will report | |
| # an error for DumpLoadedClassList. | |
| UTIL_ARG_ENABLE(NAME: generate-classlist, DEFAULT: auto, | |
| RESULT: ENABLE_GENERATE_CLASSLIST, AVAILABLE: $ENABLE_CDS, | |
| DESC: [enable generation of a CDS classlist at build time], | |
| DEFAULT_DESC: [enabled if the JVM feature 'cds' is enabled for all JVM variants], | |
| CHECKING_MSG: [if the CDS classlist generation should be enabled]) | |
| AC_SUBST(ENABLE_GENERATE_CLASSLIST) | |
| ]) | |
| ################################################################################ | |
| # | |
| # Optionally filter resource translations | |
| # | |
| AC_DEFUN([JDKOPT_EXCLUDE_TRANSLATIONS], | |
| [ | |
| AC_ARG_WITH([exclude-translations], [AS_HELP_STRING([--with-exclude-translations], | |
| [a comma separated list of locales to exclude translations for. Default is | |
| to include all translations present in the source.])]) | |
| EXCLUDE_TRANSLATIONS="" | |
| AC_MSG_CHECKING([if any translations should be excluded]) | |
| if test "x$with_exclude_translations" != "x"; then | |
| EXCLUDE_TRANSLATIONS="${with_exclude_translations//,/ }" | |
| AC_MSG_RESULT([yes: $EXCLUDE_TRANSLATIONS]) | |
| else | |
| AC_MSG_RESULT([no]) | |
| fi | |
| AC_SUBST(EXCLUDE_TRANSLATIONS) | |
| ]) | |
| ################################################################################ | |
| # | |
| # Disable the default CDS archive generation | |
| # | |
| AC_DEFUN([JDKOPT_ENABLE_DISABLE_CDS_ARCHIVE], | |
| [ | |
| UTIL_ARG_ENABLE(NAME: cds-archive, DEFAULT: auto, RESULT: BUILD_CDS_ARCHIVE, | |
| DESC: [enable generation of a default CDS archive in the product image], | |
| DEFAULT_DESC: [enabled if possible], | |
| CHECKING_MSG: [if a default CDS archive should be generated], | |
| CHECK_AVAILABLE: [ | |
| AC_MSG_CHECKING([if CDS archive is available]) | |
| if test "x$ENABLE_CDS" = "xfalse"; then | |
| AC_MSG_RESULT([no (CDS is disabled)]) | |
| AVAILABLE=false | |
| elif test "x$COMPILE_TYPE" = "xcross"; then | |
| AC_MSG_RESULT([no (not possible with cross compilation)]) | |
| AVAILABLE=false | |
| else | |
| AC_MSG_RESULT([yes]) | |
| fi | |
| ]) | |
| AC_SUBST(BUILD_CDS_ARCHIVE) | |
| ]) | |
| ################################################################################ | |
| # | |
| # Enable or disable the default CDS archive generation for Compact Object Headers | |
| # | |
| AC_DEFUN([JDKOPT_ENABLE_DISABLE_CDS_ARCHIVE_COH], | |
| [ | |
| UTIL_ARG_ENABLE(NAME: cds-archive-coh, DEFAULT: auto, RESULT: BUILD_CDS_ARCHIVE_COH, | |
| DESC: [enable generation of default CDS archives for compact object headers (requires --enable-cds-archive)], | |
| DEFAULT_DESC: [auto], | |
| CHECKING_MSG: [if default CDS archives for compact object headers should be generated], | |
| CHECK_AVAILABLE: [ | |
| AC_MSG_CHECKING([if CDS archive with compact object headers is available]) | |
| if test "x$BUILD_CDS_ARCHIVE" = "xfalse"; then | |
| AC_MSG_RESULT([no (CDS default archive generation is disabled)]) | |
| AVAILABLE=false | |
| elif test "x$OPENJDK_TARGET_CPU" != "xx86_64" && | |
| test "x$OPENJDK_TARGET_CPU" != "xaarch64" && | |
| test "x$OPENJDK_TARGET_CPU" != "xppc64" && | |
| test "x$OPENJDK_TARGET_CPU" != "xppc64le" && | |
| test "x$OPENJDK_TARGET_CPU" != "xriscv64" && | |
| test "x$OPENJDK_TARGET_CPU" != "xs390x"; then | |
| AC_MSG_RESULT([no (compact object headers not supported for this platform)]) | |
| AVAILABLE=false | |
| else | |
| AC_MSG_RESULT([yes]) | |
| AVAILABLE=true | |
| fi | |
| ]) | |
| AC_SUBST(BUILD_CDS_ARCHIVE_COH) | |
| ]) | |
| ################################################################################ | |
| # | |
| # Enable the alternative CDS core region alignment | |
| # | |
| AC_DEFUN([JDKOPT_ENABLE_DISABLE_COMPATIBLE_CDS_ALIGNMENT], | |
| [ | |
| UTIL_ARG_ENABLE(NAME: compatible-cds-alignment, DEFAULT: $COMPATIBLE_CDS_ALIGNMENT_DEFAULT, | |
| RESULT: ENABLE_COMPATIBLE_CDS_ALIGNMENT, | |
| DESC: [enable use alternative compatible cds core region alignment], | |
| DEFAULT_DESC: [disabled except on linux-aarch64], | |
| CHECKING_MSG: [if compatible cds region alignment enabled], | |
| CHECK_AVAILABLE: [ | |
| AC_MSG_CHECKING([if CDS archive is available]) | |
| if test "x$ENABLE_CDS" = "xfalse"; then | |
| AVAILABLE=false | |
| AC_MSG_RESULT([no (CDS is disabled)]) | |
| else | |
| AVAILABLE=true | |
| AC_MSG_RESULT([yes]) | |
| fi | |
| ]) | |
| AC_SUBST(ENABLE_COMPATIBLE_CDS_ALIGNMENT) | |
| ]) | |
| ################################################################################ | |
| # | |
| # Disallow any output from containing absolute paths from the build system. | |
| # This setting defaults to allowed on debug builds and not allowed on release | |
| # builds. | |
| # | |
| AC_DEFUN([JDKOPT_ALLOW_ABSOLUTE_PATHS_IN_OUTPUT], | |
| [ | |
| AC_ARG_ENABLE([absolute-paths-in-output], | |
| [AS_HELP_STRING([--disable-absolute-paths-in-output], | |
| [Set to disable to prevent any absolute paths from the build to end up in | |
| any of the build output. @<:@disabled in release builds, otherwise enabled@:>@])]) | |
| AC_MSG_CHECKING([if absolute paths should be allowed in the build output]) | |
| if test "x$enable_absolute_paths_in_output" = "xno"; then | |
| AC_MSG_RESULT([no, forced]) | |
| ALLOW_ABSOLUTE_PATHS_IN_OUTPUT="false" | |
| elif test "x$enable_absolute_paths_in_output" = "xyes"; then | |
| AC_MSG_RESULT([yes, forced]) | |
| ALLOW_ABSOLUTE_PATHS_IN_OUTPUT="true" | |
| elif test "x$DEBUG_LEVEL" = "xrelease"; then | |
| AC_MSG_RESULT([no, release build]) | |
| ALLOW_ABSOLUTE_PATHS_IN_OUTPUT="false" | |
| else | |
| AC_MSG_RESULT([yes, debug build]) | |
| ALLOW_ABSOLUTE_PATHS_IN_OUTPUT="true" | |
| fi | |
| AC_SUBST(ALLOW_ABSOLUTE_PATHS_IN_OUTPUT) | |
| ]) | |
| ################################################################################ | |
| # | |
| # Check and set options related to reproducible builds. | |
| # | |
| AC_DEFUN_ONCE([JDKOPT_SETUP_REPRODUCIBLE_BUILD], | |
| [ | |
| AC_ARG_WITH([source-date], [AS_HELP_STRING([--with-source-date], | |
| [how to set SOURCE_DATE_EPOCH ('updated', 'current', 'version' a timestamp or an ISO-8601 date) @<:@current/value of SOURCE_DATE_EPOCH@:>@])], | |
| [with_source_date_present=true], [with_source_date_present=false]) | |
| if test "x$SOURCE_DATE_EPOCH" != x && test "x$with_source_date" != x; then | |
| AC_MSG_WARN([--with-source-date will override SOURCE_DATE_EPOCH]) | |
| fi | |
| AC_MSG_CHECKING([what source date to use]) | |
| if test "x$with_source_date" = xyes; then | |
| AC_MSG_ERROR([--with-source-date must have a value]) | |
| elif test "x$with_source_date" = x; then | |
| if test "x$SOURCE_DATE_EPOCH" != x; then | |
| SOURCE_DATE=$SOURCE_DATE_EPOCH | |
| with_source_date_present=true | |
| AC_MSG_RESULT([$SOURCE_DATE, from SOURCE_DATE_EPOCH]) | |
| else | |
| # Tell makefiles to take the time from configure | |
| SOURCE_DATE=$($DATE +"%s") | |
| AC_MSG_RESULT([$SOURCE_DATE, from 'current' (default)]) | |
| fi | |
| elif test "x$with_source_date" = xupdated; then | |
| SOURCE_DATE=updated | |
| AC_MSG_RESULT([determined at build time, from 'updated']) | |
| elif test "x$with_source_date" = xcurrent; then | |
| # Set the current time | |
| SOURCE_DATE=$($DATE +"%s") | |
| AC_MSG_RESULT([$SOURCE_DATE, from 'current']) | |
| elif test "x$with_source_date" = xversion; then | |
| # Use the date from version-numbers.conf | |
| UTIL_GET_EPOCH_TIMESTAMP(SOURCE_DATE, $DEFAULT_VERSION_DATE) | |
| if test "x$SOURCE_DATE" = x; then | |
| AC_MSG_RESULT([unavailable]) | |
| AC_MSG_ERROR([Cannot convert DEFAULT_VERSION_DATE to timestamp]) | |
| fi | |
| AC_MSG_RESULT([$SOURCE_DATE, from 'version']) | |
| else | |
| # It's a timestamp, an ISO-8601 date, or an invalid string | |
| # Additional [] needed to keep m4 from mangling shell constructs. | |
| if [ [[ "$with_source_date" =~ ^[0-9][0-9]*$ ]] ] ; then | |
| SOURCE_DATE=$with_source_date | |
| AC_MSG_RESULT([$SOURCE_DATE, from timestamp on command line]) | |
| else | |
| UTIL_GET_EPOCH_TIMESTAMP(SOURCE_DATE, $with_source_date) | |
| if test "x$SOURCE_DATE" != x; then | |
| AC_MSG_RESULT([$SOURCE_DATE, from ISO-8601 date on command line]) | |
| else | |
| AC_MSG_RESULT([unavailable]) | |
| AC_MSG_ERROR([Cannot parse date string "$with_source_date"]) | |
| fi | |
| fi | |
| fi | |
| ISO_8601_FORMAT_STRING="%Y-%m-%dT%H:%M:%SZ" | |
| if test "x$SOURCE_DATE" != xupdated; then | |
| # If we have a fixed value for SOURCE_DATE, we need to set SOURCE_DATE_EPOCH | |
| # for the rest of configure. | |
| SOURCE_DATE_EPOCH="$SOURCE_DATE" | |
| if test "x$IS_GNU_DATE" = xyes; then | |
| SOURCE_DATE_ISO_8601=`$DATE --utc --date="@$SOURCE_DATE" +"$ISO_8601_FORMAT_STRING" 2> /dev/null` | |
| else | |
| SOURCE_DATE_ISO_8601=`$DATE -u -j -f "%s" "$SOURCE_DATE" +"$ISO_8601_FORMAT_STRING" 2> /dev/null` | |
| fi | |
| fi | |
| AC_SUBST(SOURCE_DATE) | |
| AC_SUBST(ISO_8601_FORMAT_STRING) | |
| AC_SUBST(SOURCE_DATE_ISO_8601) | |
| ]) | |
| ################################################################################ | |
| # | |
| # Setup signing on macOS. This can either be setup to sign with a real identity | |
| # and enabling the hardened runtime, or it can simply add the debug entitlement | |
| # com.apple.security.get-task-allow without actually signing any binaries. The | |
| # latter is needed to be able to debug processes and dump core files on modern | |
| # versions of macOS. It can also be skipped completely. | |
| # | |
| # Check if codesign will run with the given parameters | |
| # $1: Parameters to run with | |
| # $2: Checking message | |
| # Sets CODESIGN_SUCCESS=true/false | |
| AC_DEFUN([JDKOPT_CHECK_CODESIGN_PARAMS], | |
| [ | |
| PARAMS="$1" | |
| MESSAGE="$2" | |
| CODESIGN_TESTFILE="$CONFIGURESUPPORT_OUTPUTDIR/codesign-testfile" | |
| $RM "$CODESIGN_TESTFILE" | |
| $TOUCH "$CODESIGN_TESTFILE" | |
| CODESIGN_SUCCESS=false | |
| $ECHO "check codesign, calling $CODESIGN $PARAMS $CODESIGN_TESTFILE" >&AS_MESSAGE_LOG_FD | |
| eval \"$CODESIGN\" $PARAMS \"$CODESIGN_TESTFILE\" 2>&AS_MESSAGE_LOG_FD \ | |
| >&AS_MESSAGE_LOG_FD && CODESIGN_SUCCESS=true | |
| $RM "$CODESIGN_TESTFILE" | |
| AC_MSG_CHECKING([$MESSAGE]) | |
| if test "x$CODESIGN_SUCCESS" = "xtrue"; then | |
| AC_MSG_RESULT([yes]) | |
| else | |
| AC_MSG_RESULT([no]) | |
| fi | |
| ]) | |
| AC_DEFUN([JDKOPT_CHECK_CODESIGN_HARDENED], | |
| [ | |
| JDKOPT_CHECK_CODESIGN_PARAMS([-s \"$MACOSX_CODESIGN_IDENTITY\" --option runtime], | |
| [if codesign with hardened runtime is possible]) | |
| ]) | |
| AC_DEFUN([JDKOPT_CHECK_CODESIGN_DEBUG], | |
| [ | |
| JDKOPT_CHECK_CODESIGN_PARAMS([-s -], [if debug mode codesign is possible]) | |
| ]) | |
| AC_DEFUN([JDKOPT_SETUP_MACOSX_SIGNING], | |
| [ | |
| MACOSX_CODESIGN_MODE=disabled | |
| if test "x$OPENJDK_TARGET_OS" = "xmacosx" && test "x$CODESIGN" != "x"; then | |
| UTIL_ARG_WITH(NAME: macosx-codesign, TYPE: literal, OPTIONAL: true, | |
| VALID_VALUES: [hardened debug auto], DEFAULT: auto, | |
| ENABLED_DEFAULT: true, | |
| CHECKING_MSG: [for macosx code signing mode], | |
| DESC: [set the macosx code signing mode (hardened, debug, auto)] | |
| ) | |
| if test "x$MACOSX_CODESIGN_ENABLED" = "xtrue"; then | |
| # Check for user provided code signing identity. | |
| UTIL_ARG_WITH(NAME: macosx-codesign-identity, TYPE: string, | |
| DEFAULT: openjdk_codesign, CHECK_VALUE: [UTIL_CHECK_STRING_NON_EMPTY], | |
| DESC: [specify the macosx code signing identity], | |
| CHECKING_MSG: [for macosx code signing identity] | |
| ) | |
| AC_SUBST(MACOSX_CODESIGN_IDENTITY) | |
| if test "x$MACOSX_CODESIGN" = "xauto"; then | |
| # Only try to default to hardened signing on release builds | |
| if test "x$DEBUG_LEVEL" = "xrelease"; then | |
| JDKOPT_CHECK_CODESIGN_HARDENED | |
| if test "x$CODESIGN_SUCCESS" = "xtrue"; then | |
| MACOSX_CODESIGN_MODE=hardened | |
| fi | |
| fi | |
| if test "x$MACOSX_CODESIGN_MODE" = "xdisabled"; then | |
| JDKOPT_CHECK_CODESIGN_DEBUG | |
| if test "x$CODESIGN_SUCCESS" = "xtrue"; then | |
| MACOSX_CODESIGN_MODE=debug | |
| fi | |
| fi | |
| AC_MSG_CHECKING([for macosx code signing mode]) | |
| AC_MSG_RESULT([$MACOSX_CODESIGN_MODE]) | |
| elif test "x$MACOSX_CODESIGN" = "xhardened"; then | |
| JDKOPT_CHECK_CODESIGN_HARDENED | |
| if test "x$CODESIGN_SUCCESS" = "xfalse"; then | |
| AC_MSG_ERROR([Signing with hardened runtime is not possible]) | |
| fi | |
| MACOSX_CODESIGN_MODE=hardened | |
| elif test "x$MACOSX_CODESIGN" = "xdebug"; then | |
| JDKOPT_CHECK_CODESIGN_DEBUG | |
| if test "x$CODESIGN_SUCCESS" = "xfalse"; then | |
| AC_MSG_ERROR([Signing in debug mode is not possible]) | |
| fi | |
| MACOSX_CODESIGN_MODE=debug | |
| else | |
| AC_MSG_ERROR([unknown value for --with-macosx-codesign: $MACOSX_CODESIGN]) | |
| fi | |
| fi | |
| fi | |
| AC_SUBST(MACOSX_CODESIGN_IDENTITY) | |
| AC_SUBST(MACOSX_CODESIGN_MODE) | |
| ]) | |
| ################################################################################ | |
| # | |
| # Setup a hook to invoke a script that runs for file produced by the native | |
| # compilation steps, after linking. | |
| # Parameter is the path to the script to be called. | |
| # | |
| AC_DEFUN([JDKOPT_SETUP_SIGNING_HOOK], | |
| [ | |
| UTIL_ARG_WITH(NAME: signing-hook, TYPE: executable, | |
| OPTIONAL: true, DEFAULT: "", | |
| DESC: [specify path to script used to code sign native binaries] | |
| ) | |
| AC_MSG_CHECKING([for signing hook]) | |
| if test "x$SIGNING_HOOK" != x; then | |
| UTIL_FIXUP_EXECUTABLE(SIGNING_HOOK) | |
| AC_MSG_RESULT([$SIGNING_HOOK]) | |
| else | |
| AC_MSG_RESULT([none]) | |
| fi | |
| AC_SUBST(SIGNING_HOOK) | |
| ]) | |
| ################################################################################ | |
| # | |
| # Setup how javac should handle warnings. | |
| # | |
| AC_DEFUN([JDKOPT_SETUP_JAVA_WARNINGS], | |
| [ | |
| UTIL_ARG_ENABLE(NAME: java-warnings-as-errors, DEFAULT: true, | |
| RESULT: JAVA_WARNINGS_AS_ERRORS, | |
| DESC: [consider java warnings to be an error]) | |
| AC_SUBST(JAVA_WARNINGS_AS_ERRORS) | |
| ]) | |
| ################################################################################ | |
| # | |
| # fallback linker | |
| # | |
| AC_DEFUN_ONCE([JDKOPT_SETUP_FALLBACK_LINKER], | |
| [ | |
| FALLBACK_LINKER_DEFAULT=false | |
| if HOTSPOT_CHECK_JVM_VARIANT(zero); then | |
| FALLBACK_LINKER_DEFAULT=true | |
| fi | |
| UTIL_ARG_ENABLE(NAME: fallback-linker, DEFAULT: $FALLBACK_LINKER_DEFAULT, | |
| RESULT: ENABLE_FALLBACK_LINKER, | |
| DESC: [enable libffi-based fallback implementation of java.lang.foreign.Linker], | |
| CHECKING_MSG: [if fallback linker enabled]) | |
| AC_SUBST(ENABLE_FALLBACK_LINKER) | |
| ]) |