flags.m4 revision 1235:281f68758113
1190391Ssam# 2190391Ssam# Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved. 3190391Ssam# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4190391Ssam# 5190391Ssam# This code is free software; you can redistribute it and/or modify it 6190391Ssam# under the terms of the GNU General Public License version 2 only, as 7190391Ssam# published by the Free Software Foundation. Oracle designates this 8190391Ssam# particular file as subject to the "Classpath" exception as provided 9190391Ssam# by Oracle in the LICENSE file that accompanied this code. 10190391Ssam# 11190391Ssam# This code is distributed in the hope that it will be useful, but WITHOUT 12190391Ssam# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13190391Ssam# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14190391Ssam# version 2 for more details (a copy is included in the LICENSE file that 15190391Ssam# accompanied this code). 16190391Ssam# 17190391Ssam# You should have received a copy of the GNU General Public License version 18190391Ssam# 2 along with this work; if not, write to the Free Software Foundation, 19190391Ssam# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20190391Ssam# 21190391Ssam# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22190391Ssam# or visit www.oracle.com if you need additional information or have any 23190391Ssam# questions. 24190391Ssam# 25190391Ssam 26190391SsamAC_DEFUN_ONCE([FLAGS_SETUP_INIT_FLAGS], 27190391Ssam[ 28190391Ssam # Option used to tell the compiler whether to create 32- or 64-bit executables 29190391Ssam if test "x$TOOLCHAIN_TYPE" = xxlc; then 30190391Ssam COMPILER_TARGET_BITS_FLAG="-q" 31246226Sadrian else 32246226Sadrian COMPILER_TARGET_BITS_FLAG="-m" 33190391Ssam fi 34190391Ssam AC_SUBST(COMPILER_TARGET_BITS_FLAG) 35190391Ssam 36190391Ssam # FIXME: figure out if we should select AR flags depending on OS or toolchain. 37190391Ssam if test "x$OPENJDK_TARGET_OS" = xmacosx; then 38190391Ssam ARFLAGS="-r" 39190391Ssam elif test "x$OPENJDK_TARGET_OS" = xaix; then 40190391Ssam ARFLAGS="-X64" 41190391Ssam elif test "x$OPENJDK_TARGET_OS" = xwindows; then 42257284Sglebius # lib.exe is used as AR to create static libraries. 43190391Ssam ARFLAGS="-nologo -NODEFAULTLIB:MSVCRT" 44190391Ssam else 45257284Sglebius ARFLAGS="" 46257284Sglebius fi 47190391Ssam AC_SUBST(ARFLAGS) 48190391Ssam 49190391Ssam ## Setup strip. 50190391Ssam # FIXME: should this really be per platform, or should it be per toolchain type? 51190391Ssam # strip is not provided by clang or solstudio; so guessing platform makes most sense. 52190391Ssam # FIXME: we should really only export STRIPFLAGS from here, not POST_STRIP_CMD. 53190455Ssam if test "x$OPENJDK_TARGET_OS" = xlinux; then 54190455Ssam STRIPFLAGS="-g" 55190455Ssam elif test "x$OPENJDK_TARGET_OS" = xsolaris; then 56190455Ssam STRIPFLAGS="-x" 57190455Ssam elif test "x$OPENJDK_TARGET_OS" = xmacosx; then 58190455Ssam STRIPFLAGS="-S" 59190455Ssam elif test "x$OPENJDK_TARGET_OS" = xaix; then 60190455Ssam STRIPFLAGS="-X32_64" 61190455Ssam fi 62190455Ssam 63190455Ssam if test "x$OPENJDK_TARGET_OS" != xwindows; then 64190455Ssam POST_STRIP_CMD="$STRIP $STRIPFLAGS" 65190455Ssam fi 66190455Ssam AC_SUBST(POST_STRIP_CMD) 67190455Ssam 68190455Ssam if test "x$OPENJDK_TARGET_OS" = xsolaris; then 69190455Ssam # FIXME: break out into MCSFLAGS 70190455Ssam POST_MCS_CMD="$MCS -d -a \"JDK $FULL_VERSION\"" 71190455Ssam fi 72190455Ssam AC_SUBST(POST_MCS_CMD) 73190455Ssam 74190455Ssam if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then 75190455Ssam CC_OUT_OPTION=-Fo 76190455Ssam EXE_OUT_OPTION=-out: 77190455Ssam LD_OUT_OPTION=-out: 78190455Ssam AR_OUT_OPTION=-out: 79190455Ssam else 80190455Ssam # The option used to specify the target .o,.a or .so file. 81190455Ssam # When compiling, how to specify the to be created object file. 82190579Ssam CC_OUT_OPTION='-o$(SPACE)' 83190579Ssam # When linking, how to specify the to be created executable. 84190579Ssam EXE_OUT_OPTION='-o$(SPACE)' 85190579Ssam # When linking, how to specify the to be created dynamically linkable library. 86190391Ssam LD_OUT_OPTION='-o$(SPACE)' 87190391Ssam # When archiving, how to specify the to be create static archive for object files. 88190391Ssam AR_OUT_OPTION='rcs$(SPACE)' 89193115Ssam fi 90273377Shselasky AC_SUBST(CC_OUT_OPTION) 91193115Ssam AC_SUBST(EXE_OUT_OPTION) 92193115Ssam AC_SUBST(LD_OUT_OPTION) 93193115Ssam AC_SUBST(AR_OUT_OPTION) 94193115Ssam 95193115Ssam # On Windows, we need to set RC flags. 96190579Ssam if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then 97190391Ssam RC_FLAGS="-nologo -l0x409" 98190391Ssam if test "x$VARIANT" = xOPT; then 99190391Ssam RC_FLAGS="$RC_FLAGS -DNDEBUG" 100191753Ssam fi 101191753Ssam 102191753Ssam # The version variables used to create RC_FLAGS may be overridden 103283538Sadrian # in a custom configure script, or possibly the command line. 104191753Ssam # Let those variables be expanded at make time in spec.gmk. 105283538Sadrian # The \$ are escaped to the shell, and the $(...) variables 106191753Ssam # are evaluated by make. 107191753Ssam RC_FLAGS="$RC_FLAGS \ 108191753Ssam -D\"JDK_BUILD_ID=\$(FULL_VERSION)\" \ 109191753Ssam -D\"JDK_COMPANY=\$(COMPANY_NAME)\" \ 110191753Ssam -D\"JDK_COMPONENT=\$(PRODUCT_NAME) \$(JDK_RC_PLATFORM_NAME) binary\" \ 111191753Ssam -D\"JDK_VER=\$(JDK_MINOR_VERSION).\$(JDK_MICRO_VERSION).\$(if \$(JDK_UPDATE_VERSION),\$(JDK_UPDATE_VERSION),0).\$(COOKED_BUILD_NUMBER)\" \ 112191753Ssam -D\"JDK_COPYRIGHT=Copyright \xA9 $COPYRIGHT_YEAR\" \ 113190579Ssam -D\"JDK_NAME=\$(PRODUCT_NAME) \$(JDK_RC_PLATFORM_NAME) \$(JDK_MINOR_VERSION) \$(JDK_UPDATE_META_TAG)\" \ 114190391Ssam -D\"JDK_FVER=\$(JDK_MINOR_VERSION),\$(JDK_MICRO_VERSION),\$(if \$(JDK_UPDATE_VERSION),\$(JDK_UPDATE_VERSION),0),\$(COOKED_BUILD_NUMBER)\"" 115190391Ssam fi 116190391Ssam AC_SUBST(RC_FLAGS) 117190391Ssam 118190391Ssam if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then 119191753Ssam # silence copyright notice and other headers. 120283538Sadrian COMMON_CCXXFLAGS="$COMMON_CCXXFLAGS -nologo" 121191753Ssam fi 122191753Ssam 123190391Ssam if test "x$SYSROOT" != "x"; then 124190391Ssam if test "x$TOOLCHAIN_TYPE" = xsolstudio; then 125190391Ssam if test "x$OPENJDK_TARGET_OS" = xsolaris; then 126190391Ssam # Solaris Studio does not have a concept of sysroot. Instead we must 127190391Ssam # make sure the default include and lib dirs are appended to each 128191753Ssam # compile and link command line. 129191753Ssam SYSROOT_CFLAGS="-I$SYSROOT/usr/include" 130191753Ssam SYSROOT_LDFLAGS="-L$SYSROOT/usr/lib$OPENJDK_TARGET_CPU_ISADIR \ 131191753Ssam -L$SYSROOT/lib$OPENJDK_TARGET_CPU_ISADIR \ 132190391Ssam -L$SYSROOT/usr/ccs/lib$OPENJDK_TARGET_CPU_ISADIR" 133190391Ssam fi 134190450Ssam elif test "x$OPENJDK_TARGET_OS" = xmacosx; then 135190450Ssam # Apple only wants -isysroot <path>, but we also need -iframework<path>/System/Library/Frameworks 136190450Ssam SYSROOT_CFLAGS="-isysroot \"$SYSROOT\" -iframework\"$SYSROOT/System/Library/Frameworks\"" 137190391Ssam SYSROOT_LDFLAGS=$SYSROOT_CFLAGS 138190391Ssam elif test "x$TOOLCHAIN_TYPE" = xgcc; then 139190391Ssam SYSROOT_CFLAGS="--sysroot=$SYSROOT" 140190391Ssam SYSROOT_LDFLAGS="--sysroot=$SYSROOT" 141190391Ssam elif test "x$TOOLCHAIN_TYPE" = xclang; then 142190391Ssam SYSROOT_CFLAGS="-isysroot \"$SYSROOT\"" 143190391Ssam SYSROOT_LDFLAGS="-isysroot \"$SYSROOT\"" 144190391Ssam fi 145190391Ssam # Propagate the sysroot args to hotspot 146190391Ssam LEGACY_EXTRA_CFLAGS="$LEGACY_EXTRA_CFLAGS $SYSROOT_CFLAGS" 147190391Ssam LEGACY_EXTRA_CXXFLAGS="$LEGACY_EXTRA_CXXFLAGS $SYSROOT_CFLAGS" 148190391Ssam LEGACY_EXTRA_LDFLAGS="$LEGACY_EXTRA_LDFLAGS $SYSROOT_LDFLAGS" 149190391Ssam fi 150190451Ssam 151190391Ssam # These always need to be set, or we can't find the frameworks embedded in JavaVM.framework 152190391Ssam # set this here so it doesn't have to be peppered throughout the forest 153190391Ssam if test "x$OPENJDK_TARGET_OS" = xmacosx; then 154190391Ssam SYSROOT_CFLAGS="$SYSROOT_CFLAGS -F\"$SYSROOT/System/Library/Frameworks/JavaVM.framework/Frameworks\"" 155190391Ssam SYSROOT_LDFLAGS="$SYSROOT_LDFLAGS -F\"$SYSROOT/System/Library/Frameworks/JavaVM.framework/Frameworks\"" 156190391Ssam fi 157190391Ssam 158190391Ssam AC_SUBST(SYSROOT_CFLAGS) 159190391Ssam AC_SUBST(SYSROOT_LDFLAGS) 160190391Ssam]) 161190391Ssam 162190391SsamAC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_LIBS], 163190391Ssam[ 164190451Ssam ############################################################################### 165190451Ssam # 166190451Ssam # How to compile shared libraries. 167190451Ssam # 168190451Ssam 169190451Ssam if test "x$TOOLCHAIN_TYPE" = xgcc; then 170190451Ssam PICFLAG="-fPIC" 171190391Ssam C_FLAG_REORDER='' 172190391Ssam CXX_FLAG_REORDER='' 173190391Ssam 174190391Ssam if test "x$OPENJDK_TARGET_OS" = xmacosx; then 175190451Ssam # Linking is different on MacOSX 176190451Ssam SHARED_LIBRARY_FLAGS="-dynamiclib -compatibility_version 1.0.0 -current_version 1.0.0 $PICFLAG" 177190451Ssam SET_EXECUTABLE_ORIGIN='-Xlinker -rpath -Xlinker @loader_path/.' 178190451Ssam SET_SHARED_LIBRARY_ORIGIN="$SET_EXECUTABLE_ORIGIN" 179190451Ssam SET_SHARED_LIBRARY_NAME='-Xlinker -install_name -Xlinker @rpath/[$]1' 180190451Ssam SET_SHARED_LIBRARY_MAPFILE='' 181190451Ssam else 182190451Ssam # Default works for linux, might work on other platforms as well. 183190451Ssam SHARED_LIBRARY_FLAGS='-shared' 184190451Ssam SET_EXECUTABLE_ORIGIN='-Xlinker -rpath -Xlinker \$$$$ORIGIN[$]1' 185190451Ssam SET_SHARED_LIBRARY_ORIGIN="-Xlinker -z -Xlinker origin $SET_EXECUTABLE_ORIGIN" 186190451Ssam SET_SHARED_LIBRARY_NAME='-Xlinker -soname=[$]1' 187190391Ssam SET_SHARED_LIBRARY_MAPFILE='-Xlinker -version-script=[$]1' 188190391Ssam fi 189190391Ssam elif test "x$TOOLCHAIN_TYPE" = xclang; then 190190391Ssam PICFLAG='' 191190391Ssam C_FLAG_REORDER='' 192190391Ssam CXX_FLAG_REORDER='' 193190391Ssam 194190391Ssam if test "x$OPENJDK_TARGET_OS" = xmacosx; then 195190391Ssam # Linking is different on MacOSX 196190391Ssam SHARED_LIBRARY_FLAGS="-dynamiclib -compatibility_version 1.0.0 -current_version 1.0.0 $PICFLAG" 197190391Ssam SET_EXECUTABLE_ORIGIN='-Xlinker -rpath -Xlinker @loader_path/.' 198190391Ssam SET_SHARED_LIBRARY_ORIGIN="$SET_EXECUTABLE_ORIGIN" 199190391Ssam SET_SHARED_LIBRARY_NAME='-Xlinker -install_name -Xlinker @rpath/[$]1' 200190391Ssam SET_SHARED_LIBRARY_MAPFILE='' 201190391Ssam else 202190391Ssam # Default works for linux, might work on other platforms as well. 203190391Ssam SHARED_LIBRARY_FLAGS='-shared' 204190391Ssam SET_EXECUTABLE_ORIGIN='-Xlinker -rpath -Xlinker \$$$$ORIGIN[$]1' 205190391Ssam SET_SHARED_LIBRARY_ORIGIN="-Xlinker -z -Xlinker origin $SET_EXECUTABLE_ORIGIN" 206190391Ssam SET_SHARED_LIBRARY_NAME='-Xlinker -soname=[$]1' 207190391Ssam SET_SHARED_LIBRARY_MAPFILE='-Xlinker -version-script=[$]1' 208190391Ssam fi 209190391Ssam elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then 210190391Ssam PICFLAG="-KPIC" 211190391Ssam C_FLAG_REORDER='-xF' 212190391Ssam CXX_FLAG_REORDER='-xF' 213190391Ssam SHARED_LIBRARY_FLAGS="-G" 214190391Ssam SET_EXECUTABLE_ORIGIN='-R\$$$$ORIGIN[$]1' 215190391Ssam SET_SHARED_LIBRARY_ORIGIN="$SET_EXECUTABLE_ORIGIN" 216190391Ssam SET_SHARED_LIBRARY_NAME='' 217190391Ssam SET_SHARED_LIBRARY_MAPFILE='-M[$]1' 218190391Ssam elif test "x$TOOLCHAIN_TYPE" = xxlc; then 219190391Ssam PICFLAG="-qpic=large" 220190391Ssam C_FLAG_REORDER='' 221190391Ssam CXX_FLAG_REORDER='' 222190391Ssam SHARED_LIBRARY_FLAGS="-qmkshrobj" 223190391Ssam SET_EXECUTABLE_ORIGIN="" 224190391Ssam SET_SHARED_LIBRARY_ORIGIN='' 225190391Ssam SET_SHARED_LIBRARY_NAME='' 226190391Ssam SET_SHARED_LIBRARY_MAPFILE='' 227190391Ssam elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then 228190391Ssam PICFLAG="" 229190391Ssam C_FLAG_REORDER='' 230190391Ssam CXX_FLAG_REORDER='' 231190391Ssam SHARED_LIBRARY_FLAGS="-LD" 232190391Ssam SET_EXECUTABLE_ORIGIN='' 233190391Ssam SET_SHARED_LIBRARY_ORIGIN='' 234190391Ssam SET_SHARED_LIBRARY_NAME='' 235190391Ssam SET_SHARED_LIBRARY_MAPFILE='' 236190391Ssam fi 237190391Ssam 238190391Ssam AC_SUBST(C_FLAG_REORDER) 239190391Ssam AC_SUBST(CXX_FLAG_REORDER) 240190391Ssam AC_SUBST(SHARED_LIBRARY_FLAGS) 241190391Ssam AC_SUBST(SET_EXECUTABLE_ORIGIN) 242190391Ssam AC_SUBST(SET_SHARED_LIBRARY_ORIGIN) 243190391Ssam AC_SUBST(SET_SHARED_LIBRARY_NAME) 244190391Ssam AC_SUBST(SET_SHARED_LIBRARY_MAPFILE) 245190391Ssam 246190391Ssam if test "x$OPENJDK_TARGET_OS" = xsolaris; then 247190391Ssam CFLAGS_JDK="${CFLAGS_JDK} -D__solaris__" 248190391Ssam CXXFLAGS_JDK="${CXXFLAGS_JDK} -D__solaris__" 249190391Ssam CFLAGS_JDKLIB_EXTRA='-xstrconst' 250190391Ssam fi 251190391Ssam # The (cross) compiler is now configured, we can now test capabilities 252190391Ssam # of the target platform. 253190391Ssam]) 254190391Ssam 255190391Ssam# Documentation on common flags used for solstudio in HIGHEST. 256190391Ssam# 257190391Ssam# WARNING: Use of OPTIMIZATION_LEVEL=HIGHEST in your Makefile needs to be 258190391Ssam# done with care, there are some assumptions below that need to 259190391Ssam# be understood about the use of pointers, and IEEE behavior. 260190391Ssam# 261190391Ssam# -fns: Use non-standard floating point mode (not IEEE 754) 262190391Ssam# -fsimple: Do some simplification of floating point arithmetic (not IEEE 754) 263190391Ssam# -fsingle: Use single precision floating point with 'float' 264190391Ssam# -xalias_level=basic: Assume memory references via basic pointer types do not alias 265190391Ssam# (Source with excessing pointer casting and data access with mixed 266190391Ssam# pointer types are not recommended) 267190391Ssam# -xbuiltin=%all: Use intrinsic or inline versions for math/std functions 268190391Ssam# (If you expect perfect errno behavior, do not use this) 269190391Ssam# -xdepend: Loop data dependency optimizations (need -xO3 or higher) 270190391Ssam# -xrestrict: Pointer parameters to functions do not overlap 271190391Ssam# (Similar to -xalias_level=basic usage, but less obvious sometimes. 272190391Ssam# If you pass in multiple pointers to the same data, do not use this) 273190391Ssam# -xlibmil: Inline some library routines 274190391Ssam# (If you expect perfect errno behavior, do not use this) 275190391Ssam# -xlibmopt: Use optimized math routines (CURRENTLY DISABLED) 276190391Ssam# (If you expect perfect errno behavior, do not use this) 277190391Ssam# Can cause undefined external on Solaris 8 X86 on __sincos, removing for now 278190391Ssam 279190391Ssam # FIXME: this will never happen since sparc != sparcv9, ie 32 bit, which we don't build anymore. 280190391Ssam # Bug? 281190391Ssam #if test "x$OPENJDK_TARGET_CPU" = xsparc; then 282190391Ssam # CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s" 283190391Ssam # CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s" 284190391Ssam #fi 285190391Ssam 286190391SsamAC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION], 287190391Ssam[ 288190391Ssam 289190391Ssam ############################################################################### 290190391Ssam # 291190391Ssam # Setup the opt flags for different compilers 292190391Ssam # and different operating systems. 293190391Ssam # 294190391Ssam 295190391Ssam # FIXME: this was indirectly the old default, but just inherited. 296190391Ssam # if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then 297190391Ssam # C_FLAG_DEPS="-MMD -MF" 298190391Ssam # fi 299190391Ssam 300190391Ssam # Generate make dependency files 301190391Ssam if test "x$TOOLCHAIN_TYPE" = xgcc; then 302190391Ssam C_FLAG_DEPS="-MMD -MF" 303190391Ssam elif test "x$TOOLCHAIN_TYPE" = xclang; then 304190391Ssam C_FLAG_DEPS="-MMD -MF" 305190391Ssam elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then 306190391Ssam C_FLAG_DEPS="-xMMD -xMF" 307190391Ssam elif test "x$TOOLCHAIN_TYPE" = xxlc; then 308190391Ssam C_FLAG_DEPS="-qmakedep=gcc -MF" 309190391Ssam fi 310190391Ssam CXX_FLAG_DEPS="$C_FLAG_DEPS" 311190391Ssam AC_SUBST(C_FLAG_DEPS) 312190391Ssam AC_SUBST(CXX_FLAG_DEPS) 313190391Ssam 314190391Ssam # Debug symbols 315190391Ssam if test "x$TOOLCHAIN_TYPE" = xgcc; then 316190391Ssam if test "x$OPENJDK_TARGET_CPU_BITS" = "x64" && test "x$DEBUG_LEVEL" = "xfastdebug"; then 317190391Ssam # reduce from default "-g2" option to save space 318190391Ssam CFLAGS_DEBUG_SYMBOLS="-g1" 319190391Ssam CXXFLAGS_DEBUG_SYMBOLS="-g1" 320190391Ssam else 321190391Ssam CFLAGS_DEBUG_SYMBOLS="-g" 322190391Ssam CXXFLAGS_DEBUG_SYMBOLS="-g" 323190391Ssam fi 324190391Ssam elif test "x$TOOLCHAIN_TYPE" = xclang; then 325190391Ssam CFLAGS_DEBUG_SYMBOLS="-g" 326190391Ssam CXXFLAGS_DEBUG_SYMBOLS="-g" 327190391Ssam elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then 328190391Ssam CFLAGS_DEBUG_SYMBOLS="-g -xs" 329190391Ssam # FIXME: likely a bug, this disables debug symbols rather than enables them 330190391Ssam CXXFLAGS_DEBUG_SYMBOLS="-g0 -xs" 331190391Ssam elif test "x$TOOLCHAIN_TYPE" = xxlc; then 332190391Ssam CFLAGS_DEBUG_SYMBOLS="-g" 333190391Ssam CXXFLAGS_DEBUG_SYMBOLS="-g" 334190391Ssam fi 335190391Ssam AC_SUBST(CFLAGS_DEBUG_SYMBOLS) 336190391Ssam AC_SUBST(CXXFLAGS_DEBUG_SYMBOLS) 337190391Ssam 338190391Ssam # bounds, memory and behavior checking options 339190391Ssam if test "x$TOOLCHAIN_TYPE" = xgcc; then 340190391Ssam case $DEBUG_LEVEL in 341190391Ssam release ) 342190391Ssam # no adjustment 343190391Ssam ;; 344190391Ssam fastdebug ) 345190391Ssam # no adjustment 346190391Ssam ;; 347190391Ssam slowdebug ) 348190391Ssam # Add runtime stack smashing and undefined behavior checks 349190391Ssam CFLAGS_DEBUG_OPTIONS="-fstack-protector-all --param ssp-buffer-size=1" 350190391Ssam CXXFLAGS_DEBUG_OPTIONS="-fstack-protector-all --param ssp-buffer-size=1" 351190391Ssam ;; 352190391Ssam esac 353190391Ssam fi 354190391Ssam AC_SUBST(CFLAGS_DEBUG_OPTIONS) 355190391Ssam AC_SUBST(CXXFLAGS_DEBUG_OPTIONS) 356190391Ssam 357190579Ssam # Optimization levels 358190391Ssam if test "x$TOOLCHAIN_TYPE" = xsolstudio; then 359190579Ssam CC_HIGHEST="$CC_HIGHEST -fns -fsimple -fsingle -xbuiltin=%all -xdepend -xrestrict -xlibmil" 360190579Ssam 361190391Ssam if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then 362190391Ssam # FIXME: seems we always set -xregs=no%frameptr; put it elsewhere more global? 363190391Ssam C_O_FLAG_HIGHEST="-xO4 -Wu,-O4~yz $CC_HIGHEST -xalias_level=basic -xregs=no%frameptr" 364190391Ssam C_O_FLAG_HI="-xO4 -Wu,-O4~yz -xregs=no%frameptr" 365190391Ssam C_O_FLAG_NORM="-xO2 -Wu,-O2~yz -xregs=no%frameptr" 366190391Ssam C_O_FLAG_DEBUG="-xregs=no%frameptr" 367190391Ssam C_O_FLAG_NONE="-xregs=no%frameptr" 368190391Ssam CXX_O_FLAG_HIGHEST="-xO4 -Qoption ube -O4~yz $CC_HIGHEST -xregs=no%frameptr" 369190391Ssam CXX_O_FLAG_HI="-xO4 -Qoption ube -O4~yz -xregs=no%frameptr" 370190391Ssam CXX_O_FLAG_NORM="-xO2 -Qoption ube -O2~yz -xregs=no%frameptr" 371190391Ssam CXX_O_FLAG_DEBUG="-xregs=no%frameptr" 372190391Ssam CXX_O_FLAG_NONE="-xregs=no%frameptr" 373190391Ssam if test "x$OPENJDK_TARGET_CPU_BITS" = "x32"; then 374190391Ssam C_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST -xchip=pentium" 375190391Ssam CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_HIGHEST -xchip=pentium" 376190391Ssam fi 377190391Ssam elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then 378190391Ssam C_O_FLAG_HIGHEST="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0 $CC_HIGHEST -xalias_level=basic -xprefetch=auto,explicit -xchip=ultra" 379190391Ssam C_O_FLAG_HI="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0" 380190391Ssam C_O_FLAG_NORM="-xO2 -Wc,-Qrm-s -Wc,-Qiselect-T0" 381190391Ssam C_O_FLAG_DEBUG="" 382190391Ssam C_O_FLAG_NONE="" 383190391Ssam CXX_O_FLAG_HIGHEST="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra" 384190391Ssam CXX_O_FLAG_HI="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0" 385190391Ssam CXX_O_FLAG_NORM="-xO2 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0" 386190391Ssam C_O_FLAG_DEBUG="" 387190391Ssam CXX_O_FLAG_NONE="" 388190391Ssam fi 389190391Ssam else 390190391Ssam # The remaining toolchains share opt flags between CC and CXX; 391254900Sadrian # setup for C and duplicate afterwards. 392190391Ssam if test "x$TOOLCHAIN_TYPE" = xgcc; then 393190391Ssam if test "x$OPENJDK_TARGET_OS" = xmacosx; then 394254900Sadrian # On MacOSX we optimize for size, something 395190391Ssam # we should do for all platforms? 396190391Ssam C_O_FLAG_HIGHEST="-Os" 397190391Ssam C_O_FLAG_HI="-Os" 398190391Ssam C_O_FLAG_NORM="-Os" 399190391Ssam else 400190391Ssam C_O_FLAG_HIGHEST="-O3" 401190391Ssam C_O_FLAG_HI="-O3" 402190391Ssam C_O_FLAG_NORM="-O2" 403190391Ssam fi 404190391Ssam C_O_FLAG_DEBUG="-O0" 405190391Ssam C_O_FLAG_NONE="-O0" 406190391Ssam elif test "x$TOOLCHAIN_TYPE" = xclang; then 407190391Ssam if test "x$OPENJDK_TARGET_OS" = xmacosx; then 408190391Ssam # On MacOSX we optimize for size, something 409190391Ssam # we should do for all platforms? 410190391Ssam C_O_FLAG_HIGHEST="-Os" 411190391Ssam C_O_FLAG_HI="-Os" 412190391Ssam C_O_FLAG_NORM="-Os" 413190391Ssam else 414190391Ssam C_O_FLAG_HIGHEST="-O3" 415190391Ssam C_O_FLAG_HI="-O3" 416190391Ssam C_O_FLAG_NORM="-O2" 417190391Ssam fi 418190391Ssam C_O_FLAG_DEBUG="-O0" 419190391Ssam C_O_FLAG_NONE="-O0" 420190391Ssam elif test "x$TOOLCHAIN_TYPE" = xxlc; then 421190391Ssam C_O_FLAG_HIGHEST="-O3" 422190391Ssam C_O_FLAG_HI="-O3 -qstrict" 423190391Ssam C_O_FLAG_NORM="-O2" 424190391Ssam C_O_FLAG_DEBUG="-qnoopt" 425190391Ssam C_O_FLAG_NONE="-qnoop" 426190391Ssam elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then 427190391Ssam C_O_FLAG_HIGHEST="-O2" 428190391Ssam C_O_FLAG_HI="-O1" 429243882Sglebius C_O_FLAG_NORM="-O1" 430190391Ssam C_O_FLAG_DEBUG="-Od" 431190391Ssam C_O_FLAG_NONE="-Od" 432190391Ssam fi 433190391Ssam CXX_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST" 434190391Ssam CXX_O_FLAG_HI="$C_O_FLAG_HI" 435190391Ssam CXX_O_FLAG_NORM="$C_O_FLAG_NORM" 436190391Ssam CXX_O_FLAG_DEBUG="$C_O_FLAG_DEBUG" 437190391Ssam CXX_O_FLAG_NONE="$C_O_FLAG_NONE" 438243882Sglebius fi 439190391Ssam 440190391Ssam # Adjust optimization flags according to debug level. 441190391Ssam case $DEBUG_LEVEL in 442190391Ssam release ) 443190391Ssam # no adjustment 444190391Ssam ;; 445190391Ssam fastdebug ) 446190391Ssam # Not quite so much optimization 447190391Ssam C_O_FLAG_HI="$C_O_FLAG_NORM" 448190391Ssam CXX_O_FLAG_HI="$CXX_O_FLAG_NORM" 449190391Ssam ;; 450190391Ssam slowdebug ) 451190391Ssam # Disable optimization 452190391Ssam C_O_FLAG_HIGHEST="$C_O_FLAG_DEBUG" 453190391Ssam C_O_FLAG_HI="$C_O_FLAG_DEBUG" 454190391Ssam C_O_FLAG_NORM="$C_O_FLAG_DEBUG" 455190391Ssam CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_DEBUG" 456190391Ssam CXX_O_FLAG_HI="$CXX_O_FLAG_DEBUG" 457190391Ssam CXX_O_FLAG_NORM="$CXX_O_FLAG_DEBUG" 458190391Ssam ;; 459190391Ssam esac 460190391Ssam 461190391Ssam AC_SUBST(C_O_FLAG_HIGHEST) 462190391Ssam AC_SUBST(C_O_FLAG_HI) 463190391Ssam AC_SUBST(C_O_FLAG_NORM) 464190579Ssam AC_SUBST(C_O_FLAG_DEBUG) 465190579Ssam AC_SUBST(C_O_FLAG_NONE) 466190579Ssam AC_SUBST(CXX_O_FLAG_HIGHEST) 467190579Ssam AC_SUBST(CXX_O_FLAG_HI) 468248069Sadrian AC_SUBST(CXX_O_FLAG_NORM) 469190579Ssam AC_SUBST(CXX_O_FLAG_DEBUG) 470190579Ssam AC_SUBST(CXX_O_FLAG_NONE) 471248069Sadrian]) 472248069Sadrian 473190579SsamAC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK], 474190579Ssam[ 475190579Ssam # Special extras... 476190579Ssam if test "x$TOOLCHAIN_TYPE" = xsolstudio; then 477190579Ssam if test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then 478254082Sadrian CFLAGS_JDKLIB_EXTRA="${CFLAGS_JDKLIB_EXTRA} -xregs=no%appl" 479190579Ssam CXXFLAGS_JDKLIB_EXTRA="${CXXFLAGS_JDKLIB_EXTRA} -xregs=no%appl" 480190579Ssam fi 481190579Ssam elif test "x$TOOLCHAIN_TYPE" = xxlc; then 482190579Ssam LDFLAGS_JDK="${LDFLAGS_JDK} -q64 -brtl -bnolibpath -liconv -bexpall" 483271861Sglebius CFLAGS_JDK="${CFLAGS_JDK} -qchars=signed -q64 -qfullpath -qsaveopt" 484190579Ssam CXXFLAGS_JDK="${CXXFLAGS_JDK} -qchars=signed -q64 -qfullpath -qsaveopt" 485190579Ssam fi 486190579Ssam 487190579Ssam if test "x$CFLAGS" != "x${ADDED_CFLAGS}"; then 488190579Ssam AC_MSG_WARN([Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags]) 489190391Ssam fi 490190579Ssam 491190579Ssam if test "x$CXXFLAGS" != "x${ADDED_CXXFLAGS}"; then 492190579Ssam AC_MSG_WARN([Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags]) 493190579Ssam fi 494190579Ssam 495190579Ssam if test "x$LDFLAGS" != "x${ADDED_LDFLAGS}"; then 496190579Ssam AC_MSG_WARN([Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags]) 497190579Ssam fi 498190579Ssam 499190579Ssam AC_ARG_WITH(extra-cflags, [AS_HELP_STRING([--with-extra-cflags], 500190579Ssam [extra flags to be used when compiling jdk c-files])]) 501190579Ssam 502190579Ssam AC_ARG_WITH(extra-cxxflags, [AS_HELP_STRING([--with-extra-cxxflags], 503190579Ssam [extra flags to be used when compiling jdk c++-files])]) 504190579Ssam 505190579Ssam AC_ARG_WITH(extra-ldflags, [AS_HELP_STRING([--with-extra-ldflags], 506190579Ssam [extra flags to be used when linking jdk])]) 507190579Ssam 508190579Ssam CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags" 509190579Ssam CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags" 510190579Ssam LDFLAGS_JDK="${LDFLAGS_JDK} $with_extra_ldflags" 511190579Ssam 512190579Ssam # Hotspot needs these set in their legacy form 513190579Ssam LEGACY_EXTRA_CFLAGS="$LEGACY_EXTRA_CFLAGS $with_extra_cflags" 514190579Ssam LEGACY_EXTRA_CXXFLAGS="$LEGACY_EXTRA_CXXFLAGS $with_extra_cxxflags" 515190579Ssam LEGACY_EXTRA_LDFLAGS="$LEGACY_EXTRA_LDFLAGS $with_extra_ldflags" 516190579Ssam 517190579Ssam AC_SUBST(LEGACY_EXTRA_CFLAGS) 518244044Sadrian AC_SUBST(LEGACY_EXTRA_CXXFLAGS) 519244044Sadrian AC_SUBST(LEGACY_EXTRA_LDFLAGS) 520244044Sadrian 521244044Sadrian ############################################################################### 522244044Sadrian # 523244044Sadrian # Now setup the CFLAGS and LDFLAGS for the JDK build. 524244044Sadrian # Later we will also have CFLAGS and LDFLAGS for the hotspot subrepo build. 525244044Sadrian # 526190579Ssam 527190579Ssam # Setup compiler/platform specific flags into 528191753Ssam # CFLAGS_JDK - C Compiler flags 529191753Ssam # CXXFLAGS_JDK - C++ Compiler flags 530190579Ssam # COMMON_CCXXFLAGS_JDK - common to C and C++ 531190579Ssam if test "x$TOOLCHAIN_TYPE" = xgcc; then 532190579Ssam COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -Wall -Wno-parentheses -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \ 533190579Ssam -pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE" 534244044Sadrian case $OPENJDK_TARGET_CPU_ARCH in 535190579Ssam arm ) 536244044Sadrian # on arm we don't prevent gcc to omit frame pointer but do prevent strict aliasing 537190579Ssam CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing" 538190579Ssam ;; 539190579Ssam ppc ) 540190579Ssam # on ppc we don't prevent gcc to omit frame pointer but do prevent strict aliasing 541234324Sadrian CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing" 542234324Sadrian ;; 543288318Sadrian * ) 544190579Ssam COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -fno-omit-frame-pointer" 545288318Sadrian CFLAGS_JDK="${CFLAGS_JDK} -fno-strict-aliasing" 546288318Sadrian ;; 547190579Ssam esac 548190579Ssam elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then 549190579Ssam COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS" 550190579Ssam if test "x$OPENJDK_TARGET_CPU_ARCH" = xx86; then 551190579Ssam COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_TARGET_CPU_LEGACY_LIB" 552190579Ssam CFLAGS_JDK="$CFLAGS_JDK -erroff=E_BAD_PRAGMA_PACK_VALUE" 553190579Ssam fi 554190579Ssam 555190579Ssam CFLAGS_JDK="$CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal" 556190579Ssam CXXFLAGS_JDK="$CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib" 557248069Sadrian elif test "x$TOOLCHAIN_TYPE" = xxlc; then 558190579Ssam CFLAGS_JDK="$CFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC" 559248069Sadrian CXXFLAGS_JDK="$CXXFLAGS_JDK -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE -DSTDC" 560190579Ssam elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then 561190579Ssam COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS $COMMON_CCXXFLAGS_JDK -Zi -MD -Zc:wchar_t- -W3 -wd4800 \ 562190579Ssam -D_STATIC_CPPLIB -D_DISABLE_DEPRECATE_STATIC_CPPLIB -DWIN32_LEAN_AND_MEAN \ 563244051Sadrian -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \ 564190579Ssam -DWIN32 -DIAL" 565190579Ssam if test "x$OPENJDK_TARGET_CPU" = xx86_64; then 566244051Sadrian COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_AMD64_ -Damd64" 567244051Sadrian else 568244051Sadrian COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_X86_ -Dx86" 569190579Ssam fi 570190579Ssam fi 571190579Ssam 572190579Ssam ############################################################################### 573190579Ssam 574190579Ssam # Adjust flags according to debug level. 575190579Ssam case $DEBUG_LEVEL in 576190579Ssam fastdebug | slowdebug ) 577190579Ssam CFLAGS_JDK="$CFLAGS_JDK $CFLAGS_DEBUG_SYMBOLS $CFLAGS_DEBUG_OPTIONS" 578190579Ssam CXXFLAGS_JDK="$CXXFLAGS_JDK $CXXFLAGS_DEBUG_SYMBOLS $CXXFLAGS_DEBUG_OPTIONS" 579190579Ssam JAVAC_FLAGS="$JAVAC_FLAGS -g" 580190579Ssam ;; 581190579Ssam release ) 582244051Sadrian ;; 583190579Ssam * ) 584190579Ssam AC_MSG_ERROR([Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL]) 585190579Ssam ;; 586244051Sadrian esac 587244051Sadrian 588190579Ssam # Setup LP64 589190579Ssam COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK $ADD_LP64" 590190579Ssam 591190579Ssam # Set some common defines. These works for all compilers, but assume 592190579Ssam # -D is universally accepted. 593190579Ssam 594190579Ssam # Setup endianness 595190579Ssam if test "x$OPENJDK_TARGET_CPU_ENDIAN" = xlittle; then 596190579Ssam # The macro _LITTLE_ENDIAN needs to be defined the same to avoid the 597190579Ssam # Sun C compiler warning message: warning: macro redefined: _LITTLE_ENDIAN 598190579Ssam # (The Solaris X86 system defines this in file /usr/include/sys/isa_defs.h). 599190579Ssam # Note: -Dmacro is the same as #define macro 1 600190579Ssam # -Dmacro= is the same as #define macro 601190579Ssam if test "x$OPENJDK_TARGET_OS" = xsolaris; then 602190579Ssam COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN=" 603190579Ssam else 604190579Ssam COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN" 605190579Ssam fi 606190579Ssam else 607190579Ssam # Same goes for _BIG_ENDIAN. Do we really need to set *ENDIAN on Solaris if they 608190579Ssam # are defined in the system? 609190579Ssam if test "x$OPENJDK_TARGET_OS" = xsolaris; then 610190579Ssam COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN=" 611190579Ssam else 612190579Ssam COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN" 613190579Ssam fi 614190579Ssam fi 615190579Ssam 616190579Ssam # Setup target OS define. Use OS target name but in upper case. 617190579Ssam OPENJDK_TARGET_OS_UPPERCASE=`$ECHO $OPENJDK_TARGET_OS | $TR 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'` 618190579Ssam COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D$OPENJDK_TARGET_OS_UPPERCASE" 619190579Ssam 620190579Ssam # Setup target CPU 621190579Ssam COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DARCH='\"$OPENJDK_TARGET_CPU_LEGACY\"' -D$OPENJDK_TARGET_CPU_LEGACY" 622190579Ssam 623190579Ssam # Setup debug/release defines 624190579Ssam if test "x$DEBUG_LEVEL" = xrelease; then 625190579Ssam COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DNDEBUG" 626190579Ssam if test "x$OPENJDK_TARGET_OS" = xsolaris; then 627190579Ssam COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DTRIMMED" 628190579Ssam fi 629190579Ssam else 630190579Ssam COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DDEBUG" 631190579Ssam fi 632190579Ssam 633190579Ssam # Setup release name 634190579Ssam COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DRELEASE='\"\$(RELEASE)\"'" 635190579Ssam 636190579Ssam 637190579Ssam # Set some additional per-OS defines. 638190579Ssam if test "x$OPENJDK_TARGET_OS" = xmacosx; then 639190579Ssam COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT" 640190579Ssam elif test "x$OPENJDK_TARGET_OS" = xaix; then 641191753Ssam # FIXME: PPC64 should not be here. 642190579Ssam COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DPPC64" 643190579Ssam elif test "x$OPENJDK_TARGET_OS" = xbsd; then 644190579Ssam COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE" 645190579Ssam fi 646190579Ssam 647190579Ssam # Additional macosx handling 648248069Sadrian if test "x$OPENJDK_TARGET_OS" = xmacosx; then 649248069Sadrian # Setting these parameters makes it an error to link to macosx APIs that are 650190579Ssam # newer than the given OS version and makes the linked binaries compatible 651190579Ssam # even if built on a newer version of the OS. 652190579Ssam # The expected format is X.Y.Z 653190579Ssam MACOSX_VERSION_MIN=10.7.0 654190579Ssam AC_SUBST(MACOSX_VERSION_MIN) 655190579Ssam 656190579Ssam # The macro takes the version with no dots, ex: 1070 657190579Ssam # Let the flags variables get resolved in make for easier override on make 658234324Sadrian # command line. 659288318Sadrian COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK -DMAC_OS_X_VERSION_MAX_ALLOWED=\$(subst .,,\$(MACOSX_VERSION_MIN)) -mmacosx-version-min=\$(MACOSX_VERSION_MIN)" 660288318Sadrian LDFLAGS_JDK="$LDFLAGS_JDK -mmacosx-version-min=\$(MACOSX_VERSION_MIN)" 661288318Sadrian fi 662288318Sadrian 663288318Sadrian # Setup some hard coded includes 664288318Sadrian COMMON_CCXXFLAGS_JDK="$COMMON_CCXXFLAGS_JDK \ 665190579Ssam -I${JDK_TOPDIR}/src/java.base/share/native/include \ 666190579Ssam -I${JDK_TOPDIR}/src/java.base/$OPENJDK_TARGET_OS/native/include \ 667190579Ssam -I${JDK_TOPDIR}/src/java.base/$OPENJDK_TARGET_OS_TYPE/native/include" 668190579Ssam 669190579Ssam # The shared libraries are compiled using the picflag. 670190579Ssam CFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA" 671190579Ssam CXXFLAGS_JDKLIB="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK $PICFLAG $CXXFLAGS_JDKLIB_EXTRA " 672190579Ssam 673190579Ssam # Executable flags 674190579Ssam CFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK" 675190579Ssam CXXFLAGS_JDKEXE="$COMMON_CCXXFLAGS_JDK $CXXFLAGS_JDK" 676190579Ssam 677190579Ssam AC_SUBST(CFLAGS_JDKLIB) 678190579Ssam AC_SUBST(CFLAGS_JDKEXE) 679190579Ssam AC_SUBST(CXXFLAGS_JDKLIB) 680190579Ssam AC_SUBST(CXXFLAGS_JDKEXE) 681190579Ssam 682288318Sadrian # Setup LDFLAGS et al. 683288318Sadrian # 684190579Ssam 685190579Ssam # Now this is odd. The JDK native libraries have to link against libjvm.so 686190579Ssam # On 32-bit machines there is normally two distinct libjvm.so:s, client and server. 687190579Ssam # Which should we link to? Are we lucky enough that the binary api to the libjvm.so library 688190579Ssam # is identical for client and server? Yes. Which is picked at runtime (client or server)? 689191753Ssam # Neither, since the chosen libjvm.so has already been loaded by the launcher, all the following 690190579Ssam # libraries will link to whatever is in memory. Yuck. 691190579Ssam # 692190579Ssam # Thus we offer the compiler to find libjvm.so first in server then in client. It works. Ugh. 693190579Ssam if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then 694190579Ssam LDFLAGS_JDK="$LDFLAGS_JDK -nologo -opt:ref -incremental:no" 695190579Ssam if test "x$OPENJDK_TARGET_CPU_BITS" = "x32"; then 696190579Ssam LDFLAGS_JDK="$LDFLAGS_JDK -safeseh" 697190579Ssam fi 698190579Ssam # TODO: make -debug optional "--disable-full-debug-symbols" 699190579Ssam LDFLAGS_JDK="$LDFLAGS_JDK -debug" 700190579Ssam elif test "x$TOOLCHAIN_TYPE" = xgcc; then 701190579Ssam # If this is a --hash-style=gnu system, use --hash-style=both, why? 702190579Ssam # We have previously set HAS_GNU_HASH if this is the case 703190579Ssam if test -n "$HAS_GNU_HASH"; then 704190579Ssam LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker --hash-style=both" 705190579Ssam fi 706288318Sadrian if test "x$OPENJDK_TARGET_OS" = xlinux; then 707190579Ssam # And since we now know that the linker is gnu, then add -z defs, to forbid 708244051Sadrian # undefined symbols in object files. 709190579Ssam LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -z -Xlinker defs" 710190579Ssam case $DEBUG_LEVEL in 711190579Ssam release ) 712248069Sadrian # tell linker to optimize libraries. 713190579Ssam # Should this be supplied to the OSS linker as well? 714190579Ssam LDFLAGS_JDK="${LDFLAGS_JDK} -Xlinker -O1" 715190579Ssam ;; 716190579Ssam slowdebug ) 717248069Sadrian if test "x$HAS_LINKER_NOW" = "xtrue"; then 718190579Ssam # do relocations at load 719190579Ssam LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_NOW_FLAG" 720190579Ssam LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_NOW_FLAG" 721190579Ssam fi 722190579Ssam if test "x$HAS_LINKER_RELRO" = "xtrue"; then 723190579Ssam # mark relocations read only 724190579Ssam LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_RELRO_FLAG" 725190579Ssam LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_RELRO_FLAG" 726190579Ssam fi 727190579Ssam ;; 728190579Ssam fastdebug ) 729288318Sadrian if test "x$HAS_LINKER_RELRO" = "xtrue"; then 730244051Sadrian # mark relocations read only 731190579Ssam LDFLAGS_JDK="$LDFLAGS_JDK $LINKER_RELRO_FLAG" 732190579Ssam LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK $LINKER_RELRO_FLAG" 733190579Ssam fi 734190579Ssam ;; 735190579Ssam * ) 736190579Ssam AC_MSG_ERROR([Unrecognized \$DEBUG_LEVEL: $DEBUG_LEVEL]) 737190579Ssam ;; 738190579Ssam esac 739190579Ssam fi 740190579Ssam elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then 741190579Ssam LDFLAGS_JDK="$LDFLAGS_JDK -z defs -xildoff -ztext" 742190579Ssam LDFLAGS_CXX_JDK="$LDFLAGS_CXX_JDK -norunpath -xnolib" 743190579Ssam fi 744190579Ssam 745190579Ssam # Customize LDFLAGS for executables 746190579Ssam 747288318Sadrian LDFLAGS_JDKEXE="${LDFLAGS_JDK}" 748288318Sadrian 749288318Sadrian if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then 750288318Sadrian if test "x$OPENJDK_TARGET_CPU_BITS" = "x64"; then 751190579Ssam LDFLAGS_STACK_SIZE=1048576 752244051Sadrian else 753190579Ssam LDFLAGS_STACK_SIZE=327680 754190579Ssam fi 755190579Ssam LDFLAGS_JDKEXE="${LDFLAGS_JDKEXE} /STACK:$LDFLAGS_STACK_SIZE" 756190579Ssam elif test "x$OPENJDK_TARGET_OS" = xlinux; then 757190579Ssam LDFLAGS_JDKEXE="$LDFLAGS_JDKEXE -Xlinker --allow-shlib-undefined" 758190579Ssam fi 759190579Ssam 760190579Ssam # Customize LDFLAGS for libs 761190579Ssam LDFLAGS_JDKLIB="${LDFLAGS_JDK}" 762190579Ssam 763190579Ssam if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then 764190579Ssam LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -dll -libpath:${JDK_OUTPUTDIR}/lib" 765190579Ssam LDFLAGS_JDKLIB_SUFFIX="" 766190579Ssam else 767190579Ssam LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} ${SHARED_LIBRARY_FLAGS} \ 768190579Ssam -L${JDK_OUTPUTDIR}/lib${OPENJDK_TARGET_CPU_LIBDIR}" 769190579Ssam 770190579Ssam # On some platforms (mac) the linker warns about non existing -L dirs. 771190579Ssam # Add server first if available. Linking aginst client does not always produce the same results. 772190579Ssam # Only add client dir if client is being built. Add minimal (note not minimal1) if only building minimal1. 773190579Ssam # Default to server for other variants. 774190579Ssam if test "x$JVM_VARIANT_SERVER" = xtrue; then 775190579Ssam LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -L${JDK_OUTPUTDIR}/lib${OPENJDK_TARGET_CPU_LIBDIR}/server" 776190579Ssam elif test "x$JVM_VARIANT_CLIENT" = xtrue; then 777191753Ssam LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -L${JDK_OUTPUTDIR}/lib${OPENJDK_TARGET_CPU_LIBDIR}/client" 778244025Sadrian elif test "x$JVM_VARIANT_MINIMAL1" = xtrue; then 779234324Sadrian LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -L${JDK_OUTPUTDIR}/lib${OPENJDK_TARGET_CPU_LIBDIR}/minimal" 780190579Ssam else 781190579Ssam LDFLAGS_JDKLIB="${LDFLAGS_JDKLIB} -L${JDK_OUTPUTDIR}/lib${OPENJDK_TARGET_CPU_LIBDIR}/server" 782190579Ssam fi 783234324Sadrian 784234324Sadrian LDFLAGS_JDKLIB_SUFFIX="-ljava -ljvm" 785288318Sadrian if test "x$TOOLCHAIN_TYPE" = xsolstudio; then 786288318Sadrian LDFLAGS_JDKLIB_SUFFIX="$LDFLAGS_JDKLIB_SUFFIX -lc" 787288318Sadrian fi 788288318Sadrian fi 789288318Sadrian 790288318Sadrian AC_SUBST(LDFLAGS_JDKLIB) 791288318Sadrian AC_SUBST(LDFLAGS_JDKEXE) 792288318Sadrian AC_SUBST(LDFLAGS_JDKLIB_SUFFIX) 793190579Ssam AC_SUBST(LDFLAGS_JDKEXE_SUFFIX) 794288318Sadrian AC_SUBST(LDFLAGS_CXX_JDK) 795244051Sadrian]) 796190579Ssam 797190579Ssam# FLAGS_COMPILER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE], 798190579Ssam# [RUN-IF-FALSE]) 799190579Ssam# ------------------------------------------------------------ 800190579Ssam# Check that the c and c++ compilers support an argument 801190579SsamAC_DEFUN([FLAGS_COMPILER_CHECK_ARGUMENTS], 802244025Sadrian[ 803244025Sadrian AC_MSG_CHECKING([if compiler supports "$1"]) 804244025Sadrian supports=yes 805244025Sadrian 806244025Sadrian saved_cflags="$CFLAGS" 807244025Sadrian CFLAGS="$CFLAGS $1" 808244025Sadrian AC_LANG_PUSH([C]) 809190579Ssam AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int i;]])], [], 810190579Ssam [supports=no]) 811244025Sadrian AC_LANG_POP([C]) 812190579Ssam CFLAGS="$saved_cflags" 813190579Ssam 814190579Ssam saved_cxxflags="$CXXFLAGS" 815190579Ssam CXXFLAGS="$CXXFLAG $1" 816190391Ssam AC_LANG_PUSH([C++]) 817190391Ssam AC_COMPILE_IFELSE([AC_LANG_SOURCE([[int i;]])], [], 818190391Ssam [supports=no]) 819190391Ssam AC_LANG_POP([C++]) 820190391Ssam CXXFLAGS="$saved_cxxflags" 821190391Ssam 822190391Ssam AC_MSG_RESULT([$supports]) 823190391Ssam if test "x$supports" = "xyes" ; then 824190391Ssam m4_ifval([$2], [$2], [:]) 825190391Ssam else 826190391Ssam m4_ifval([$3], [$3], [:]) 827190391Ssam fi 828190391Ssam]) 829190391Ssam 830190391Ssam# FLAGS_LINKER_CHECK_ARGUMENTS([ARGUMENT], [RUN-IF-TRUE], 831190391Ssam# [RUN-IF-FALSE]) 832190391Ssam# ------------------------------------------------------------ 833190391Ssam# Check that the linker support an argument 834190391SsamAC_DEFUN([FLAGS_LINKER_CHECK_ARGUMENTS], 835190391Ssam[ 836190391Ssam AC_MSG_CHECKING([if linker supports "$1"]) 837190391Ssam supports=yes 838190391Ssam 839190391Ssam saved_ldflags="$LDFLAGS" 840190391Ssam LDFLAGS="$LDFLAGS $1" 841190391Ssam AC_LANG_PUSH([C]) 842190391Ssam AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])], 843190391Ssam [], [supports=no]) 844190532Ssam AC_LANG_POP([C]) 845190391Ssam LDFLAGS="$saved_ldflags" 846192468Ssam 847190391Ssam AC_MSG_RESULT([$supports]) 848190391Ssam if test "x$supports" = "xyes" ; then 849190391Ssam m4_ifval([$2], [$2], [:]) 850190391Ssam else 851190391Ssam m4_ifval([$3], [$3], [:]) 852190391Ssam fi 853190391Ssam]) 854190391Ssam 855190391SsamAC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_MISC], 856190391Ssam[ 857190391Ssam # Some Zero and Shark settings. 858190391Ssam # ZERO_ARCHFLAG tells the compiler which mode to build for 859190391Ssam case "${OPENJDK_TARGET_CPU}" in 860190391Ssam s390) 861190391Ssam ZERO_ARCHFLAG="${COMPILER_TARGET_BITS_FLAG}31" 862190391Ssam ;; 863190391Ssam *) 864190391Ssam ZERO_ARCHFLAG="${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}" 865190391Ssam esac 866190391Ssam FLAGS_COMPILER_CHECK_ARGUMENTS([$ZERO_ARCHFLAG], [], [ZERO_ARCHFLAG=""]) 867190391Ssam AC_SUBST(ZERO_ARCHFLAG) 868190391Ssam 869190391Ssam # Check that the compiler supports -mX (or -qX on AIX) flags 870190391Ssam # Set COMPILER_SUPPORTS_TARGET_BITS_FLAG to 'true' if it does 871190391Ssam FLAGS_COMPILER_CHECK_ARGUMENTS([${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}], 872190391Ssam [COMPILER_SUPPORTS_TARGET_BITS_FLAG=true], 873190391Ssam [COMPILER_SUPPORTS_TARGET_BITS_FLAG=false]) 874190391Ssam AC_SUBST(COMPILER_SUPPORTS_TARGET_BITS_FLAG) 875190391Ssam 876190391Ssam case "${TOOLCHAIN_TYPE}" in 877190391Ssam microsoft) 878190391Ssam CFLAGS_WARNINGS_ARE_ERRORS="-WX" 879190391Ssam ;; 880190391Ssam solstudio) 881190391Ssam CFLAGS_WARNINGS_ARE_ERRORS="-errtags -errwarn=%all" 882190391Ssam ;; 883190391Ssam gcc) 884190391Ssam CFLAGS_WARNINGS_ARE_ERRORS="-Werror" 885190391Ssam ;; 886190391Ssam clang) 887190391Ssam CFLAGS_WARNINGS_ARE_ERRORS="-Werror" 888190391Ssam ;; 889190391Ssam esac 890190391Ssam AC_SUBST(CFLAGS_WARNINGS_ARE_ERRORS) 891190391Ssam]) 892190391Ssam