flags.m4 revision 1808:90f455b5ff5e
125164Speter# 225164Speter# Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved. 325164Speter# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 425164Speter# 525164Speter# This code is free software; you can redistribute it and/or modify it 625164Speter# under the terms of the GNU General Public License version 2 only, as 725164Speter# published by the Free Software Foundation. Oracle designates this 825164Speter# particular file as subject to the "Classpath" exception as provided 925164Speter# by Oracle in the LICENSE file that accompanied this code. 1025164Speter# 1125164Speter# This code is distributed in the hope that it will be useful, but WITHOUT 1225164Speter# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 1325164Speter# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1425164Speter# version 2 for more details (a copy is included in the LICENSE file that 1525164Speter# accompanied this code). 1625164Speter# 1725164Speter# You should have received a copy of the GNU General Public License version 1825164Speter# 2 along with this work; if not, write to the Free Software Foundation, 1925164Speter# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 2025164Speter# 2125164Speter# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 2225164Speter# or visit www.oracle.com if you need additional information or have any 2325164Speter# questions. 2425164Speter# 2525216Sfsmp 2625164Speter# Reset the global CFLAGS/LDFLAGS variables and initialize them with the 2725164Speter# corresponding configure arguments instead 2825164SpeterAC_DEFUN_ONCE([FLAGS_SETUP_USER_SUPPLIED_FLAGS], 2925215Sfsmp[ 3025164Speter if test "x$CFLAGS" != "x${ADDED_CFLAGS}"; then 3125164Speter AC_MSG_WARN([Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags]) 3225164Speter fi 3325164Speter 3425164Speter if test "x$CXXFLAGS" != "x${ADDED_CXXFLAGS}"; then 3525164Speter AC_MSG_WARN([Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags]) 3625164Speter fi 3725164Speter 3825164Speter if test "x$LDFLAGS" != "x${ADDED_LDFLAGS}"; then 3925164Speter AC_MSG_WARN([Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags]) 4025164Speter fi 4125164Speter 4225164Speter AC_ARG_WITH(extra-cflags, [AS_HELP_STRING([--with-extra-cflags], 4325164Speter [extra flags to be used when compiling jdk c-files])]) 4425164Speter 4525164Speter AC_ARG_WITH(extra-cxxflags, [AS_HELP_STRING([--with-extra-cxxflags], 4625164Speter [extra flags to be used when compiling jdk c++-files])]) 4725164Speter 4825164Speter AC_ARG_WITH(extra-ldflags, [AS_HELP_STRING([--with-extra-ldflags], 4925164Speter [extra flags to be used when linking jdk])]) 5025216Sfsmp 5125164Speter EXTRA_CFLAGS="$with_extra_cflags" 5225164Speter EXTRA_CXXFLAGS="$with_extra_cxxflags" 5325164Speter EXTRA_LDFLAGS="$with_extra_ldflags" 5425215Sfsmp 5525215Sfsmp # Hotspot needs these set in their legacy form 5625215Sfsmp LEGACY_EXTRA_CFLAGS="$LEGACY_EXTRA_CFLAGS $EXTRA_CFLAGS" 5725215Sfsmp LEGACY_EXTRA_CXXFLAGS="$LEGACY_EXTRA_CXXFLAGS $EXTRA_CXXFLAGS" 5825215Sfsmp LEGACY_EXTRA_LDFLAGS="$LEGACY_EXTRA_LDFLAGS $EXTRA_LDFLAGS" 5925164Speter 6025164Speter AC_SUBST(LEGACY_EXTRA_CFLAGS) 6125164Speter AC_SUBST(LEGACY_EXTRA_CXXFLAGS) 6225164Speter AC_SUBST(LEGACY_EXTRA_LDFLAGS) 6325164Speter 6425164Speter # The global CFLAGS and LDLAGS variables are used by configure tests and 6525164Speter # should include the extra parameters 6625164Speter CFLAGS="$EXTRA_CFLAGS" 6725164Speter CXXFLAGS="$EXTRA_CXXFLAGS" 6825164Speter LDFLAGS="$EXTRA_LDFLAGS" 6925164Speter CPPFLAGS="" 7025164Speter]) 7125164Speter 7225164Speter# Setup the sysroot flags and add them to global CFLAGS and LDFLAGS so 7325164Speter# that configure can use them while detecting compilers. 7425164Speter# TOOLCHAIN_TYPE is available here. 7525164Speter# Param 1 - Optional prefix to all variables. (e.g BUILD_) 7625164SpeterAC_DEFUN([FLAGS_SETUP_SYSROOT_FLAGS], 7725164Speter[ 7825164Speter if test "x[$]$1SYSROOT" != "x"; then 7925164Speter if test "x$TOOLCHAIN_TYPE" = xsolstudio; then 8025164Speter if test "x$OPENJDK_TARGET_OS" = xsolaris; then 8125164Speter # Solaris Studio does not have a concept of sysroot. Instead we must 8225164Speter # make sure the default include and lib dirs are appended to each 8325164Speter # compile and link command line. 8425164Speter $1SYSROOT_CFLAGS="-I[$]$1SYSROOT/usr/include" 8525164Speter $1SYSROOT_LDFLAGS="-L[$]$1SYSROOT/usr/lib$OPENJDK_TARGET_CPU_ISADIR \ 8625164Speter -L[$]$1SYSROOT/lib$OPENJDK_TARGET_CPU_ISADIR \ 8725164Speter -L[$]$1SYSROOT/usr/ccs/lib$OPENJDK_TARGET_CPU_ISADIR" 8825164Speter fi 8925164Speter elif test "x$TOOLCHAIN_TYPE" = xgcc; then 9025164Speter $1SYSROOT_CFLAGS="--sysroot=[$]$1SYSROOT" 9125164Speter $1SYSROOT_LDFLAGS="--sysroot=[$]$1SYSROOT" 9225164Speter elif test "x$TOOLCHAIN_TYPE" = xclang; then 9325164Speter $1SYSROOT_CFLAGS="-isysroot [$]$1SYSROOT" 9425164Speter $1SYSROOT_LDFLAGS="-isysroot [$]$1SYSROOT" 9525164Speter fi 9625164Speter # Propagate the sysroot args to hotspot 9725164Speter $1LEGACY_EXTRA_CFLAGS="[$]$1LEGACY_EXTRA_CFLAGS [$]$1SYSROOT_CFLAGS" 9825164Speter $1LEGACY_EXTRA_CXXFLAGS="[$]$1LEGACY_EXTRA_CXXFLAGS [$]$1SYSROOT_CFLAGS" 9925164Speter $1LEGACY_EXTRA_LDFLAGS="[$]$1LEGACY_EXTRA_LDFLAGS [$]$1SYSROOT_LDFLAGS" 10025164Speter # The global CFLAGS and LDFLAGS variables need these for configure to function 10125164Speter $1CFLAGS="[$]$1CFLAGS [$]$1SYSROOT_CFLAGS" 10225164Speter $1CPPFLAGS="[$]$1CPPFLAGS [$]$1SYSROOT_CFLAGS" 10325164Speter $1CXXFLAGS="[$]$1CXXFLAGS [$]$1SYSROOT_CFLAGS" 10425164Speter $1LDFLAGS="[$]$1LDFLAGS [$]$1SYSROOT_LDFLAGS" 10525164Speter fi 10625164Speter 10725164Speter if test "x$OPENJDK_TARGET_OS" = xmacosx; then 10825164Speter # We also need -iframework<path>/System/Library/Frameworks 10925164Speter $1SYSROOT_CFLAGS="[$]$1SYSROOT_CFLAGS -iframework [$]$1SYSROOT/System/Library/Frameworks" 11025164Speter $1SYSROOT_LDFLAGS="[$]$1SYSROOT_LDFLAGS -iframework [$]$1SYSROOT/System/Library/Frameworks" 11125164Speter # These always need to be set, or we can't find the frameworks embedded in JavaVM.framework 11225164Speter # set this here so it doesn't have to be peppered throughout the forest 11325164Speter $1SYSROOT_CFLAGS="[$]$1SYSROOT_CFLAGS -F [$]$1SYSROOT/System/Library/Frameworks/JavaVM.framework/Frameworks" 11425164Speter $1SYSROOT_LDFLAGS="[$]$1SYSROOT_LDFLAGS -F [$]$1SYSROOT/System/Library/Frameworks/JavaVM.framework/Frameworks" 11525164Speter fi 11625164Speter 11725164Speter AC_SUBST($1SYSROOT_CFLAGS) 11825164Speter AC_SUBST($1SYSROOT_LDFLAGS) 11925164Speter]) 12025164Speter 12125164SpeterAC_DEFUN_ONCE([FLAGS_SETUP_INIT_FLAGS], 12225164Speter[ 12325164Speter # Option used to tell the compiler whether to create 32- or 64-bit executables 12425164Speter if test "x$TOOLCHAIN_TYPE" = xxlc; then 12525164Speter COMPILER_TARGET_BITS_FLAG="-q" 12625164Speter else 12725164Speter COMPILER_TARGET_BITS_FLAG="-m" 12825164Speter fi 12925164Speter AC_SUBST(COMPILER_TARGET_BITS_FLAG) 13025164Speter 13125164Speter # FIXME: figure out if we should select AR flags depending on OS or toolchain. 13225164Speter if test "x$OPENJDK_TARGET_OS" = xmacosx; then 13325164Speter ARFLAGS="-r" 13425164Speter elif test "x$OPENJDK_TARGET_OS" = xaix; then 13525164Speter ARFLAGS="-X64" 13625164Speter elif test "x$OPENJDK_TARGET_OS" = xwindows; then 13725164Speter # lib.exe is used as AR to create static libraries. 13825164Speter ARFLAGS="-nologo -NODEFAULTLIB:MSVCRT" 13925164Speter else 14025164Speter ARFLAGS="" 14125164Speter fi 14225164Speter AC_SUBST(ARFLAGS) 14325164Speter 14425164Speter ## Setup strip. 14525164Speter # FIXME: should this really be per platform, or should it be per toolchain type? 14625164Speter # strip is not provided by clang or solstudio; so guessing platform makes most sense. 14725164Speter # FIXME: we should really only export STRIPFLAGS from here, not POST_STRIP_CMD. 14825164Speter if test "x$OPENJDK_TARGET_OS" = xlinux; then 14925164Speter STRIPFLAGS="-g" 15025164Speter elif test "x$OPENJDK_TARGET_OS" = xsolaris; then 15125164Speter STRIPFLAGS="-x" 15225164Speter elif test "x$OPENJDK_TARGET_OS" = xmacosx; then 15325164Speter STRIPFLAGS="-S" 15425164Speter elif test "x$OPENJDK_TARGET_OS" = xaix; then 15525164Speter STRIPFLAGS="-X32_64" 15625164Speter fi 15725164Speter 15825164Speter AC_SUBST(STRIPFLAGS) 15925164Speter 16025164Speter if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then 16125164Speter CC_OUT_OPTION=-Fo 16225164Speter EXE_OUT_OPTION=-out: 16325164Speter LD_OUT_OPTION=-out: 16425164Speter AR_OUT_OPTION=-out: 16525164Speter else 16625164Speter # The option used to specify the target .o,.a or .so file. 16725164Speter # When compiling, how to specify the to be created object file. 16825164Speter CC_OUT_OPTION='-o$(SPACE)' 16925164Speter # When linking, how to specify the to be created executable. 17025164Speter EXE_OUT_OPTION='-o$(SPACE)' 17125164Speter # When linking, how to specify the to be created dynamically linkable library. 17225164Speter LD_OUT_OPTION='-o$(SPACE)' 17325164Speter # When archiving, how to specify the to be create static archive for object files. 17425164Speter AR_OUT_OPTION='rcs$(SPACE)' 17525164Speter fi 17625164Speter AC_SUBST(CC_OUT_OPTION) 17725164Speter AC_SUBST(EXE_OUT_OPTION) 17825164Speter AC_SUBST(LD_OUT_OPTION) 17925164Speter AC_SUBST(AR_OUT_OPTION) 18025164Speter 18125164Speter # On Windows, we need to set RC flags. 18225164Speter if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then 18325164Speter RC_FLAGS="-nologo -l0x409" 18425164Speter if test "x$VARIANT" = xOPT; then 18525164Speter RC_FLAGS="$RC_FLAGS -DNDEBUG" 18625164Speter fi 18725164Speter 18825164Speter # The version variables used to create RC_FLAGS may be overridden 18925164Speter # in a custom configure script, or possibly the command line. 19025164Speter # Let those variables be expanded at make time in spec.gmk. 19125164Speter # The \$ are escaped to the shell, and the $(...) variables 19225164Speter # are evaluated by make. 19325164Speter RC_FLAGS="$RC_FLAGS \ 19425164Speter -D\"JDK_VERSION_STRING=\$(VERSION_STRING)\" \ 19525164Speter -D\"JDK_COMPANY=\$(COMPANY_NAME)\" \ 19625164Speter -D\"JDK_COMPONENT=\$(PRODUCT_NAME) \$(JDK_RC_PLATFORM_NAME) binary\" \ 19725164Speter -D\"JDK_VER=\$(VERSION_NUMBER)\" \ 19825164Speter -D\"JDK_COPYRIGHT=Copyright \xA9 $COPYRIGHT_YEAR\" \ 19925164Speter -D\"JDK_NAME=\$(PRODUCT_NAME) \$(JDK_RC_PLATFORM_NAME) \$(VERSION_MAJOR)\" \ 20025164Speter -D\"JDK_FVER=\$(subst .,\$(COMMA),\$(VERSION_NUMBER_FOUR_POSITIONS))\"" 20125164Speter fi 20225164Speter AC_SUBST(RC_FLAGS) 20325164Speter 20425164Speter if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then 20525164Speter # silence copyright notice and other headers. 20625164Speter COMMON_CCXXFLAGS="$COMMON_CCXXFLAGS -nologo" 20725164Speter fi 20825164Speter]) 20925164Speter 21025164SpeterAC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_LIBS], 21125164Speter[ 21225164Speter ############################################################################### 21325164Speter # 21425164Speter # How to compile shared libraries. 21525164Speter # 21625164Speter 21725164Speter if test "x$TOOLCHAIN_TYPE" = xgcc; then 21825164Speter PICFLAG="-fPIC" 21925164Speter C_FLAG_REORDER='' 22025164Speter CXX_FLAG_REORDER='' 22125164Speter 22225164Speter if test "x$OPENJDK_TARGET_OS" = xmacosx; then 22325164Speter # Linking is different on MacOSX 22425164Speter if test "x$STATIC_BUILD" = xtrue; then 22525164Speter SHARED_LIBRARY_FLAGS ='-undefined dynamic_lookup' 22625164Speter else 22725164Speter SHARED_LIBRARY_FLAGS="-dynamiclib -compatibility_version 1.0.0 -current_version 1.0.0 $PICFLAG" 22825164Speter fi 22925164Speter SET_EXECUTABLE_ORIGIN='-Xlinker -rpath -Xlinker @loader_path/.' 23025164Speter SET_SHARED_LIBRARY_ORIGIN="$SET_EXECUTABLE_ORIGIN" 23125164Speter SET_SHARED_LIBRARY_NAME='-Xlinker -install_name -Xlinker @rpath/[$]1' 23225164Speter SET_SHARED_LIBRARY_MAPFILE='' 23325164Speter else 23425164Speter # Default works for linux, might work on other platforms as well. 23525164Speter SHARED_LIBRARY_FLAGS='-shared' 23625164Speter SET_EXECUTABLE_ORIGIN='-Xlinker -rpath -Xlinker \$$$$ORIGIN[$]1' 23725164Speter SET_SHARED_LIBRARY_ORIGIN="-Xlinker -z -Xlinker origin $SET_EXECUTABLE_ORIGIN" 23825164Speter SET_SHARED_LIBRARY_NAME='-Xlinker -soname=[$]1' 23925164Speter SET_SHARED_LIBRARY_MAPFILE='-Xlinker -version-script=[$]1' 24025164Speter fi 24125164Speter elif test "x$TOOLCHAIN_TYPE" = xclang; then 24225164Speter PICFLAG='' 24325164Speter C_FLAG_REORDER='' 24425164Speter CXX_FLAG_REORDER='' 24525164Speter 24625164Speter if test "x$OPENJDK_TARGET_OS" = xmacosx; then 24725164Speter # Linking is different on MacOSX 24825164Speter SHARED_LIBRARY_FLAGS="-dynamiclib -compatibility_version 1.0.0 -current_version 1.0.0 $PICFLAG" 24925164Speter SET_EXECUTABLE_ORIGIN='-Xlinker -rpath -Xlinker @loader_path/.' 25025164Speter SET_SHARED_LIBRARY_ORIGIN="$SET_EXECUTABLE_ORIGIN" 25125164Speter SET_SHARED_LIBRARY_NAME='-Xlinker -install_name -Xlinker @rpath/[$]1' 25225164Speter SET_SHARED_LIBRARY_MAPFILE='' 25325164Speter else 25425164Speter # Default works for linux, might work on other platforms as well. 25525164Speter SHARED_LIBRARY_FLAGS='-shared' 25625164Speter SET_EXECUTABLE_ORIGIN='-Xlinker -rpath -Xlinker \$$$$ORIGIN[$]1' 25725164Speter SET_SHARED_LIBRARY_ORIGIN="-Xlinker -z -Xlinker origin $SET_EXECUTABLE_ORIGIN" 25825164Speter SET_SHARED_LIBRARY_NAME='-Xlinker -soname=[$]1' 25925164Speter SET_SHARED_LIBRARY_MAPFILE='-Xlinker -version-script=[$]1' 26025164Speter fi 26125164Speter elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then 26225164Speter PICFLAG="-KPIC" 26325164Speter C_FLAG_REORDER='-xF' 26425164Speter CXX_FLAG_REORDER='-xF' 26525164Speter SHARED_LIBRARY_FLAGS="-G" 26625164Speter SET_EXECUTABLE_ORIGIN='-R\$$$$ORIGIN[$]1' 26725164Speter SET_SHARED_LIBRARY_ORIGIN="$SET_EXECUTABLE_ORIGIN" 26825164Speter SET_SHARED_LIBRARY_NAME='' 26925164Speter SET_SHARED_LIBRARY_MAPFILE='-M[$]1' 27025164Speter elif test "x$TOOLCHAIN_TYPE" = xxlc; then 27125164Speter PICFLAG="-qpic=large" 27225164Speter C_FLAG_REORDER='' 27325164Speter CXX_FLAG_REORDER='' 27425164Speter SHARED_LIBRARY_FLAGS="-qmkshrobj" 27525164Speter SET_EXECUTABLE_ORIGIN="" 27625164Speter SET_SHARED_LIBRARY_ORIGIN='' 27725164Speter SET_SHARED_LIBRARY_NAME='' 27825164Speter SET_SHARED_LIBRARY_MAPFILE='' 27925164Speter elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then 28025164Speter PICFLAG="" 28125164Speter C_FLAG_REORDER='' 28225164Speter CXX_FLAG_REORDER='' 28325164Speter SHARED_LIBRARY_FLAGS="-LD" 28425164Speter SET_EXECUTABLE_ORIGIN='' 28525164Speter SET_SHARED_LIBRARY_ORIGIN='' 28625164Speter SET_SHARED_LIBRARY_NAME='' 28725164Speter SET_SHARED_LIBRARY_MAPFILE='' 28825164Speter fi 28925164Speter 29025164Speter AC_SUBST(C_FLAG_REORDER) 29125164Speter AC_SUBST(CXX_FLAG_REORDER) 29225164Speter AC_SUBST(SET_EXECUTABLE_ORIGIN) 29325164Speter AC_SUBST(SET_SHARED_LIBRARY_ORIGIN) 29425164Speter AC_SUBST(SET_SHARED_LIBRARY_NAME) 29525164Speter AC_SUBST(SET_SHARED_LIBRARY_MAPFILE) 29625164Speter 29725164Speter if test "x$OPENJDK_TARGET_OS" = xsolaris; then 29825164Speter CFLAGS_JDK="${CFLAGS_JDK} -D__solaris__" 29925164Speter CXXFLAGS_JDK="${CXXFLAGS_JDK} -D__solaris__" 30025164Speter CFLAGS_JDKLIB_EXTRA='-xstrconst' 30125164Speter fi 30225164Speter # The (cross) compiler is now configured, we can now test capabilities 30325164Speter # of the target platform. 30425164Speter]) 30525164Speter 30625164Speter# Documentation on common flags used for solstudio in HIGHEST. 30725164Speter# 30825164Speter# WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be 30925164Speter# done with care, there are some assumptions below that need to 31025164Speter# be understood about the use of pointers, and IEEE behavior. 31125164Speter# 31225164Speter# -fns: Use non-standard floating point mode (not IEEE 754) 31325164Speter# -fsimple: Do some simplification of floating point arithmetic (not IEEE 754) 31425164Speter# -fsingle: Use single precision floating point with 'float' 31525164Speter# -xalias_level=basic: Assume memory references via basic pointer types do not alias 31625164Speter# (Source with excessing pointer casting and data access with mixed 31725164Speter# pointer types are not recommended) 31825164Speter# -xbuiltin=%all: Use intrinsic or inline versions for math/std functions 31925164Speter# (If you expect perfect errno behavior, do not use this) 32025164Speter# -xdepend: Loop data dependency optimizations (need -xO3 or higher) 32125164Speter# -xrestrict: Pointer parameters to functions do not overlap 32225164Speter# (Similar to -xalias_level=basic usage, but less obvious sometimes. 32325164Speter# If you pass in multiple pointers to the same data, do not use this) 32425164Speter# -xlibmil: Inline some library routines 32525164Speter# (If you expect perfect errno behavior, do not use this) 32625164Speter# -xlibmopt: Use optimized math routines (CURRENTLY DISABLED) 32725164Speter# (If you expect perfect errno behavior, do not use this) 32825164Speter# Can cause undefined external on Solaris 8 X86 on __sincos, removing for now 32925164Speter 33025164Speter # FIXME: this will never happen since sparc != sparcv9, ie 32 bit, which we don't build anymore. 33125164Speter # Bug? 33225216Sfsmp #if test "x$OPENJDK_TARGET_CPU" = xsparc; then 33325164Speter # CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s" 33425164Speter # CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s" 33525164Speter #fi 33625164Speter 33725204SfsmpAC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION], 33825204Sfsmp[ 33925216Sfsmp 34025164Speter ############################################################################### 34125164Speter # 34225164Speter # Setup the opt flags for different compilers 34325164Speter # and different operating systems. 34425164Speter # 34525164Speter 34625164Speter # FIXME: this was indirectly the old default, but just inherited. 34725164Speter # if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then 34825164Speter # C_FLAG_DEPS="-MMD -MF" 34925164Speter # fi 35025164Speter 35125164Speter # Generate make dependency files 35225164Speter if test "x$TOOLCHAIN_TYPE" = xgcc; then 35325164Speter C_FLAG_DEPS="-MMD -MF" 35425164Speter elif test "x$TOOLCHAIN_TYPE" = xclang; then 35525164Speter C_FLAG_DEPS="-MMD -MF" 35625164Speter elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then 35725164Speter C_FLAG_DEPS="-xMMD -xMF" 35825164Speter elif test "x$TOOLCHAIN_TYPE" = xxlc; then 35925164Speter C_FLAG_DEPS="-qmakedep=gcc -MF" 36025164Speter fi 36125164Speter CXX_FLAG_DEPS="$C_FLAG_DEPS" 36225164Speter AC_SUBST(C_FLAG_DEPS) 36325164Speter AC_SUBST(CXX_FLAG_DEPS) 36425164Speter 36525164Speter # Debug symbols 36625164Speter if test "x$TOOLCHAIN_TYPE" = xgcc; then 36725164Speter if test "x$OPENJDK_TARGET_CPU_BITS" = "x64" && test "x$DEBUG_LEVEL" = "xfastdebug"; then 36825164Speter # reduce from default "-g2" option to save space 36925164Speter CFLAGS_DEBUG_SYMBOLS="-g1" 37025164Speter CXXFLAGS_DEBUG_SYMBOLS="-g1" 37125164Speter else 37225164Speter CFLAGS_DEBUG_SYMBOLS="-g" 37325164Speter CXXFLAGS_DEBUG_SYMBOLS="-g" 37425164Speter fi 37525164Speter elif test "x$TOOLCHAIN_TYPE" = xclang; then 37625164Speter CFLAGS_DEBUG_SYMBOLS="-g" 37725164Speter CXXFLAGS_DEBUG_SYMBOLS="-g" 37825164Speter elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then 37925164Speter CFLAGS_DEBUG_SYMBOLS="-g -xs" 38025164Speter # FIXME: likely a bug, this disables debug symbols rather than enables them 38125164Speter CXXFLAGS_DEBUG_SYMBOLS="-g0 -xs" 38225164Speter elif test "x$TOOLCHAIN_TYPE" = xxlc; then 38325164Speter CFLAGS_DEBUG_SYMBOLS="-g" 38425164Speter CXXFLAGS_DEBUG_SYMBOLS="-g" 38525164Speter fi 38625164Speter AC_SUBST(CFLAGS_DEBUG_SYMBOLS) 38725164Speter AC_SUBST(CXXFLAGS_DEBUG_SYMBOLS) 38825164Speter 38925164Speter # bounds, memory and behavior checking options 39025164Speter if test "x$TOOLCHAIN_TYPE" = xgcc; then 39125164Speter case $DEBUG_LEVEL in 39225164Speter release ) 39325164Speter # no adjustment 39425164Speter ;; 39525164Speter fastdebug ) 39625164Speter # no adjustment 39725164Speter ;; 39825164Speter slowdebug ) 39925164Speter # Add runtime stack smashing and undefined behavior checks. 40025164Speter # Not all versions of gcc support -fstack-protector 40125164Speter STACK_PROTECTOR_CFLAG="-fstack-protector-all" 40225164Speter FLAGS_COMPILER_CHECK_ARGUMENTS([$STACK_PROTECTOR_CFLAG], [], [STACK_PROTECTOR_CFLAG=""]) 40325164Speter 40425164Speter CFLAGS_DEBUG_OPTIONS="$STACK_PROTECTOR_CFLAG --param ssp-buffer-size=1" 40525164Speter CXXFLAGS_DEBUG_OPTIONS="$STACK_PROTECTOR_CFLAG --param ssp-buffer-size=1" 40625164Speter ;; 40725164Speter esac 40825164Speter fi 40925164Speter 41025164Speter # Optimization levels 41125164Speter if test "x$TOOLCHAIN_TYPE" = xsolstudio; then 41225164Speter CC_HIGHEST="$CC_HIGHEST -fns -fsimple -fsingle -xbuiltin=%all -xdepend -xrestrict -xlibmil" 41325164Speter 41425164Speter if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then 41525164Speter # FIXME: seems we always set -xregs=no%frameptr; put it elsewhere more global? 41625164Speter C_O_FLAG_HIGHEST="-xO4 -Wu,-O4~yz $CC_HIGHEST -xalias_level=basic -xregs=no%frameptr" 41725164Speter C_O_FLAG_HI="-xO4 -Wu,-O4~yz -xregs=no%frameptr" 41825164Speter C_O_FLAG_NORM="-xO2 -Wu,-O2~yz -xregs=no%frameptr" 41925164Speter C_O_FLAG_DEBUG="-xregs=no%frameptr" 42025164Speter C_O_FLAG_NONE="-xregs=no%frameptr" 42125164Speter CXX_O_FLAG_HIGHEST="-xO4 -Qoption ube -O4~yz $CC_HIGHEST -xregs=no%frameptr" 42225164Speter CXX_O_FLAG_HI="-xO4 -Qoption ube -O4~yz -xregs=no%frameptr" 42325164Speter CXX_O_FLAG_NORM="-xO2 -Qoption ube -O2~yz -xregs=no%frameptr" 42425164Speter CXX_O_FLAG_DEBUG="-xregs=no%frameptr" 42525164Speter CXX_O_FLAG_NONE="-xregs=no%frameptr" 42625164Speter if test "x$OPENJDK_TARGET_CPU_BITS" = "x32"; then 42725164Speter C_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST -xchip=pentium" 42825164Speter CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_HIGHEST -xchip=pentium" 42925164Speter fi 43025164Speter elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then 43125164Speter C_O_FLAG_HIGHEST="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0 $CC_HIGHEST -xalias_level=basic -xprefetch=auto,explicit -xchip=ultra" 43225164Speter C_O_FLAG_HI="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0" 43325164Speter C_O_FLAG_NORM="-xO2 -Wc,-Qrm-s -Wc,-Qiselect-T0" 43425164Speter C_O_FLAG_DEBUG="" 43525164Speter C_O_FLAG_NONE="" 43625164Speter CXX_O_FLAG_HIGHEST="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra" 43725164Speter CXX_O_FLAG_HI="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0" 43825164Speter CXX_O_FLAG_NORM="-xO2 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0" 43925164Speter C_O_FLAG_DEBUG="" 44025164Speter CXX_O_FLAG_NONE="" 44125164Speter fi 44225164Speter else 44325164Speter # The remaining toolchains share opt flags between CC and CXX; 44425164Speter # setup for C and duplicate afterwards. 44525164Speter if test "x$TOOLCHAIN_TYPE" = xgcc; then 44625164Speter if test "x$OPENJDK_TARGET_OS" = xmacosx; then 44725164Speter # On MacOSX we optimize for size, something 44825164Speter # we should do for all platforms? 44925164Speter C_O_FLAG_HIGHEST="-Os" 45025164Speter C_O_FLAG_HI="-Os" 45125164Speter C_O_FLAG_NORM="-Os" 45225164Speter else 45325164Speter C_O_FLAG_HIGHEST="-O3" 45425164Speter C_O_FLAG_HI="-O3" 45525164Speter C_O_FLAG_NORM="-O2" 45625164Speter fi 45725164Speter C_O_FLAG_DEBUG="-O0" 45825164Speter C_O_FLAG_NONE="-O0" 45925164Speter elif test "x$TOOLCHAIN_TYPE" = xclang; then 46025164Speter if test "x$OPENJDK_TARGET_OS" = xmacosx; then 46125164Speter # On MacOSX we optimize for size, something 46225164Speter # we should do for all platforms? 46325164Speter C_O_FLAG_HIGHEST="-Os" 46425164Speter C_O_FLAG_HI="-Os" 46525164Speter C_O_FLAG_NORM="-Os" 46625164Speter else 46725164Speter C_O_FLAG_HIGHEST="-O3" 46825164Speter C_O_FLAG_HI="-O3" 46925164Speter C_O_FLAG_NORM="-O2" 47025164Speter fi 47125164Speter C_O_FLAG_DEBUG="-O0" 47225164Speter C_O_FLAG_NONE="-O0" 47325164Speter elif test "x$TOOLCHAIN_TYPE" = xxlc; then 47425164Speter C_O_FLAG_HIGHEST="-O3" 47525164Speter C_O_FLAG_HI="-O3 -qstrict" 47625164Speter C_O_FLAG_NORM="-O2" 47725164Speter C_O_FLAG_DEBUG="-qnoopt" 47825164Speter C_O_FLAG_NONE="-qnoop" 47925164Speter elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then 48025164Speter C_O_FLAG_HIGHEST="-O2" 48125164Speter C_O_FLAG_HI="-O1" 48225164Speter C_O_FLAG_NORM="-O1" 48325164Speter C_O_FLAG_DEBUG="-Od" 48425164Speter C_O_FLAG_NONE="-Od" 48525164Speter fi 48625164Speter CXX_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST" 48725164Speter CXX_O_FLAG_HI="$C_O_FLAG_HI" 48825164Speter CXX_O_FLAG_NORM="$C_O_FLAG_NORM" 48925164Speter CXX_O_FLAG_DEBUG="$C_O_FLAG_DEBUG" 49025164Speter CXX_O_FLAG_NONE="$C_O_FLAG_NONE" 49125164Speter fi 49225164Speter 49325164Speter # Adjust optimization flags according to debug level. 49425164Speter case $DEBUG_LEVEL in 49525164Speter release ) 49625164Speter # no adjustment 49725164Speter ;; 49825164Speter fastdebug ) 49925164Speter # Not quite so much optimization 50025164Speter C_O_FLAG_HI="$C_O_FLAG_NORM" 50125164Speter CXX_O_FLAG_HI="$CXX_O_FLAG_NORM" 50225164Speter ;; 50325164Speter slowdebug ) 50425164Speter # Disable optimization 50525164Speter C_O_FLAG_HIGHEST="$C_O_FLAG_DEBUG" 50625164Speter C_O_FLAG_HI="$C_O_FLAG_DEBUG" 50725164Speter C_O_FLAG_NORM="$C_O_FLAG_DEBUG" 50825164Speter CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_DEBUG" 50925164Speter CXX_O_FLAG_HI="$CXX_O_FLAG_DEBUG" 51025164Speter CXX_O_FLAG_NORM="$CXX_O_FLAG_DEBUG" 51125164Speter ;; 51225164Speter esac 51325164Speter 51425164Speter AC_SUBST(C_O_FLAG_HIGHEST) 51525164Speter AC_SUBST(C_O_FLAG_HI) 51625164Speter AC_SUBST(C_O_FLAG_NORM) 51725164Speter AC_SUBST(C_O_FLAG_DEBUG) 51825164Speter AC_SUBST(C_O_FLAG_NONE) 51925164Speter AC_SUBST(CXX_O_FLAG_HIGHEST) 52025164Speter AC_SUBST(CXX_O_FLAG_HI) 52125164Speter AC_SUBST(CXX_O_FLAG_NORM) 52225164Speter AC_SUBST(CXX_O_FLAG_DEBUG) 52325164Speter AC_SUBST(CXX_O_FLAG_NONE) 52425164Speter]) 52525164Speter 52625164SpeterAC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK], 52725164Speter[ 52825164Speter # Special extras... 52925164Speter if test "x$TOOLCHAIN_TYPE" = xsolstudio; then 53025164Speter if test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then 53125164Speter CFLAGS_JDKLIB_EXTRA="${CFLAGS_JDKLIB_EXTRA} -xregs=no%appl" 53225164Speter CXXFLAGS_JDKLIB_EXTRA="${CXXFLAGS_JDKLIB_EXTRA} -xregs=no%appl" 53325164Speter fi 53425164Speter CFLAGS_JDKLIB_EXTRA="${CFLAGS_JDKLIB_EXTRA} -errtags=yes -errfmt" 53525164Speter CXXFLAGS_JDKLIB_EXTRA="${CXXFLAGS_JDKLIB_EXTRA} -errtags=yes -errfmt" 53625164Speter elif test "x$TOOLCHAIN_TYPE" = xxlc; then 53725164Speter CFLAGS_JDK="${CFLAGS_JDK} -qchars=signed -qfullpath -qsaveopt" 53825164Speter CXXFLAGS_JDK="${CXXFLAGS_JDK} -qchars=signed -qfullpath -qsaveopt" 53925164Speter fi 54025164Speter 54125164Speter CFLAGS_JDK="${CFLAGS_JDK} $EXTRA_CFLAGS" 54225164Speter CXXFLAGS_JDK="${CXXFLAGS_JDK} $EXTRA_CXXFLAGS" 54325164Speter LDFLAGS_JDK="${LDFLAGS_JDK} $EXTRA_LDFLAGS" 54425164Speter 54525164Speter ############################################################################### 54625164Speter # 54725164Speter # Now setup the CFLAGS and LDFLAGS for the JDK build. 54825164Speter # Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build. 54925164Speter # 55025164Speter 55125164Speter # Setup compiler/platform specific flags into 55225164Speter # CFLAGS_JDK - C Compiler flags 55325164Speter # CXXFLAGS_JDK - C++ Compiler flags 55425164Speter # COMMON_CCXXFLAGS_JDK - common to C and C++ 55525164Speter if test "x$TOOLCHAIN_TYPE" = xgcc; then 55625164Speter if test "x$OPENJDK_TARGET_CPU" = xx86; then 55725164Speter # Force compatibility with i586 on 32 bit intel platforms. 55825164Speter COMMON_CCXXFLAGS="${COMMON_CCXXFLAGS} -march=i586" 55925164Speter fi 56025164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -Wall -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \ 56125164Speter -pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE" 56225164Speter case $OPENJDK_TARGET_CPU_ARCH in 56325164Speter arm ) 56425164Speter # on arm we don't prevent gcc to omit frame pointer but do prevent strict aliasing 56525164Speter CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing" 56625164Speter ;; 56725164Speter ppc ) 56825164Speter # on ppc we don't prevent gcc to omit frame pointer but do prevent strict aliasing 56925164Speter CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing" 57025164Speter ;; 57125164Speter * ) 57225164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer" 57325164Speter CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing" 57425164Speter ;; 57525164Speter esac 57625164Speter elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then 57725164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS" 57825164Speter if test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then 57925164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_TARGET_CPU_LEGACY_LIB" 58025164Speter fi 58125164Speter 58225164Speter CFLAGS_JDK="$CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal" 58325164Speter CXXFLAGS_JDK="$CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib" 58425164Speter elif test "x$TOOLCHAIN_TYPE" = xxlc; then 58525164Speter CFLAGS_JDK="$CFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC" 58625164Speter CXXFLAGS_JDK="$CXXFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC" 58725164Speter elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then 58825164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK \ 58925164Speter -Zi -MD -Zc:wchar_t- -W3 -wd4800 \ 59025164Speter -DWIN32_LEAN_AND_MEAN \ 59125164Speter -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \ 59225164Speter -D_WINSOCK_DEPRECATED_NO_WARNINGS \ 59325164Speter -DWIN32 -DIAL" 59425164Speter if test "x$OPENJDK_TARGET_CPU" = xx86_64; then 59525164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_AMD64_ -Damd64" 59625164Speter else 59725164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_X86_ -Dx86" 59825164Speter fi 59925164Speter # If building with Visual Studio 2010, we can still use _STATIC_CPPLIB to 60025164Speter # avoid bundling msvcpNNN.dll. Doesn't work with newer versions of visual 60125164Speter # studio. 60225164Speter if test "x$TOOLCHAIN_VERSION" = "x2010"; then 60325164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK \ 60425164Speter -D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB" 60525164Speter fi 60625164Speter fi 60725164Speter 60825164Speter ############################################################################### 60925164Speter 61025164Speter # Adjust flags according to debug level. 61125164Speter case $DEBUG_LEVEL in 61225164Speter fastdebug | slowdebug ) 61325164Speter CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS $CFLAGS_DEBUG_OPTIONS" 61425164Speter CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS $CXXFLAGS_DEBUG_OPTIONS" 61525164Speter JAVAC_FLAGS="$JAVAC_FLAGS -g" 61625164Speter ;; 61725164Speter release ) 61825164Speter ;; 61925164Speter * ) 62025164Speter AC_MSG_ERROR([Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL]) 62125164Speter ;; 62225164Speter esac 62325164Speter 62425164Speter # Setup LP64 62525164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK $ADD_LP64" 62625164Speter 62725164Speter # Set some common defines. These works for all compilers, but assume 62825164Speter # -D is universally accepted. 62925164Speter 63025164Speter # Setup endianness 63125164Speter if test "x$OPENJDK_TARGET_CPU_ENDIAN" = xlittle; then 63225164Speter # The macro _LITTLE_ENDIAN needs to be defined the same to avoid the 63325164Speter # Sun C compiler warning message: warning: macro redefined: _LITTLE_ENDIAN 63425164Speter # (The Solaris X86 system defines this in file /usr/include/sys/isa_defs.h). 63525164Speter # Note: -Dmacro is the same as #define macro 1 63625164Speter # -Dmacro= is the same as #define macro 63725164Speter if test "x$OPENJDK_TARGET_OS" = xsolaris; then 63825164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN=" 63925164Speter else 64025164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN" 64125164Speter fi 64225164Speter else 64325164Speter # Same goes for _BIG_ENDIAN. Do we really need to set *ENDIAN on Solaris if they 64425164Speter # are defined in the system? 64525164Speter if test "x$OPENJDK_TARGET_OS" = xsolaris; then 64625164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN=" 64725164Speter else 64825164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN" 64925164Speter fi 65025164Speter fi 65125164Speter 65225164Speter # Setup target OS define. Use OS target name but in upper case. 65325164Speter OPENJDK_TARGET_OS_UPPERCASE=`$ECHO $OPENJDK_TARGET_OS | $TR 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` 65425164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D$OPENJDK_TARGET_OS_UPPERCASE" 65525164Speter 65625164Speter # Setup target CPU 65725164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DARCH='\"$OPENJDK_TARGET_CPU_LEGACY\"' -D$OPENJDK_TARGET_CPU_LEGACY" 65825164Speter 65925164Speter # Setup debug/release defines 66025164Speter if test "x$DEBUG_LEVEL" = xrelease; then 66125164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DNDEBUG" 66225164Speter if test "x$OPENJDK_TARGET_OS" = xsolaris; then 66325164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DTRIMMED" 66425164Speter fi 66525164Speter else 66625164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DDEBUG" 66725164Speter fi 66825164Speter 66925164Speter # Set some additional per-OS defines. 67025164Speter if test "x$OPENJDK_TARGET_OS" = xmacosx; then 67125164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT" 67225164Speter elif test "x$OPENJDK_TARGET_OS" = xaix; then 67325164Speter # FIXME: PPC64 should not be here. 67425164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DPPC64" 67525164Speter elif test "x$OPENJDK_TARGET_OS" = xbsd; then 67625164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE" 67725164Speter fi 67825164Speter 67925164Speter # Additional macosx handling 68025164Speter if test "x$OPENJDK_TARGET_OS" = xmacosx; then 68125164Speter # Setting these parameters makes it an error to link to macosx APIs that are 68225164Speter # newer than the given OS version and makes the linked binaries compatible 68325164Speter # even if built on a newer version of the OS. 68425164Speter # The expected format is X.Y.Z 68525164Speter MACOSX_VERSION_MIN=10.7.0 68625164Speter AC_SUBST(MACOSX_VERSION_MIN) 68725164Speter 68825164Speter # The macro takes the version with no dots, ex: 1070 68925164Speter # Let the flags variables get resolved in make for easier override on make 69025164Speter # command line. 69125164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MIN)) -mmacosx-version-min=\$(MACOSX_VERSION_MIN)" 69225164Speter LDFLAGS_JDK="$LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)" 69325164Speter fi 69425164Speter 69525164Speter # Setup some hard coded includes 69625164Speter COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK \ 69725164Speter -I${JDK_TOPDIR}/src/java.base/share/native/include \ 69825164Speter -I${JDK_TOPDIR}/src/java.base/$OPENJDK_TARGET_OS/native/include \ 69925164Speter -I${JDK_TOPDIR}/src/java.base/$OPENJDK_TARGET_OS_TYPE/native/include \ 70025164Speter -I${JDK_TOPDIR}/src/java.base/share/native/libjava \ 70125164Speter -I${JDK_TOPDIR}/src/java.base/$OPENJDK_TARGET_OS_TYPE/native/libjava" 70225164Speter 70325164Speter # The shared libraries are compiled using the picflag. 70425164Speter CFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA" 70525164Speter CXXFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA" 70625164Speter 70725164Speter # Executable flags 70825164Speter CFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK" 70925164Speter CXXFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK" 71025164Speter 71125164Speter AC_SUBST(CFLAGS_JDKLIB) 71225164Speter AC_SUBST(CFLAGS_JDKEXE) 71325164Speter AC_SUBST(CXXFLAGS_JDKLIB) 71425164Speter AC_SUBST(CXXFLAGS_JDKEXE) 71525164Speter 71625164Speter # Flags for compiling test libraries 71725164Speter CFLAGS_TESTLIB="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA" 71825164Speter CXXFLAGS_TESTLIB="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA" 71925164Speter 72025164Speter # Flags for compiling test executables 72125164Speter CFLAGS_TESTEXE="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK" 72225164Speter CXXFLAGS_TESTEXE="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK" 72325164Speter 72425164Speter AC_SUBST(CFLAGS_TESTLIB) 72525164Speter AC_SUBST(CFLAGS_TESTEXE) 72625164Speter AC_SUBST(CXXFLAGS_TESTLIB) 72725164Speter AC_SUBST(CXXFLAGS_TESTEXE) 72825164Speter 72925164Speter # Setup LDFLAGS et al. 73025164Speter # 73125164Speter 73225164Speter # Now this is odd. The JDK native libraries have to link against libjvm.so 73325164Speter # On 32-bit machines there is normally two distinct libjvm.so:s, client and server. 73425164Speter # Which should we link to? Are we lucky enough that the binary api to the libjvm.so library 73525164Speter # is identical for client and server? Yes. Which is picked at runtime (client or server)? 73625164Speter # Neither, since the chosen libjvm.so has already been loaded by the launcher, all the following 73725164Speter # libraries will link to whatever is in memory. Yuck. 73825164Speter # 73925164Speter # Thus we offer the compiler to find libjvm.so first in server then in client. It works. Ugh. 74025164Speter if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then 74125164Speter LDFLAGS_JDK="$LDFLAGS_JDK -nologo -opt:ref -incremental:no" 74225164Speter if test "x$OPENJDK_TARGET_CPU_BITS" = "x32"; then 74325164Speter LDFLAGS_JDK="$LDFLAGS_JDK -safeseh" 74425164Speter fi 74525164Speter # TODO: make -debug optional "--disable-full-debug-symbols" 74625164Speter LDFLAGS_JDK="$LDFLAGS_JDK -debug" 74725164Speter elif test "x$TOOLCHAIN_TYPE" = xgcc; then 74825164Speter # If this is a --hash-style=gnu system, use --hash-style=both, why? 74925164Speter # We have previously set HAS_GNU_HASH if this is the case 75025164Speter if test -n "$HAS_GNU_HASH"; then 75125164Speter LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker --hash-style=both" 75225164Speter fi 75325164Speter if test "x$OPENJDK_TARGET_OS" = xlinux; then 75425164Speter # And since we now know that the linker is gnu, then add -z defs, to forbid 75525164Speter # undefined symbols in object files. 75625164Speter LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -z -Xlinker defs" 75725164Speter case $DEBUG_LEVEL in 75825164Speter release ) 75925164Speter # tell linker to optimize libraries. 76025164Speter # Should this be supplied to the OSS linker as well? 76125164Speter LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -O1" 76225164Speter ;; 76325164Speter slowdebug ) 76425164Speter if test "x$HAS_LINKER_NOW" = "xtrue"; then 76525164Speter # do relocations at load 76625164Speter LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_NOW_FLAG" 76725164Speter LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_NOW_FLAG" 76825164Speter fi 76925164Speter if test "x$HAS_LINKER_RELRO" = "xtrue"; then 77025164Speter # mark relocations read only 77125164Speter LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_RELRO_FLAG" 77225164Speter LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_RELRO_FLAG" 77325164Speter fi 77425164Speter ;; 77525164Speter fastdebug ) 77625164Speter if test "x$HAS_LINKER_RELRO" = "xtrue"; then 77725164Speter # mark relocations read only 77825164Speter LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_RELRO_FLAG" 77925164Speter LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_RELRO_FLAG" 78025164Speter fi 78125164Speter ;; 78225164Speter * ) 78325164Speter AC_MSG_ERROR([Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL]) 78425164Speter ;; 78525164Speter esac 78625164Speter fi 78725164Speter elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then 78825164Speter LDFLAGS_JDK="$LDFLAGS_JDK -z defs -xildoff -ztext" 78925164Speter LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK -norunpath -xnolib" 79025164Speter elif test "x$TOOLCHAIN_TYPE" = xxlc; then 79125164Speter LDFLAGS_JDK="${LDFLAGS_JDK} -brtl -bnolibpath -bexpall -bernotok" 79225164Speter fi 79325164Speter 79425164Speter # Customize LDFLAGS for executables 79525164Speter 79625164Speter LDFLAGS_JDKEXE="${LDFLAGS_JDK}" 79725164Speter 79825164Speter if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then 79925164Speter if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then 80025164Speter LDFLAGS_STACK_SIZE=1048576 80125164Speter else 80225164Speter LDFLAGS_STACK_SIZE=327680 80325164Speter fi 80425164Speter LDFLAGS_JDKEXE="${LDFLAGS_JDKEXE} /STACK:$LDFLAGS_STACK_SIZE" 80525164Speter elif test "x$OPENJDK_TARGET_OS" = xlinux; then 80625164Speter LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE -Xlinker --allow-shlib-undefined" 80725164Speter fi 80825164Speter 80925164Speter # Customize LDFLAGS for libs 81025164Speter LDFLAGS_JDKLIB="${LDFLAGS_JDK}" 81125164Speter 81225164Speter if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then 81325164Speter LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -dll -libpath:${OUTPUT_ROOT}/support/modules_libs/java.base" 81425164Speter JDKLIB_LIBS="" 81525164Speter else 81625164Speter LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} ${SHARED_LIBRARY_FLAGS} \ 81725164Speter -L${OUTPUT_ROOT}/support/modules_libs/java.base${OPENJDK_TARGET_CPU_LIBDIR}" 81825164Speter 81925164Speter # On some platforms (mac) the linker warns about non existing -L dirs. 82025164Speter # Add server first if available. Linking aginst client does not always produce the same results. 82125164Speter # Only add client dir if client is being built. Add minimal (note not minimal1) if only building minimal1. 82225164Speter # Default to server for other variants. 82325164Speter if test "x$JVM_VARIANT_SERVER" = xtrue; then 82425164Speter LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -L${OUTPUT_ROOT}/support/modules_libs/java.base${OPENJDK_TARGET_CPU_LIBDIR}/server" 82525164Speter elif test "x$JVM_VARIANT_CLIENT" = xtrue; then 82625164Speter LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -L${OUTPUT_ROOT}/support/modules_libs/java.base${OPENJDK_TARGET_CPU_LIBDIR}/client" 82725164Speter elif test "x$JVM_VARIANT_MINIMAL1" = xtrue; then 82825164Speter LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -L${OUTPUT_ROOT}/support/modules_libs/java.base${OPENJDK_TARGET_CPU_LIBDIR}/minimal" 82925164Speter else 83025164Speter LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -L${OUTPUT_ROOT}/support/modules_libs/java.base${OPENJDK_TARGET_CPU_LIBDIR}/server" 83125164Speter fi 83225164Speter 83325164Speter JDKLIB_LIBS="-ljava -ljvm" 83425164Speter if test "x$TOOLCHAIN_TYPE" = xsolstudio; then 83525164Speter JDKLIB_LIBS="$JDKLIB_LIBS -lc" 83625164Speter fi 83725164Speter fi 83825164Speter 83925164Speter AC_SUBST(LDFLAGS_JDKLIB) 84025164Speter AC_SUBST(LDFLAGS_JDKEXE) 84125164Speter AC_SUBST(JDKLIB_LIBS) 84225164Speter AC_SUBST(JDKEXE_LIBS) 84325164Speter AC_SUBST(LDFLAGS_CXX_JDK) 84425164Speter 84525164Speter LDFLAGS_TESTLIB="$LDFLAGS_JDKLIB" 84625164Speter LDFLAGS_TESTEXE="$LDFLAGS_JDKEXE" 84725164Speter 84825164Speter AC_SUBST(LDFLAGS_TESTLIB) 84925164Speter AC_SUBST(LDFLAGS_TESTEXE) 85025164Speter]) 85125164Speter 85225164Speter# FLAGS_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE], 85325164Speter# [RUN-IF-FALSE]) 85425164Speter# ------------------------------------------------------------ 85525164Speter# Check that the c and c++ compilers support an argument 85625164SpeterAC_DEFUN([FLAGS_COMPILER_CHECK_ARGUMENTS], 85725164Speter[ 85825164Speter AC_MSG_CHECKING([if compiler supports "$1"]) 85925164Speter supports=yes 86025164Speter 86125164Speter saved_cflags="$CFLAGS" 86225164Speter CFLAGS="$CFLAGS $1" 86325164Speter AC_LANG_PUSH([C]) 86425164Speter AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int i;]])], [], 86525164Speter [supports=no]) 86625164Speter AC_LANG_POP([C]) 86725164Speter CFLAGS="$saved_cflags" 86825164Speter 86925164Speter saved_cxxflags="$CXXFLAGS" 87025164Speter CXXFLAGS="$CXXFLAG $1" 87125164Speter AC_LANG_PUSH([C++]) 87225164Speter AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int i;]])], [], 87325164Speter [supports=no]) 87425164Speter AC_LANG_POP([C++]) 87525164Speter CXXFLAGS="$saved_cxxflags" 87625164Speter 87725164Speter AC_MSG_RESULT([$supports]) 87825164Speter if test "x$supports" = "xyes" ; then 87925164Speter m4_ifval([$2], [$2], [:]) 88025164Speter else 88125164Speter m4_ifval([$3], [$3], [:]) 88225164Speter fi 88325164Speter]) 88425164Speter 88525164Speter# FLAGS_LINKER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE], 88625164Speter# [RUN-IF-FALSE]) 88725164Speter# ------------------------------------------------------------ 88825164Speter# Check that the linker support an argument 88925164SpeterAC_DEFUN([FLAGS_LINKER_CHECK_ARGUMENTS], 89025164Speter[ 89125164Speter AC_MSG_CHECKING([if linker supports "$1"]) 89225164Speter supports=yes 89325164Speter 89425164Speter saved_ldflags="$LDFLAGS" 89525164Speter LDFLAGS="$LDFLAGS $1" 89625164Speter AC_LANG_PUSH([C]) 89725164Speter AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])], 89825164Speter [], [supports=no]) 89925164Speter AC_LANG_POP([C]) 90025164Speter LDFLAGS="$saved_ldflags" 90125164Speter 90225164Speter AC_MSG_RESULT([$supports]) 90325164Speter if test "x$supports" = "xyes" ; then 90425164Speter m4_ifval([$2], [$2], [:]) 90525164Speter else 90625164Speter m4_ifval([$3], [$3], [:]) 90725164Speter fi 90825164Speter]) 90925164Speter 91025164SpeterAC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_MISC], 91125164Speter[ 91225164Speter # Some Zero and Shark settings. 91325164Speter # ZERO_ARCHFLAG tells the compiler which mode to build for 91425164Speter case "${OPENJDK_TARGET_CPU}" in 91525164Speter s390) 91625164Speter ZERO_ARCHFLAG="${COMPILER_TARGET_BITS_FLAG}31" 91725164Speter ;; 91825164Speter *) 91925164Speter ZERO_ARCHFLAG="${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}" 92025164Speter esac 92125164Speter FLAGS_COMPILER_CHECK_ARGUMENTS([$ZERO_ARCHFLAG], [], [ZERO_ARCHFLAG=""]) 92225164Speter AC_SUBST(ZERO_ARCHFLAG) 92325164Speter 92425164Speter # Check that the compiler supports -mX (or -qX on AIX) flags 92525164Speter # Set COMPILER_SUPPORTS_TARGET_BITS_FLAG to 'true' if it does 92625164Speter FLAGS_COMPILER_CHECK_ARGUMENTS([${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}], 92725164Speter [COMPILER_SUPPORTS_TARGET_BITS_FLAG=true], 92825164Speter [COMPILER_SUPPORTS_TARGET_BITS_FLAG=false]) 92925164Speter AC_SUBST(COMPILER_SUPPORTS_TARGET_BITS_FLAG) 93025164Speter 93125164Speter AC_ARG_ENABLE([warnings-as-errors], [AS_HELP_STRING([--disable-warnings-as-errors], 93225164Speter [do not consider native warnings to be an error @<:@enabled@:>@])]) 93325164Speter 93425164Speter AC_MSG_CHECKING([if native warnings are errors]) 93525164Speter if test "x$enable_warnings_as_errors" = "xyes"; then 93625164Speter AC_MSG_RESULT([yes (explicitely set)]) 93725164Speter WARNINGS_AS_ERRORS=true 93825164Speter elif test "x$enable_warnings_as_errors" = "xno"; then 93925164Speter AC_MSG_RESULT([no]) 94025164Speter WARNINGS_AS_ERRORS=false 94125164Speter elif test "x$enable_warnings_as_errors" = "x"; then 94225164Speter AC_MSG_RESULT([yes (default)]) 94325164Speter WARNINGS_AS_ERRORS=true 94425164Speter else 94525164Speter AC_MSG_ERROR([--enable-warnings-as-errors accepts no argument]) 94625164Speter fi 94725164Speter 94825164Speter if test "x$WARNINGS_AS_ERRORS" = "xfalse"; then 94925164Speter # Set legacy hotspot variable 95025164Speter HOTSPOT_SET_WARNINGS_AS_ERRORS="WARNINGS_ARE_ERRORS=" 95125164Speter else 95225164Speter HOTSPOT_SET_WARNINGS_AS_ERRORS="" 95325164Speter fi 95425164Speter 95525164Speter AC_SUBST(WARNINGS_AS_ERRORS) 95625164Speter AC_SUBST(HOTSPOT_SET_WARNINGS_AS_ERRORS) 95725164Speter 95825164Speter case "${TOOLCHAIN_TYPE}" in 95925164Speter microsoft) 96025164Speter DISABLE_WARNING_PREFIX="-wd" 96125164Speter CFLAGS_WARNINGS_ARE_ERRORS="-WX" 96225164Speter ;; 96325164Speter solstudio) 96425164Speter DISABLE_WARNING_PREFIX="-erroff=" 96525164Speter CFLAGS_WARNINGS_ARE_ERRORS="-errtags -errwarn=%all" 96625164Speter ;; 96725164Speter gcc) 96825164Speter # Prior to gcc 4.4, a -Wno-X where X is unknown for that version of gcc will cause an error 96925164Speter FLAGS_COMPILER_CHECK_ARGUMENTS([-Wno-this-is-a-warning-that-do-not-exist], 97025164Speter [GCC_CAN_DISABLE_WARNINGS=true], 97125164Speter [GCC_CAN_DISABLE_WARNINGS=false] 97225164Speter ) 97325164Speter if test "x$GCC_CAN_DISABLE_WARNINGS" = "xtrue"; then 97425164Speter DISABLE_WARNING_PREFIX="-Wno-" 97525164Speter else 97625164Speter DISABLE_WARNING_PREFIX= 97725164Speter fi 97825164Speter CFLAGS_WARNINGS_ARE_ERRORS="-Werror" 97925164Speter # Repeate the check for the BUILD_CC 98025164Speter CC_OLD="$CC" 98125164Speter CC="$BUILD_CC" 98225164Speter FLAGS_COMPILER_CHECK_ARGUMENTS([-Wno-this-is-a-warning-that-do-not-exist], 98325164Speter [BUILD_CC_CAN_DISABLE_WARNINGS=true], 98425164Speter [BUILD_CC_CAN_DISABLE_WARNINGS=false] 98525164Speter ) 98625164Speter if test "x$BUILD_CC_CAN_DISABLE_WARNINGS" = "xtrue"; then 98725164Speter BUILD_CC_DISABLE_WARNING_PREFIX="-Wno-" 98825164Speter else 98925164Speter BUILD_CC_DISABLE_WARNING_PREFIX= 99025164Speter fi 99125164Speter CC="$CC_OLD" 99225164Speter ;; 99325164Speter clang) 99425164Speter DISABLE_WARNING_PREFIX="-Wno-" 99525164Speter CFLAGS_WARNINGS_ARE_ERRORS="-Werror" 99625164Speter ;; 99725164Speter esac 99825164Speter AC_SUBST(DISABLE_WARNING_PREFIX) 99925164Speter AC_SUBST(CFLAGS_WARNINGS_ARE_ERRORS) 100025164Speter]) 100125164Speter