jdk-options.m4

#
# 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.
  # In the ubsan case we have to link every binary with the C++-compiler as linker, because inherently
  # the C-Compiler and the C++-compiler used as linker provide a different set of ubsan exports.
  # Linking an executable with the C-compiler and one of its shared libraries with the C++-compiler
  # leeds to unresolved symbols.
  if test "x$TOOLCHAIN_TYPE" = "xclang" && test "x$OPENJDK_TARGET_OS" = "xaix"; then
    UBSAN_CFLAGS="$UBSAN_CFLAGS -DLLVM_SYMBOLIZER=$(dirname $(dirname $CC))/tools/ibm-llvm-symbolizer"
    UBSAN_LDFLAGS="$UBSAN_LDFLAGS -Wl,-bbigtoc"
    LD="$LDCXX"
  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)
])