Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
make/autoconf/flags.m4
branchihse-cflags-rewrite-branch
changeset 56124 b2b9dfdc39c8
parent 48854 345f41527dcc
child 56125 4e2422994c9e
equal deleted inserted replaced
56123:9794cd2de23a 56124:b2b9dfdc39c8 
   204   AC_SUBST($1SYSROOT_LDFLAGS)
 
   204   AC_SUBST($1SYSROOT_LDFLAGS)
 
   205 ])
 
   205 ])
 
   206 
   206 
   207 AC_DEFUN_ONCE([FLAGS_SETUP_INIT_FLAGS],
 
   207 AC_DEFUN_ONCE([FLAGS_SETUP_INIT_FLAGS],
 
   208 [
 
   208 [
 
   209   # COMPILER_TARGET_BITS_FLAG  : option for selecting 32- or 64-bit output
 
   209   FLAGS_SETUP_TOOLCHAIN_CONTROL
 
   210   # COMPILER_COMMAND_FILE_FLAG : option for passing a command file to the compiler
 
   210 
   211   # COMPILER_BINDCMD_FILE_FLAG : option for specifying a file which saves the binder
 
   211   FLAGS_SETUP_ARFLAGS
 
   212   #                              commands produced by the link step (currently AIX only)
 
   212   FLAGS_SETUP_STRIPFLAGS
 
   213   if test "x$TOOLCHAIN_TYPE" = xxlc; then
 
   213 
   214     COMPILER_TARGET_BITS_FLAG="-q"
 
   214   FLAGS_SETUP_RCFLAGS
 
   215     COMPILER_COMMAND_FILE_FLAG="-f"
 
       
   216     COMPILER_BINDCMD_FILE_FLAG="-bloadmap:"
 
       
   217   else
 
       
   218     COMPILER_TARGET_BITS_FLAG="-m"
 
       
   219     COMPILER_COMMAND_FILE_FLAG="@"
 
       
   220     COMPILER_BINDCMD_FILE_FLAG=""
 
       
   221 
       
   222     # The solstudio linker does not support @-files.
 
       
   223     if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
 
       
   224       COMPILER_COMMAND_FILE_FLAG=
 
       
   225     fi
 
       
   226 
       
   227     # Check if @file is supported by gcc
 
       
   228     if test "x$TOOLCHAIN_TYPE" = xgcc; then
 
       
   229       AC_MSG_CHECKING([if @file is supported by gcc])
 
       
   230       # Extra emtpy "" to prevent ECHO from interpreting '--version' as argument
 
       
   231       $ECHO "" "--version" > command.file
 
       
   232       if $CXX @command.file 2>&AS_MESSAGE_LOG_FD >&AS_MESSAGE_LOG_FD; then
 
       
   233         AC_MSG_RESULT(yes)
 
       
   234         COMPILER_COMMAND_FILE_FLAG="@"
 
       
   235       else
 
       
   236         AC_MSG_RESULT(no)
 
       
   237         COMPILER_COMMAND_FILE_FLAG=
 
       
   238       fi
 
       
   239       $RM command.file
 
       
   240     fi
 
       
   241   fi
 
       
   242   AC_SUBST(COMPILER_TARGET_BITS_FLAG)
 
       
   243   AC_SUBST(COMPILER_COMMAND_FILE_FLAG)
 
       
   244   AC_SUBST(COMPILER_BINDCMD_FILE_FLAG)
 
       
   245 
       
   246   # FIXME: figure out if we should select AR flags depending on OS or toolchain.
 
       
   247   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
 
       
   248     ARFLAGS="-r"
 
       
   249   elif test "x$OPENJDK_TARGET_OS" = xaix; then
 
       
   250     ARFLAGS="-X64"
 
       
   251   elif test "x$OPENJDK_TARGET_OS" = xwindows; then
 
       
   252     # lib.exe is used as AR to create static libraries.
 
       
   253     ARFLAGS="-nologo -NODEFAULTLIB:MSVCRT"
 
       
   254   else
 
       
   255     ARFLAGS=""
 
       
   256   fi
 
       
   257   AC_SUBST(ARFLAGS)
 
       
   258 
       
   259   ## Setup strip.
 
       
   260   # FIXME: should this really be per platform, or should it be per toolchain type?
 
       
   261   # strip is not provided by clang or solstudio; so guessing platform makes most sense.
 
       
   262   # FIXME: we should really only export STRIPFLAGS from here, not POST_STRIP_CMD.
 
       
   263   if test "x$OPENJDK_TARGET_OS" = xlinux; then
 
       
   264     STRIPFLAGS="-g"
 
       
   265   elif test "x$OPENJDK_TARGET_OS" = xsolaris; then
 
       
   266     STRIPFLAGS="-x"
 
       
   267   elif test "x$OPENJDK_TARGET_OS" = xmacosx; then
 
       
   268     STRIPFLAGS="-S"
 
       
   269   elif test "x$OPENJDK_TARGET_OS" = xaix; then
 
       
   270     STRIPFLAGS="-X32_64"
 
       
   271   fi
 
       
   272 
       
   273   AC_SUBST(STRIPFLAGS)
 
       
   274 
       
   275   if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 
       
   276     CC_OUT_OPTION=-Fo
 
       
   277     EXE_OUT_OPTION=-out:
 
       
   278     LD_OUT_OPTION=-out:
 
       
   279     AR_OUT_OPTION=-out:
 
       
   280   else
 
       
   281     # The option used to specify the target .o,.a or .so file.
 
       
   282     # When compiling, how to specify the to be created object file.
 
       
   283     CC_OUT_OPTION='-o$(SPACE)'
 
       
   284     # When linking, how to specify the to be created executable.
 
       
   285     EXE_OUT_OPTION='-o$(SPACE)'
 
       
   286     # When linking, how to specify the to be created dynamically linkable library.
 
       
   287     LD_OUT_OPTION='-o$(SPACE)'
 
       
   288     # When archiving, how to specify the to be create static archive for object files.
 
       
   289     AR_OUT_OPTION='rcs$(SPACE)'
 
       
   290   fi
 
       
   291   AC_SUBST(CC_OUT_OPTION)
 
       
   292   AC_SUBST(EXE_OUT_OPTION)
 
       
   293   AC_SUBST(LD_OUT_OPTION)
 
       
   294   AC_SUBST(AR_OUT_OPTION)
 
       
   295 
       
   296   # On Windows, we need to set RC flags.
 
       
   297   if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 
       
   298     RC_FLAGS="-nologo -l0x409"
 
       
   299     JVM_RCFLAGS="-nologo"
 
       
   300     if test "x$DEBUG_LEVEL" = xrelease; then
 
       
   301       RC_FLAGS="$RC_FLAGS -DNDEBUG"
 
       
   302       JVM_RCFLAGS="$JVM_RCFLAGS -DNDEBUG"
 
       
   303     fi
 
       
   304 
       
   305     # The version variables used to create RC_FLAGS may be overridden
 
       
   306     # in a custom configure script, or possibly the command line.
 
       
   307     # Let those variables be expanded at make time in spec.gmk.
 
       
   308     # The \$ are escaped to the shell, and the $(...) variables
 
       
   309     # are evaluated by make.
 
       
   310     RC_FLAGS="$RC_FLAGS \
 
       
   311         -D\"JDK_VERSION_STRING=\$(VERSION_STRING)\" \
 
       
   312         -D\"JDK_COMPANY=\$(COMPANY_NAME)\" \
 
       
   313         -D\"JDK_COMPONENT=\$(PRODUCT_NAME) \$(JDK_RC_PLATFORM_NAME) binary\" \
 
       
   314         -D\"JDK_VER=\$(VERSION_NUMBER)\" \
 
       
   315         -D\"JDK_COPYRIGHT=Copyright \xA9 $COPYRIGHT_YEAR\" \
 
       
   316         -D\"JDK_NAME=\$(PRODUCT_NAME) \$(JDK_RC_PLATFORM_NAME) \$(VERSION_FEATURE)\" \
 
       
   317         -D\"JDK_FVER=\$(subst .,\$(COMMA),\$(VERSION_NUMBER_FOUR_POSITIONS))\""
 
       
   318 
       
   319     JVM_RCFLAGS="$JVM_RCFLAGS \
 
       
   320         -D\"HS_BUILD_ID=\$(VERSION_STRING)\" \
 
       
   321         -D\"HS_COMPANY=\$(COMPANY_NAME)\" \
 
       
   322         -D\"JDK_DOTVER=\$(VERSION_NUMBER_FOUR_POSITIONS)\" \
 
       
   323         -D\"HS_COPYRIGHT=Copyright $COPYRIGHT_YEAR\" \
 
       
   324         -D\"HS_NAME=\$(PRODUCT_NAME) \$(VERSION_SHORT)\" \
 
       
   325         -D\"JDK_VER=\$(subst .,\$(COMMA),\$(VERSION_NUMBER_FOUR_POSITIONS))\" \
 
       
   326         -D\"HS_FNAME=jvm.dll\" \
 
       
   327         -D\"HS_INTERNAL_NAME=jvm\""
 
       
   328   fi
 
       
   329   AC_SUBST(RC_FLAGS)
 
       
   330   AC_SUBST(JVM_RCFLAGS)
 
       
   331 
   215 
   332   if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 
   216   if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 
   333     # silence copyright notice and other headers.
 
   217     # silence copyright notice and other headers.
 
   334     COMMON_CCXXFLAGS="$COMMON_CCXXFLAGS -nologo"
 
   218     COMMON_CCXXFLAGS="$COMMON_CCXXFLAGS -nologo"
 
   335   fi
 
   219   fi
 
   336 ])
 
   220 ])
 
   337 
   221 
   338 AC_DEFUN([FLAGS_SETUP_COMPILER_FLAGS_FOR_LIBS],
 
   222 AC_DEFUN([FLAGS_SETUP_COMPILER_FLAGS_FOR_LIBS],
 
   339 [
 
   223 [
 
   340   ###############################################################################
 
   224   FLAGS_SETUP_SHARED_LIBS
 
   341   #
 
       
   342   # How to compile shared libraries.
 
       
   343   #
 
       
   344 
   225 
   345   if test "x$TOOLCHAIN_TYPE" = xgcc; then
 
   226   if test "x$TOOLCHAIN_TYPE" = xgcc; then
 
   346     PICFLAG="-fPIC"
 
       
   347     C_FLAG_REORDER=''
 
       
   348     CXX_FLAG_REORDER=''
 
       
   349 
       
   350     if test "x$OPENJDK_TARGET_OS" = xmacosx; then
 
   227     if test "x$OPENJDK_TARGET_OS" = xmacosx; then
 
   351       # Linking is different on MacOSX
 
   228       if test "x$STATIC_BUILD" = xfalse; then
 
   352       if test "x$STATIC_BUILD" = xtrue; then
 
       
   353         SHARED_LIBRARY_FLAGS ='-undefined dynamic_lookup'
 
       
   354       else
 
       
   355         SHARED_LIBRARY_FLAGS="-dynamiclib -compatibility_version 1.0.0 -current_version 1.0.0 $PICFLAG"
 
       
   356         JVM_CFLAGS="$JVM_CFLAGS $PICFLAG"
 
   229         JVM_CFLAGS="$JVM_CFLAGS $PICFLAG"
 
   357       fi
 
   230       fi
 
   358       SET_EXECUTABLE_ORIGIN='-Wl,-rpath,@loader_path$(or [$]1,/.)'
 
       
   359       SET_SHARED_LIBRARY_ORIGIN="$SET_EXECUTABLE_ORIGIN"
 
       
   360       SET_SHARED_LIBRARY_NAME='-Wl,-install_name,@rpath/[$]1'
 
       
   361       SET_SHARED_LIBRARY_MAPFILE='-Wl,-exported_symbols_list,[$]1'
 
       
   362     else
 
       
   363       # Default works for linux, might work on other platforms as well.
 
       
   364       SHARED_LIBRARY_FLAGS='-shared'
 
       
   365       SET_EXECUTABLE_ORIGIN='-Wl,-rpath,\$$ORIGIN[$]1'
 
       
   366       SET_SHARED_LIBRARY_ORIGIN="-Wl,-z,origin $SET_EXECUTABLE_ORIGIN"
 
       
   367       SET_SHARED_LIBRARY_NAME='-Wl,-soname=[$]1'
 
       
   368       SET_SHARED_LIBRARY_MAPFILE='-Wl,-version-script=[$]1'
 
       
   369     fi
 
   231     fi
 
   370   elif test "x$TOOLCHAIN_TYPE" = xclang; then
 
   232   elif test "x$TOOLCHAIN_TYPE" = xclang; then
 
   371     C_FLAG_REORDER=''
 
       
   372     CXX_FLAG_REORDER=''
 
       
   373 
       
   374     if test "x$OPENJDK_TARGET_OS" = xmacosx; then
 
   233     if test "x$OPENJDK_TARGET_OS" = xmacosx; then
 
   375       # Linking is different on MacOSX
 
       
   376       PICFLAG=''
 
       
   377       SHARED_LIBRARY_FLAGS="-dynamiclib -compatibility_version 1.0.0 -current_version 1.0.0 $PICFLAG"
 
       
   378       SET_EXECUTABLE_ORIGIN='-Wl,-rpath,@loader_path$(or [$]1,/.)'
 
       
   379       SET_SHARED_LIBRARY_ORIGIN="$SET_EXECUTABLE_ORIGIN"
 
       
   380       SET_SHARED_LIBRARY_NAME='-Wl,-install_name,@rpath/[$]1'
 
       
   381       SET_SHARED_LIBRARY_MAPFILE='-Wl,-exported_symbols_list,[$]1'
 
       
   382 
       
   383       if test "x$STATIC_BUILD" = xfalse; then
 
   234       if test "x$STATIC_BUILD" = xfalse; then
 
   384         JVM_CFLAGS="$JVM_CFLAGS -fPIC"
 
   235         JVM_CFLAGS="$JVM_CFLAGS -fPIC"
 
   385       fi
 
   236       fi
 
   386     else
 
   237     fi
 
   387       # Default works for linux, might work on other platforms as well.
 
       
   388       PICFLAG='-fPIC'
 
       
   389       SHARED_LIBRARY_FLAGS='-shared'
 
       
   390       SET_EXECUTABLE_ORIGIN='-Wl,-rpath,\$$ORIGIN[$]1'
 
       
   391       SET_SHARED_LIBRARY_NAME='-Wl,-soname=[$]1'
 
       
   392       SET_SHARED_LIBRARY_MAPFILE='-Wl,-version-script=[$]1'
 
       
   393 
       
   394       # arm specific settings
 
       
   395       if test "x$OPENJDK_TARGET_CPU" = "xarm"; then
 
       
   396         # '-Wl,-z,origin' isn't used on arm.
 
       
   397         SET_SHARED_LIBRARY_ORIGIN='-Wl,-rpath,\$$$$ORIGIN[$]1'
 
       
   398       else
 
       
   399         SET_SHARED_LIBRARY_ORIGIN="-Wl,-z,origin $SET_EXECUTABLE_ORIGIN"
 
       
   400       fi
 
       
   401 
       
   402     fi
 
       
   403   elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
 
       
   404     if test "x$OPENJDK_TARGET_CPU" = xsparcv9; then
 
       
   405       PICFLAG="-xcode=pic32"
 
       
   406     else
 
       
   407       PICFLAG="-KPIC"
 
       
   408     fi
 
       
   409     C_FLAG_REORDER='-xF'
 
       
   410     CXX_FLAG_REORDER='-xF'
 
       
   411     SHARED_LIBRARY_FLAGS="-G"
 
       
   412     SET_EXECUTABLE_ORIGIN='-R\$$ORIGIN[$]1'
 
       
   413     SET_SHARED_LIBRARY_ORIGIN="$SET_EXECUTABLE_ORIGIN"
 
       
   414     SET_SHARED_LIBRARY_NAME='-h [$]1'
 
       
   415     SET_SHARED_LIBRARY_MAPFILE='-M[$]1'
 
       
   416   elif test "x$TOOLCHAIN_TYPE" = xxlc; then
 
   238   elif test "x$TOOLCHAIN_TYPE" = xxlc; then
 
   417     # '-qpic' defaults to 'qpic=small'. This means that the compiler generates only
 
       
   418     # one instruction for accessing the TOC. If the TOC grows larger than 64K, the linker
 
       
   419     # will have to patch this single instruction with a call to some out-of-order code which
 
       
   420     # does the load from the TOC. This is of course slow. But in that case we also would have
 
       
   421     # to use '-bbigtoc' for linking anyway so we could also change the PICFLAG to 'qpic=large'.
 
       
   422     # With 'qpic=large' the compiler will by default generate a two-instruction sequence which
 
       
   423     # can be patched directly by the linker and does not require a jump to out-of-order code.
 
       
   424     # Another alternative instead of using 'qpic=large -bbigtoc' may be to use '-qminimaltoc'
 
       
   425     # instead. This creates a distinct TOC for every compilation unit (and thus requires two
 
       
   426     # loads for accessing a global variable). But there are rumors that this may be seen as a
 
       
   427     # 'performance feature' because of improved code locality of the symbols used in a
 
       
   428     # compilation unit.
 
       
   429     PICFLAG="-qpic"
 
       
   430     JVM_CFLAGS="$JVM_CFLAGS $PICFLAG"
 
   239     JVM_CFLAGS="$JVM_CFLAGS $PICFLAG"
 
   431     C_FLAG_REORDER=''
 
   240   fi
 
   432     CXX_FLAG_REORDER=''
 
   241 
   433     SHARED_LIBRARY_FLAGS="-qmkshrobj -bM:SRE -bnoentry"
 
       
   434     SET_EXECUTABLE_ORIGIN=""
 
       
   435     SET_SHARED_LIBRARY_ORIGIN=''
 
       
   436     SET_SHARED_LIBRARY_NAME=''
 
       
   437     SET_SHARED_LIBRARY_MAPFILE=''
 
       
   438   elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 
       
   439     PICFLAG=""
 
       
   440     C_FLAG_REORDER=''
 
       
   441     CXX_FLAG_REORDER=''
 
       
   442     SHARED_LIBRARY_FLAGS="-dll"
 
       
   443     SET_EXECUTABLE_ORIGIN=''
 
       
   444     SET_SHARED_LIBRARY_ORIGIN=''
 
       
   445     SET_SHARED_LIBRARY_NAME=''
 
       
   446     SET_SHARED_LIBRARY_MAPFILE='-def:[$]1'
 
       
   447   fi
 
       
   448 
       
   449   AC_SUBST(C_FLAG_REORDER)
 
       
   450   AC_SUBST(CXX_FLAG_REORDER)
 
       
   451   AC_SUBST(SET_EXECUTABLE_ORIGIN)
 
       
   452   AC_SUBST(SET_SHARED_LIBRARY_ORIGIN)
 
       
   453   AC_SUBST(SET_SHARED_LIBRARY_NAME)
 
       
   454   AC_SUBST(SET_SHARED_LIBRARY_MAPFILE)
 
       
   455   AC_SUBST(SHARED_LIBRARY_FLAGS)
 
       
   456 
   242 
   457   # The (cross) compiler is now configured, we can now test capabilities
 
   243   # The (cross) compiler is now configured, we can now test capabilities
 
   458   # of the target platform.
 
   244   # of the target platform.
 
   459 ])
 
   245 ])
 
   460 
   246 
   480 #   (If you expect perfect errno behavior, do not use this)
 
   266 #   (If you expect perfect errno behavior, do not use this)
 
   481 # -xlibmopt: Use optimized math routines (CURRENTLY DISABLED)
 
   267 # -xlibmopt: Use optimized math routines (CURRENTLY DISABLED)
 
   482 #   (If you expect perfect errno behavior, do not use this)
 
   268 #   (If you expect perfect errno behavior, do not use this)
 
   483 #  Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
 
   269 #  Can cause undefined external on Solaris 8 X86 on __sincos, removing for now
 
   484 
   270 
   485     # FIXME: this will never happen since sparc != sparcv9, ie 32 bit, which we don't build anymore.
 
       
   486     # Bug?
 
       
   487     #if test "x$OPENJDK_TARGET_CPU" = xsparc; then
 
       
   488     #  CFLAGS_JDK="${CFLAGS_JDK} -xmemalign=4s"
 
       
   489     #  CXXFLAGS_JDK="${CXXFLAGS_JDK} -xmemalign=4s"
 
       
   490     #fi
 
       
   491 
       
   492 AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION],
 
   271 AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_OPTIMIZATION],
 
   493 [
 
   272 [
 
   494 
   273   FLAGS_SETUP_DEBUG_SYMBOLS
 
   495   ###############################################################################
 
   274   FLAGS_SETUP_QUALITY_CHECKS
 
   496   #
 
   275   FLAGS_SETUP_OPTIMIZATION
 
   497   # Setup the opt flags for different compilers
 
       
   498   # and different operating systems.
 
       
   499   #
 
       
   500 
       
   501   # FIXME: this was indirectly the old default, but just inherited.
 
       
   502   # if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 
       
   503   #   C_FLAG_DEPS="-MMD -MF"
 
       
   504   # fi
 
       
   505 
       
   506   # Generate make dependency files
 
       
   507   if test "x$TOOLCHAIN_TYPE" = xgcc; then
 
       
   508     C_FLAG_DEPS="-MMD -MF"
 
       
   509   elif test "x$TOOLCHAIN_TYPE" = xclang; then
 
       
   510     C_FLAG_DEPS="-MMD -MF"
 
       
   511   elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
 
       
   512     C_FLAG_DEPS="-xMMD -xMF"
 
       
   513   elif test "x$TOOLCHAIN_TYPE" = xxlc; then
 
       
   514     C_FLAG_DEPS="-qmakedep=gcc -MF"
 
       
   515   fi
 
       
   516   CXX_FLAG_DEPS="$C_FLAG_DEPS"
 
       
   517   AC_SUBST(C_FLAG_DEPS)
 
       
   518   AC_SUBST(CXX_FLAG_DEPS)
 
       
   519 
       
   520   # Debug symbols
 
       
   521   if test "x$TOOLCHAIN_TYPE" = xgcc; then
 
       
   522     if test "x$OPENJDK_TARGET_CPU_BITS" = "x64" && test "x$DEBUG_LEVEL" = "xfastdebug"; then
 
       
   523       # reduce from default "-g2" option to save space
 
       
   524       CFLAGS_DEBUG_SYMBOLS="-g1"
 
       
   525       CXXFLAGS_DEBUG_SYMBOLS="-g1"
 
       
   526     else
 
       
   527       CFLAGS_DEBUG_SYMBOLS="-g"
 
       
   528       CXXFLAGS_DEBUG_SYMBOLS="-g"
 
       
   529     fi
 
       
   530   elif test "x$TOOLCHAIN_TYPE" = xclang; then
 
       
   531     CFLAGS_DEBUG_SYMBOLS="-g"
 
       
   532     CXXFLAGS_DEBUG_SYMBOLS="-g"
 
       
   533   elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
 
       
   534     CFLAGS_DEBUG_SYMBOLS="-g -xs"
 
       
   535     # -g0 enables debug symbols without disabling inlining.
 
       
   536     CXXFLAGS_DEBUG_SYMBOLS="-g0 -xs"
 
       
   537   elif test "x$TOOLCHAIN_TYPE" = xxlc; then
 
       
   538     CFLAGS_DEBUG_SYMBOLS="-g"
 
       
   539     CXXFLAGS_DEBUG_SYMBOLS="-g"
 
       
   540   elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 
       
   541     CFLAGS_DEBUG_SYMBOLS="-Zi"
 
       
   542     CXXFLAGS_DEBUG_SYMBOLS="-Zi"
 
       
   543   fi
 
       
   544   AC_SUBST(CFLAGS_DEBUG_SYMBOLS)
 
       
   545   AC_SUBST(CXXFLAGS_DEBUG_SYMBOLS)
 
       
   546 
   276 
   547   # Debug symbols for JVM_CFLAGS
 
   277   # Debug symbols for JVM_CFLAGS
 
   548   if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
 
   278   if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
 
   549     JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -xs"
 
   279     JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS -xs"
 
   550     if test "x$DEBUG_LEVEL" = xslowdebug; then
 
   280     if test "x$DEBUG_LEVEL" = xslowdebug; then
 
   561   AC_SUBST(JVM_CFLAGS_SYMBOLS)
 
   291   AC_SUBST(JVM_CFLAGS_SYMBOLS)
 
   562 
   292 
   563   # bounds, memory and behavior checking options
 
   293   # bounds, memory and behavior checking options
 
   564   if test "x$TOOLCHAIN_TYPE" = xgcc; then
 
   294   if test "x$TOOLCHAIN_TYPE" = xgcc; then
 
   565     case $DEBUG_LEVEL in
 
   295     case $DEBUG_LEVEL in
 
   566     release )
 
       
   567       # no adjustment
 
       
   568       ;;
 
       
   569     fastdebug )
 
       
   570       # no adjustment
 
       
   571       ;;
 
       
   572     slowdebug )
 
   296     slowdebug )
 
   573       # FIXME: By adding this to C(XX)FLAGS_DEBUG_OPTIONS/JVM_CFLAGS_SYMBOLS it
 
   297       # FIXME: By adding this to C(XX)FLAGS_DEBUG_OPTIONS/JVM_CFLAGS_SYMBOLS it
 
   574       # get's added conditionally on whether we produce debug symbols or not.
 
   298       # get's added conditionally on whether we produce debug symbols or not.
 
   575       # This is most likely not really correct.
 
   299       # This is most likely not really correct.
 
   576 
   300 
   577       # Add runtime stack smashing and undefined behavior checks.
 
       
   578       # Not all versions of gcc support -fstack-protector
 
       
   579       STACK_PROTECTOR_CFLAG="-fstack-protector-all"
 
       
   580       FLAGS_COMPILER_CHECK_ARGUMENTS(ARGUMENT: [$STACK_PROTECTOR_CFLAG -Werror], IF_FALSE: [STACK_PROTECTOR_CFLAG=""])
 
       
   581 
       
   582       CFLAGS_DEBUG_OPTIONS="$STACK_PROTECTOR_CFLAG --param ssp-buffer-size=1"
 
       
   583       CXXFLAGS_DEBUG_OPTIONS="$STACK_PROTECTOR_CFLAG --param ssp-buffer-size=1"
 
       
   584       if test "x$STACK_PROTECTOR_CFLAG" != x; then
 
   301       if test "x$STACK_PROTECTOR_CFLAG" != x; then
 
   585         JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS $STACK_PROTECTOR_CFLAG --param ssp-buffer-size=1"
 
   302         JVM_CFLAGS_SYMBOLS="$JVM_CFLAGS_SYMBOLS $STACK_PROTECTOR_CFLAG --param ssp-buffer-size=1"
 
   586       fi
 
   303       fi
 
   587       ;;
 
   304       ;;
 
   588     esac
 
   305     esac
 
   593       if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
 
   310       if test "x$OPENJDK_TARGET_CPU" = xx86_64; then
 
   594         JVM_CFLAGS="$JVM_CFLAGS -homeparams"
 
   311         JVM_CFLAGS="$JVM_CFLAGS -homeparams"
 
   595       fi
 
   312       fi
 
   596     fi
 
   313     fi
 
   597   fi
 
   314   fi
 
   598 
       
   599   # Optimization levels
 
       
   600   if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
 
       
   601     CC_HIGHEST="$CC_HIGHEST -fns -fsimple -fsingle -xbuiltin=%all -xdepend -xrestrict -xlibmil"
 
       
   602 
       
   603     if test "x$OPENJDK_TARGET_CPU_ARCH" = "xx86"; then
 
       
   604       # FIXME: seems we always set -xregs=no%frameptr; put it elsewhere more global?
 
       
   605       C_O_FLAG_HIGHEST_JVM="-xO4"
 
       
   606       C_O_FLAG_HIGHEST="-xO4 -Wu,-O4~yz $CC_HIGHEST -xalias_level=basic -xregs=no%frameptr"
 
       
   607       C_O_FLAG_HI="-xO4 -Wu,-O4~yz -xregs=no%frameptr"
 
       
   608       C_O_FLAG_NORM="-xO2 -Wu,-O2~yz -xregs=no%frameptr"
 
       
   609       C_O_FLAG_DEBUG="-xregs=no%frameptr"
 
       
   610       C_O_FLAG_DEBUG_JVM=""
 
       
   611       C_O_FLAG_NONE="-xregs=no%frameptr"
 
       
   612       CXX_O_FLAG_HIGHEST_JVM="-xO4"
 
       
   613       CXX_O_FLAG_HIGHEST="-xO4 -Qoption ube -O4~yz $CC_HIGHEST -xregs=no%frameptr"
 
       
   614       CXX_O_FLAG_HI="-xO4 -Qoption ube -O4~yz -xregs=no%frameptr"
 
       
   615       CXX_O_FLAG_NORM="-xO2 -Qoption ube -O2~yz -xregs=no%frameptr"
 
       
   616       CXX_O_FLAG_DEBUG="-xregs=no%frameptr"
 
       
   617       CXX_O_FLAG_DEBUG_JVM=""
 
       
   618       CXX_O_FLAG_NONE="-xregs=no%frameptr"
 
       
   619       if test "x$OPENJDK_TARGET_CPU_BITS" = "x32"; then
 
       
   620         C_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST -xchip=pentium"
 
       
   621         CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_HIGHEST -xchip=pentium"
 
       
   622       fi
 
       
   623     elif test "x$OPENJDK_TARGET_CPU_ARCH" = "xsparc"; then
 
       
   624       C_O_FLAG_HIGHEST_JVM="-xO4"
 
       
   625       C_O_FLAG_HIGHEST="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0 $CC_HIGHEST -xalias_level=basic -xprefetch=auto,explicit -xchip=ultra"
 
       
   626       C_O_FLAG_HI="-xO4 -Wc,-Qrm-s -Wc,-Qiselect-T0"
 
       
   627       C_O_FLAG_NORM="-xO2 -Wc,-Qrm-s -Wc,-Qiselect-T0"
 
       
   628       C_O_FLAG_DEBUG=""
 
       
   629       C_O_FLAG_DEBUG_JVM=""
 
       
   630       C_O_FLAG_NONE=""
 
       
   631       CXX_O_FLAG_HIGHEST_JVM="-xO4"
 
       
   632       CXX_O_FLAG_HIGHEST="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0 $CC_HIGHEST -xprefetch=auto,explicit -xchip=ultra"
 
       
   633       CXX_O_FLAG_HI="-xO4 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0"
 
       
   634       CXX_O_FLAG_NORM="-xO2 -Qoption cg -Qrm-s -Qoption cg -Qiselect-T0"
 
       
   635       CXX_O_FLAG_DEBUG=""
 
       
   636       CXX_O_FLAG_DEBUG_JVM=""
 
       
   637       CXX_O_FLAG_NONE=""
 
       
   638     fi
 
       
   639   else
 
       
   640     # The remaining toolchains share opt flags between CC and CXX;
 
       
   641     # setup for C and duplicate afterwards.
 
       
   642     if test "x$TOOLCHAIN_TYPE" = xgcc; then
 
       
   643       if test "x$OPENJDK_TARGET_OS" = xmacosx; then
 
       
   644         # On MacOSX we optimize for size, something
 
       
   645         # we should do for all platforms?
 
       
   646         C_O_FLAG_HIGHEST_JVM="-Os"
 
       
   647         C_O_FLAG_HIGHEST="-Os"
 
       
   648         C_O_FLAG_HI="-Os"
 
       
   649         C_O_FLAG_NORM="-Os"
 
       
   650         C_O_FLAG_SIZE="-Os"
 
       
   651       else
 
       
   652         C_O_FLAG_HIGHEST_JVM="-O3"
 
       
   653         C_O_FLAG_HIGHEST="-O3"
 
       
   654         C_O_FLAG_HI="-O3"
 
       
   655         C_O_FLAG_NORM="-O2"
 
       
   656         C_O_FLAG_SIZE="-Os"
 
       
   657       fi
 
       
   658       C_O_FLAG_DEBUG="-O0"
 
       
   659       if test "x$OPENJDK_TARGET_OS" = xmacosx; then
 
       
   660         C_O_FLAG_DEBUG_JVM=""
 
       
   661       elif test "x$OPENJDK_TARGET_OS" = xlinux; then
 
       
   662         C_O_FLAG_DEBUG_JVM="-O0"
 
       
   663       fi
 
       
   664       C_O_FLAG_NONE="-O0"
 
       
   665     elif test "x$TOOLCHAIN_TYPE" = xclang; then
 
       
   666       if test "x$OPENJDK_TARGET_OS" = xmacosx; then
 
       
   667         # On MacOSX we optimize for size, something
 
       
   668         # we should do for all platforms?
 
       
   669         C_O_FLAG_HIGHEST_JVM="-Os"
 
       
   670         C_O_FLAG_HIGHEST="-Os"
 
       
   671         C_O_FLAG_HI="-Os"
 
       
   672         C_O_FLAG_NORM="-Os"
 
       
   673         C_O_FLAG_SIZE="-Os"
 
       
   674       else
 
       
   675         C_O_FLAG_HIGHEST_JVM="-O3"
 
       
   676         C_O_FLAG_HIGHEST="-O3"
 
       
   677         C_O_FLAG_HI="-O3"
 
       
   678         C_O_FLAG_NORM="-O2"
 
       
   679         C_O_FLAG_SIZE="-Os"
 
       
   680       fi
 
       
   681       C_O_FLAG_DEBUG="-O0"
 
       
   682       if test "x$OPENJDK_TARGET_OS" = xmacosx; then
 
       
   683         C_O_FLAG_DEBUG_JVM=""
 
       
   684       elif test "x$OPENJDK_TARGET_OS" = xlinux; then
 
       
   685         C_O_FLAG_DEBUG_JVM="-O0"
 
       
   686       fi
 
       
   687       C_O_FLAG_NONE="-O0"
 
       
   688     elif test "x$TOOLCHAIN_TYPE" = xxlc; then
 
       
   689       C_O_FLAG_HIGHEST_JVM="-O3 -qhot=level=1 -qinline -qinlglue"
 
       
   690       C_O_FLAG_HIGHEST="-O3 -qhot=level=1 -qinline -qinlglue"
 
       
   691       C_O_FLAG_HI="-O3 -qinline -qinlglue"
 
       
   692       C_O_FLAG_NORM="-O2"
 
       
   693       C_O_FLAG_DEBUG="-qnoopt"
 
       
   694       # FIXME: Value below not verified.
 
       
   695       C_O_FLAG_DEBUG_JVM=""
 
       
   696       C_O_FLAG_NONE="-qnoopt"
 
       
   697     elif test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 
       
   698       C_O_FLAG_HIGHEST_JVM="-O2 -Oy-"
 
       
   699       C_O_FLAG_HIGHEST="-O2"
 
       
   700       C_O_FLAG_HI="-O1"
 
       
   701       C_O_FLAG_NORM="-O1"
 
       
   702       C_O_FLAG_DEBUG="-Od"
 
       
   703       C_O_FLAG_DEBUG_JVM=""
 
       
   704       C_O_FLAG_NONE="-Od"
 
       
   705       C_O_FLAG_SIZE="-Os"
 
       
   706     fi
 
       
   707     CXX_O_FLAG_HIGHEST_JVM="$C_O_FLAG_HIGHEST_JVM"
 
       
   708     CXX_O_FLAG_HIGHEST="$C_O_FLAG_HIGHEST"
 
       
   709     CXX_O_FLAG_HI="$C_O_FLAG_HI"
 
       
   710     CXX_O_FLAG_NORM="$C_O_FLAG_NORM"
 
       
   711     CXX_O_FLAG_DEBUG="$C_O_FLAG_DEBUG"
 
       
   712     CXX_O_FLAG_DEBUG_JVM="$C_O_FLAG_DEBUG_JVM"
 
       
   713     CXX_O_FLAG_NONE="$C_O_FLAG_NONE"
 
       
   714     CXX_O_FLAG_SIZE="$C_O_FLAG_SIZE"
 
       
   715   fi
 
       
   716 
       
   717   # Adjust optimization flags according to debug level.
 
       
   718   case $DEBUG_LEVEL in
 
       
   719     release )
 
       
   720       # no adjustment
 
       
   721       ;;
 
       
   722     fastdebug )
 
       
   723       # Not quite so much optimization
 
       
   724       C_O_FLAG_HI="$C_O_FLAG_NORM"
 
       
   725       CXX_O_FLAG_HI="$CXX_O_FLAG_NORM"
 
       
   726       ;;
 
       
   727     slowdebug )
 
       
   728       # Disable optimization
 
       
   729       C_O_FLAG_HIGHEST_JVM="$C_O_FLAG_DEBUG_JVM"
 
       
   730       C_O_FLAG_HIGHEST="$C_O_FLAG_DEBUG"
 
       
   731       C_O_FLAG_HI="$C_O_FLAG_DEBUG"
 
       
   732       C_O_FLAG_NORM="$C_O_FLAG_DEBUG"
 
       
   733       C_O_FLAG_SIZE="$C_O_FLAG_DEBUG"
 
       
   734       CXX_O_FLAG_HIGHEST_JVM="$CXX_O_FLAG_DEBUG_JVM"
 
       
   735       CXX_O_FLAG_HIGHEST="$CXX_O_FLAG_DEBUG"
 
       
   736       CXX_O_FLAG_HI="$CXX_O_FLAG_DEBUG"
 
       
   737       CXX_O_FLAG_NORM="$CXX_O_FLAG_DEBUG"
 
       
   738       CXX_O_FLAG_SIZE="$CXX_O_FLAG_DEBUG"
 
       
   739       ;;
 
       
   740   esac
 
       
   741 
       
   742   AC_SUBST(C_O_FLAG_HIGHEST_JVM)
 
       
   743   AC_SUBST(C_O_FLAG_HIGHEST)
 
       
   744   AC_SUBST(C_O_FLAG_HI)
 
       
   745   AC_SUBST(C_O_FLAG_NORM)
 
       
   746   AC_SUBST(C_O_FLAG_DEBUG)
 
       
   747   AC_SUBST(C_O_FLAG_NONE)
 
       
   748   AC_SUBST(C_O_FLAG_SIZE)
 
       
   749   AC_SUBST(CXX_O_FLAG_HIGHEST_JVM)
 
       
   750   AC_SUBST(CXX_O_FLAG_HIGHEST)
 
       
   751   AC_SUBST(CXX_O_FLAG_HI)
 
       
   752   AC_SUBST(CXX_O_FLAG_NORM)
 
       
   753   AC_SUBST(CXX_O_FLAG_DEBUG)
 
       
   754   AC_SUBST(CXX_O_FLAG_NONE)
 
       
   755   AC_SUBST(CXX_O_FLAG_SIZE)
 
       
   756 ])
 
   315 ])
 
   757 
   316 
   758 
   317 
   759 AC_DEFUN([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
 
   318 AC_DEFUN([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
 
   760 [
 
   319 [
 
   771   if test "x$LIBS" = "x-lrt "; then
 
   330   if test "x$LIBS" = "x-lrt "; then
 
   772     CLOCK_GETTIME_IN_LIBRT=true
 
   331     CLOCK_GETTIME_IN_LIBRT=true
 
   773   fi
 
   332   fi
 
   774   LIBS="$save_LIBS"
 
   333   LIBS="$save_LIBS"
 
   775 
   334 
       
   335   FLAGS_OS=OPENJDK_TARGET_OS
 
       
   336   FLAGS_OS_TYPE=OPENJDK_TARGET_OS_TYPE
 
       
   337   FLAGS_CPU=OPENJDK_TARGET_CPU
 
       
   338   FLAGS_CPU_ARCH=OPENJDK_TARGET_CPU_ARCH
 
       
   339   FLAGS_CPU_BITS=OPENJDK_TARGET_CPU_BITS
 
       
   340   FLAGS_CPU_ENDIAN=OPENJDK_TARGET_CPU_ENDIAN
 
       
   341   FLAGS_CPU_LEGACY=OPENJDK_TARGET_CPU_LEGACY
 
       
   342   FLAGS_ADD_LP64=OPENJDK_TARGET_ADD_LP64
 
       
   343 
   776   FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK_HELPER([TARGET])
 
   344   FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK_HELPER([TARGET])
 
       
   345 
       
   346   FLAGS_OS=OPENJDK_BUILD_OS
 
       
   347   FLAGS_OS_TYPE=OPENJDK_BUILD_OS_TYPE
 
       
   348   FLAGS_CPU=OPENJDK_BUILD_CPU
 
       
   349   FLAGS_CPU_ARCH=OPENJDK_BUILD_CPU_ARCH
 
       
   350   FLAGS_CPU_BITS=OPENJDK_BUILD_CPU_BITS
 
       
   351   FLAGS_CPU_ENDIAN=OPENJDK_BUILD_CPU_ENDIAN
 
       
   352   FLAGS_CPU_LEGACY=OPENJDK_BUILD_CPU_LEGACY
 
       
   353   FLAGS_ADD_LP64=OPENJDK_BUILD_ADD_LP64=
 
       
   354 
   777   FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK_HELPER([BUILD], [OPENJDK_BUILD_])
 
   355   FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK_HELPER([BUILD], [OPENJDK_BUILD_])
 
   778 
   356 
   779   # Tests are only ever compiled for TARGET
 
   357   # Tests are only ever compiled for TARGET
 
   780   # Flags for compiling test libraries
 
   358   # Flags for compiling test libraries
 
   781   CFLAGS_TESTLIB="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"
 
   359   CFLAGS_TESTLIB="$COMMON_CCXXFLAGS_JDK $CFLAGS_JDK $PICFLAG $CFLAGS_JDKLIB_EXTRA"
 
   804 # $2 - Optional prefix for each variable defined.
 
   382 # $2 - Optional prefix for each variable defined.
 
   805 AC_DEFUN([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK_HELPER],
 
   383 AC_DEFUN([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK_HELPER],
 
   806 [
 
   384 [
 
   807   # Special extras...
 
   385   # Special extras...
 
   808   if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
 
   386   if test "x$TOOLCHAIN_TYPE" = xsolstudio; then
 
   809     if test "x$OPENJDK_$1_CPU_ARCH" = "xsparc"; then
 
   387     if test "x$FLAGS_CPU_ARCH" = "xsparc"; then
 
   810       $2CFLAGS_JDKLIB_EXTRA="${$2CFLAGS_JDKLIB_EXTRA} -xregs=no%appl"
 
   388       $2CFLAGS_JDKLIB_EXTRA="${$2CFLAGS_JDKLIB_EXTRA} -xregs=no%appl"
 
   811       $2CXXFLAGS_JDKLIB_EXTRA="${$2CXXFLAGS_JDKLIB_EXTRA} -xregs=no%appl"
 
   389       $2CXXFLAGS_JDKLIB_EXTRA="${$2CXXFLAGS_JDKLIB_EXTRA} -xregs=no%appl"
 
   812     fi
 
   390     fi
 
   813     $2CFLAGS_JDKLIB_EXTRA="${$2CFLAGS_JDKLIB_EXTRA} -errtags=yes -errfmt"
 
   391     $2CFLAGS_JDKLIB_EXTRA="${$2CFLAGS_JDKLIB_EXTRA} -errtags=yes -errfmt"
 
   814     $2CXXFLAGS_JDKLIB_EXTRA="${$2CXXFLAGS_JDKLIB_EXTRA} -errtags=yes -errfmt"
 
   392     $2CXXFLAGS_JDKLIB_EXTRA="${$2CXXFLAGS_JDKLIB_EXTRA} -errtags=yes -errfmt"
 
   844   #    $2COMMON_CCXXFLAGS_JDK - common to C and C++
 
   422   #    $2COMMON_CCXXFLAGS_JDK - common to C and C++
 
   845   if test "x$TOOLCHAIN_TYPE" = xgcc; then
 
   423   if test "x$TOOLCHAIN_TYPE" = xgcc; then
 
   846     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_GNU_SOURCE"
 
   424     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_GNU_SOURCE"
 
   847     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_REENTRANT"
 
   425     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_REENTRANT"
 
   848     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -fcheck-new"
 
   426     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -fcheck-new"
 
   849     if test "x$OPENJDK_$1_CPU" = xx86; then
 
   427     if test "x$FLAGS_CPU" = xx86; then
 
   850       # Force compatibility with i586 on 32 bit intel platforms.
 
   428       # Force compatibility with i586 on 32 bit intel platforms.
 
   851       $2COMMON_CCXXFLAGS="${$2COMMON_CCXXFLAGS} -march=i586"
 
   429       $2COMMON_CCXXFLAGS="${$2COMMON_CCXXFLAGS} -march=i586"
 
   852       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -march=i586"
 
   430       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -march=i586"
 
   853     fi
 
   431     fi
 
   854     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS [$]$2COMMON_CCXXFLAGS_JDK -Wall -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
 
   432     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS [$]$2COMMON_CCXXFLAGS_JDK -Wall -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
 
   855         -pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
 
   433         -pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
 
   856     case $OPENJDK_$1_CPU_ARCH in
 
   434     case $FLAGS_CPU_ARCH in
 
   857       arm )
 
   435       arm )
 
   858         # on arm we don't prevent gcc to omit frame pointer but do prevent strict aliasing
 
   436         # on arm we don't prevent gcc to omit frame pointer but do prevent strict aliasing
 
   859         $2CFLAGS_JDK="${$2CFLAGS_JDK} -fno-strict-aliasing"
 
   437         $2CFLAGS_JDK="${$2CFLAGS_JDK} -fno-strict-aliasing"
 
   860         $2COMMON_CCXXFLAGS_JDK="${$2COMMON_CCXXFLAGS_JDK} -fsigned-char"
 
   438         $2COMMON_CCXXFLAGS_JDK="${$2COMMON_CCXXFLAGS_JDK} -fsigned-char"
 
   861         ;;
 
   439         ;;
 
   878 
   456 
   879     # Restrict the debug information created by Clang to avoid
 
   457     # Restrict the debug information created by Clang to avoid
 
   880     # too big object files and speed the build up a little bit
 
   458     # too big object files and speed the build up a little bit
 
   881     # (see http://llvm.org/bugs/show_bug.cgi?id=7554)
 
   459     # (see http://llvm.org/bugs/show_bug.cgi?id=7554)
 
   882     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -flimit-debug-info"
 
   460     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -flimit-debug-info"
 
   883     if test "x$OPENJDK_$1_OS" = xlinux; then
 
   461     if test "x$FLAGS_OS" = xlinux; then
 
   884       if test "x$OPENJDK_$1_CPU" = xx86; then
 
   462       if test "x$FLAGS_CPU" = xx86; then
 
   885         # Force compatibility with i586 on 32 bit intel platforms.
 
   463         # Force compatibility with i586 on 32 bit intel platforms.
 
   886         $2COMMON_CCXXFLAGS="${$2COMMON_CCXXFLAGS} -march=i586"
 
   464         $2COMMON_CCXXFLAGS="${$2COMMON_CCXXFLAGS} -march=i586"
 
   887         $2JVM_CFLAGS="[$]$2JVM_CFLAGS -march=i586"
 
   465         $2JVM_CFLAGS="[$]$2JVM_CFLAGS -march=i586"
 
   888       fi
 
   466       fi
 
   889       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -Wno-sometimes-uninitialized"
 
   467       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -Wno-sometimes-uninitialized"
 
   890       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS [$]$2COMMON_CCXXFLAGS_JDK -Wall -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
 
   468       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS [$]$2COMMON_CCXXFLAGS_JDK -Wall -Wextra -Wno-unused -Wno-unused-parameter -Wformat=2 \
 
   891           -pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
 
   469           -pipe -D_GNU_SOURCE -D_REENTRANT -D_LARGEFILE64_SOURCE"
 
   892       case $OPENJDK_$1_CPU_ARCH in
 
   470       case $FLAGS_CPU_ARCH in
 
   893         ppc )
 
   471         ppc )
 
   894           # on ppc we don't prevent gcc to omit frame pointer but do prevent strict aliasing
 
   472           # on ppc we don't prevent gcc to omit frame pointer but do prevent strict aliasing
 
   895           $2CFLAGS_JDK="${$2CFLAGS_JDK} -fno-strict-aliasing"
 
   473           $2CFLAGS_JDK="${$2CFLAGS_JDK} -fno-strict-aliasing"
 
   896           ;;
 
   474           ;;
 
   897         * )
 
   475         * )
 
   901       esac
 
   479       esac
 
   902     fi
 
   480     fi
 
   903   elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
 
   481   elif test "x$TOOLCHAIN_TYPE" = xsolstudio; then
 
   904     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DSPARC_WORKS"
 
   482     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DSPARC_WORKS"
 
   905     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS [$]$2COMMON_CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
 
   483     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS [$]$2COMMON_CCXXFLAGS_JDK -DTRACING -DMACRO_MEMSYS_OPS -DBREAKPTS"
 
   906     if test "x$OPENJDK_$1_CPU_ARCH" = xx86; then
 
   484     if test "x$FLAGS_CPU_ARCH" = xx86; then
 
   907       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -DcpuIntel -Di586 -D$OPENJDK_$1_CPU_LEGACY_LIB"
 
   485       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -DcpuIntel -Di586 -D$FLAGS_CPU_LEGACY_LIB"
 
   908     fi
 
   486     fi
 
   909 
   487 
   910     $2CFLAGS_JDK="[$]$2CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal"
 
   488     $2CFLAGS_JDK="[$]$2CFLAGS_JDK -xc99=%none -xCC -errshort=tags -Xa -v -mt -W0,-noglobal"
 
   911     $2CXXFLAGS_JDK="[$]$2CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib"
 
   489     $2CXXFLAGS_JDK="[$]$2CXXFLAGS_JDK -errtags=yes +w -mt -features=no%except -DCC_NOEX -norunpath -xnolib"
 
   912   elif test "x$TOOLCHAIN_TYPE" = xxlc; then
 
   490   elif test "x$TOOLCHAIN_TYPE" = xxlc; then
 
   917     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS [$]$2COMMON_CCXXFLAGS_JDK \
 
   495     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS [$]$2COMMON_CCXXFLAGS_JDK \
 
   918         -MD -Zc:wchar_t- -W3 -wd4800 \
 
   496         -MD -Zc:wchar_t- -W3 -wd4800 \
 
   919         -DWIN32_LEAN_AND_MEAN \
 
   497         -DWIN32_LEAN_AND_MEAN \
 
   920         -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
 
   498         -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE \
 
   921         -DWIN32 -DIAL"
 
   499         -DWIN32 -DIAL"
 
   922     if test "x$OPENJDK_$1_CPU" = xx86_64; then
 
   500     if test "x$FLAGS_CPU" = xx86_64; then
 
   923       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_AMD64_ -Damd64"
 
   501       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_AMD64_ -Damd64"
 
   924     else
 
   502     else
 
   925       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_X86_ -Dx86"
 
   503       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_X86_ -Dx86"
 
   926     fi
 
   504     fi
 
   927     # If building with Visual Studio 2010, we can still use _STATIC_CPPLIB to
 
   505     # If building with Visual Studio 2010, we can still use _STATIC_CPPLIB to
 
   951 
   529 
   952   # Set some common defines. These works for all compilers, but assume
 
   530   # Set some common defines. These works for all compilers, but assume
 
   953   # -D is universally accepted.
 
   531   # -D is universally accepted.
 
   954 
   532 
   955   # Setup endianness
 
   533   # Setup endianness
 
   956   if test "x$OPENJDK_$1_CPU_ENDIAN" = xlittle; then
 
   534   if test "x$FLAGS_CPU_ENDIAN" = xlittle; then
 
   957     # The macro _LITTLE_ENDIAN needs to be defined the same to avoid the
 
   535     # The macro _LITTLE_ENDIAN needs to be defined the same to avoid the
 
   958     #   Sun C compiler warning message: warning: macro redefined: _LITTLE_ENDIAN
 
   536     #   Sun C compiler warning message: warning: macro redefined: _LITTLE_ENDIAN
 
   959     #   (The Solaris X86 system defines this in file /usr/include/sys/isa_defs.h).
 
   537     #   (The Solaris X86 system defines this in file /usr/include/sys/isa_defs.h).
 
   960     #   Note: -Dmacro         is the same as    #define macro 1
 
   538     #   Note: -Dmacro         is the same as    #define macro 1
 
   961     #         -Dmacro=        is the same as    #define macro
 
   539     #         -Dmacro=        is the same as    #define macro
 
   962     if test "x$OPENJDK_$1_OS" = xsolaris; then
 
   540     if test "x$FLAGS_OS" = xsolaris; then
 
   963       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN="
 
   541       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN="
 
   964     else
 
   542     else
 
   965       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN"
 
   543       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_LITTLE_ENDIAN"
 
   966     fi
 
   544     fi
 
   967   else
 
   545   else
 
   968     # Same goes for _BIG_ENDIAN. Do we really need to set *ENDIAN on Solaris if they
 
   546     # Same goes for _BIG_ENDIAN. Do we really need to set *ENDIAN on Solaris if they
 
   969     # are defined in the system?
 
   547     # are defined in the system?
 
   970     if test "x$OPENJDK_$1_OS" = xsolaris; then
 
   548     if test "x$FLAGS_OS" = xsolaris; then
 
   971       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN="
 
   549       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN="
 
   972     else
 
   550     else
 
   973       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN"
 
   551       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_BIG_ENDIAN"
 
   974     fi
 
   552     fi
 
   975   fi
 
   553   fi
 
   978   $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D__STDC_FORMAT_MACROS"
 
   556   $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D__STDC_FORMAT_MACROS"
 
   979   $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D__STDC_LIMIT_MACROS"
 
   557   $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D__STDC_LIMIT_MACROS"
 
   980   $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D__STDC_CONSTANT_MACROS"
 
   558   $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D__STDC_CONSTANT_MACROS"
 
   981 
   559 
   982   # Setup target OS define. Use OS target name but in upper case.
 
   560   # Setup target OS define. Use OS target name but in upper case.
 
   983   OPENJDK_$1_OS_UPPERCASE=`$ECHO $OPENJDK_$1_OS | $TR 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
 
   561   FLAGS_OS_UPPERCASE=`$ECHO $FLAGS_OS | $TR 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
 
   984   $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D$OPENJDK_$1_OS_UPPERCASE"
 
   562   $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D$FLAGS_OS_UPPERCASE"
 
   985 
   563 
   986   # Setup target CPU
 
   564   # Setup target CPU
 
   987   $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK \
 
   565   $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK \
 
   988       $OPENJDK_$1_ADD_LP64 \
 
   566       $FLAGS_ADD_LP64 \
 
   989       -DARCH='\"$OPENJDK_$1_CPU_LEGACY\"' -D$OPENJDK_$1_CPU_LEGACY"
 
   567       -DARCH='\"$FLAGS_CPU_LEGACY\"' -D$FLAGS_CPU_LEGACY"
 
   990 
   568 
   991   # Setup debug/release defines
 
   569   # Setup debug/release defines
 
   992   if test "x$DEBUG_LEVEL" = xrelease; then
 
   570   if test "x$DEBUG_LEVEL" = xrelease; then
 
   993     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -DNDEBUG"
 
   571     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -DNDEBUG"
 
   994     if test "x$OPENJDK_$1_OS" = xsolaris; then
 
   572     if test "x$FLAGS_OS" = xsolaris; then
 
   995       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -DTRIMMED"
 
   573       $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -DTRIMMED"
 
   996     fi
 
   574     fi
 
   997   else
 
   575   else
 
   998     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -DDEBUG"
 
   576     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -DDEBUG"
 
   999   fi
 
   577   fi
 
  1007     fi
 
   585     fi
 
  1008   fi
 
   586   fi
 
  1009 
   587 
  1010 
   588 
  1011   # Set some additional per-OS defines.
 
   589   # Set some additional per-OS defines.
 
  1012   if test "x$OPENJDK_$1_OS" = xlinux; then
 
   590   if test "x$FLAGS_OS" = xlinux; then
 
  1013     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DLINUX"
 
   591     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DLINUX"
 
  1014     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -pipe $PICFLAG -fno-rtti -fno-exceptions \
 
   592     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -pipe $PICFLAG -fno-rtti -fno-exceptions \
 
  1015         -fvisibility=hidden -fno-strict-aliasing -fno-omit-frame-pointer"
 
   593         -fvisibility=hidden -fno-strict-aliasing -fno-omit-frame-pointer"
 
  1016   elif test "x$OPENJDK_$1_OS" = xsolaris; then
 
   594   elif test "x$FLAGS_OS" = xsolaris; then
 
  1017     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DSOLARIS"
 
   595     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DSOLARIS"
 
  1018     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -template=no%extdef -features=no%split_init \
 
   596     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -template=no%extdef -features=no%split_init \
 
  1019         -D_Crun_inline_placement -library=stlport4 $PICFLAG -mt -features=no%except"
 
   597         -D_Crun_inline_placement -library=stlport4 $PICFLAG -mt -features=no%except"
 
  1020   elif test "x$OPENJDK_$1_OS" = xmacosx; then
 
   598   elif test "x$FLAGS_OS" = xmacosx; then
 
  1021     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT"
 
   599     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE -D_DARWIN_UNLIMITED_SELECT"
 
  1022     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_ALLBSD_SOURCE"
 
   600     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_ALLBSD_SOURCE"
 
  1023     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_DARWIN_C_SOURCE -D_XOPEN_SOURCE"
 
   601     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_DARWIN_C_SOURCE -D_XOPEN_SOURCE"
 
  1024     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -fno-rtti -fno-exceptions -fvisibility=hidden \
 
   602     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -fno-rtti -fno-exceptions -fvisibility=hidden \
 
  1025         -mno-omit-leaf-frame-pointer -mstack-alignment=16 -pipe -fno-strict-aliasing \
 
   603         -mno-omit-leaf-frame-pointer -mstack-alignment=16 -pipe -fno-strict-aliasing \
 
  1026         -fno-omit-frame-pointer"
 
   604         -fno-omit-frame-pointer"
 
  1027   elif test "x$OPENJDK_$1_OS" = xaix; then
 
   605   elif test "x$FLAGS_OS" = xaix; then
 
  1028     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DAIX"
 
   606     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DAIX"
 
  1029     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -qtune=balanced \
 
   607     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -qtune=balanced \
 
  1030         -qalias=noansi -qstrict -qtls=default -qlanglvl=c99vla \
 
   608         -qalias=noansi -qstrict -qtls=default -qlanglvl=c99vla \
 
  1031         -qlanglvl=noredefmac -qnortti -qnoeh -qignerrno"
 
   609         -qlanglvl=noredefmac -qnortti -qnoeh -qignerrno"
 
  1032     # We need '-qminimaltoc' or '-qpic=large -bbigtoc' if the TOC overflows.
 
   610     # We need '-qminimaltoc' or '-qpic=large -bbigtoc' if the TOC overflows.
 
  1033     # Hotspot now overflows its 64K TOC (currently only for debug),
 
   611     # Hotspot now overflows its 64K TOC (currently only for debug),
 
  1034     # so for debug we build with '-qpic=large -bbigtoc'.
 
   612     # so for debug we build with '-qpic=large -bbigtoc'.
 
  1035     if test "x$DEBUG_LEVEL" = xslowdebug || test "x$DEBUG_LEVEL" = xfastdebug; then
 
   613     if test "x$DEBUG_LEVEL" = xslowdebug || test "x$DEBUG_LEVEL" = xfastdebug; then
 
  1036       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -qpic=large"
 
   614       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -qpic=large"
 
  1037     fi
 
   615     fi
 
  1038   elif test "x$OPENJDK_$1_OS" = xbsd; then
 
   616   elif test "x$FLAGS_OS" = xbsd; then
 
  1039     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE"
 
   617     $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK -D_ALLBSD_SOURCE"
 
  1040   elif test "x$OPENJDK_$1_OS" = xwindows; then
 
   618   elif test "x$FLAGS_OS" = xwindows; then
 
  1041     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_WINDOWS -DWIN32 -D_JNI_IMPLEMENTATION_"
 
   619     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_WINDOWS -DWIN32 -D_JNI_IMPLEMENTATION_"
 
  1042     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -nologo -W3 -MD -MP"
 
   620     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -nologo -W3 -MD -MP"
 
  1043   fi
 
   621   fi
 
  1044 
   622 
  1045   # Set some additional per-CPU defines.
 
   623   # Set some additional per-CPU defines.
 
  1046   if test "x$OPENJDK_$1_OS-$OPENJDK_$1_CPU" = xwindows-x86; then
 
   624   if test "x$FLAGS_OS-$FLAGS_CPU" = xwindows-x86; then
 
  1047     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -arch:IA32"
 
   625     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -arch:IA32"
 
  1048   elif test "x$OPENJDK_$1_OS-$OPENJDK_$1_CPU" = xsolaris-sparcv9; then
 
   626   elif test "x$FLAGS_OS-$FLAGS_CPU" = xsolaris-sparcv9; then
 
  1049     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -xarch=sparc"
 
   627     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -xarch=sparc"
 
  1050   elif test "x$OPENJDK_$1_CPU" = xppc64; then
 
   628   elif test "x$FLAGS_CPU" = xppc64; then
 
  1051     if test "x$OPENJDK_$1_OS" = xlinux; then
 
   629     if test "x$FLAGS_OS" = xlinux; then
 
  1052       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -minsert-sched-nops=regroup_exact -mno-multiple -mno-string"
 
   630       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -minsert-sched-nops=regroup_exact -mno-multiple -mno-string"
 
  1053       # fixes `relocation truncated to fit' error for gcc 4.1.
 
   631       # fixes `relocation truncated to fit' error for gcc 4.1.
 
  1054       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -mminimal-toc"
 
   632       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -mminimal-toc"
 
  1055       # Use ppc64 instructions, but schedule for power5
 
   633       # Use ppc64 instructions, but schedule for power5
 
  1056       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -mcpu=powerpc64 -mtune=power5"
 
   634       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -mcpu=powerpc64 -mtune=power5"
 
  1057     elif test "x$OPENJDK_$1_OS" = xaix; then
 
   635     elif test "x$FLAGS_OS" = xaix; then
 
  1058       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -qarch=ppc64"
 
   636       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -qarch=ppc64"
 
  1059     fi
 
   637     fi
 
  1060   elif test "x$OPENJDK_$1_CPU" = xppc64le; then
 
   638   elif test "x$FLAGS_CPU" = xppc64le; then
 
  1061     if test "x$OPENJDK_$1_OS" = xlinux; then
 
   639     if test "x$FLAGS_OS" = xlinux; then
 
  1062       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -minsert-sched-nops=regroup_exact -mno-multiple -mno-string"
 
   640       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -minsert-sched-nops=regroup_exact -mno-multiple -mno-string"
 
  1063       # Little endian machine uses ELFv2 ABI.
 
   641       # Little endian machine uses ELFv2 ABI.
 
  1064       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DABI_ELFv2"
 
   642       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DABI_ELFv2"
 
  1065       # Use Power8, this is the first CPU to support PPC64 LE with ELFv2 ABI.
 
   643       # Use Power8, this is the first CPU to support PPC64 LE with ELFv2 ABI.
 
  1066       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -mcpu=power8 -mtune=power8"
 
   644       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -mcpu=power8 -mtune=power8"
 
  1067     fi
 
   645     fi
 
  1068   elif test "x$OPENJDK_$1_CPU" = xs390x; then
 
   646   elif test "x$FLAGS_CPU" = xs390x; then
 
  1069     if test "x$OPENJDK_$1_OS" = xlinux; then
 
   647     if test "x$FLAGS_OS" = xlinux; then
 
  1070       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -mbackchain -march=z10"
 
   648       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -mbackchain -march=z10"
 
  1071     fi
 
   649     fi
 
  1072   fi
 
   650   fi
 
  1073 
   651 
  1074   if test "x$OPENJDK_$1_CPU_ENDIAN" = xlittle; then
 
   652   if test "x$FLAGS_CPU_ENDIAN" = xlittle; then
 
  1075     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DVM_LITTLE_ENDIAN"
 
   653     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -DVM_LITTLE_ENDIAN"
 
  1076   fi
 
   654   fi
 
  1077 
   655 
  1078   if test "x$OPENJDK_$1_CPU_BITS" = x64; then
 
   656   if test "x$FLAGS_CPU_BITS" = x64; then
 
  1079     if test "x$OPENJDK_$1_OS" != xsolaris && test "x$OPENJDK_$1_OS" != xaix; then
 
   657     if test "x$FLAGS_OS" != xsolaris && test "x$FLAGS_OS" != xaix; then
 
  1080       # Solaris does not have _LP64=1 in the old build.
 
   658       # Solaris does not have _LP64=1 in the old build.
 
  1081       # xlc on AIX defines _LP64=1 by default and issues a warning if we redefine it.
 
   659       # xlc on AIX defines _LP64=1 by default and issues a warning if we redefine it.
 
  1082       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_LP64=1"
 
   660       $2JVM_CFLAGS="[$]$2JVM_CFLAGS -D_LP64=1"
 
  1083     fi
 
   661     fi
 
  1084   fi
 
   662   fi
 
  1085 
   663 
  1086   # Set $2JVM_CFLAGS warning handling
 
   664   # Set $2JVM_CFLAGS warning handling
 
  1087   if test "x$OPENJDK_$1_OS" = xlinux; then
 
   665   if test "x$FLAGS_OS" = xlinux; then
 
  1088     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -Wpointer-arith -Wsign-compare -Wunused-function \
 
   666     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -Wpointer-arith -Wsign-compare -Wunused-function \
 
  1089         -Wunused-value -Woverloaded-virtual"
 
   667         -Wunused-value -Woverloaded-virtual"
 
  1090 
   668 
  1091     if test "x$TOOLCHAIN_TYPE" = xgcc; then
 
   669     if test "x$TOOLCHAIN_TYPE" = xgcc; then
 
  1092       TOOLCHAIN_CHECK_COMPILER_VERSION(VERSION: [4.8], PREFIX: $2,
 
   670       TOOLCHAIN_CHECK_COMPILER_VERSION(VERSION: [4.8], PREFIX: $2,
 
  1103       if test "x$TOOLCHAIN_TYPE" = xclang; then
 
   681       if test "x$TOOLCHAIN_TYPE" = xclang; then
 
  1104         # Some versions of llvm do not like -Wundef
 
   682         # Some versions of llvm do not like -Wundef
 
  1105         $2JVM_CFLAGS="[$]$2JVM_CFLAGS -Wno-undef"
 
   683         $2JVM_CFLAGS="[$]$2JVM_CFLAGS -Wno-undef"
 
  1106       fi
 
   684       fi
 
  1107     fi
 
   685     fi
 
  1108   elif test "x$OPENJDK_$1_OS" = xmacosx; then
 
   686   elif test "x$FLAGS_OS" = xmacosx; then
 
  1109     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -Wno-deprecated -Wpointer-arith \
 
   687     $2JVM_CFLAGS="[$]$2JVM_CFLAGS -Wno-deprecated -Wpointer-arith \
 
  1110         -Wsign-compare -Wundef -Wunused-function -Wformat=2"
 
   688         -Wsign-compare -Wundef -Wunused-function -Wformat=2"
 
  1111   fi
 
   689   fi
 
  1112 
   690 
  1113   # Additional macosx handling
 
   691   # Additional macosx handling
 
  1114   if test "x$OPENJDK_$1_OS" = xmacosx; then
 
   692   if test "x$FLAGS_OS" = xmacosx; then
 
  1115     # MACOSX_VERSION_MIN specifies the lowest version of Macosx that the built
 
   693     # MACOSX_VERSION_MIN specifies the lowest version of Macosx that the built
 
  1116     # binaries should be compatible with, even if compiled on a newer version
 
   694     # binaries should be compatible with, even if compiled on a newer version
 
  1117     # of the OS. It currently has a hard coded value. Setting this also limits
 
   695     # of the OS. It currently has a hard coded value. Setting this also limits
 
  1118     # exposure to API changes in header files. Bumping this is likely to
 
   696     # exposure to API changes in header files. Bumping this is likely to
 
  1119     # require code changes to build.
 
   697     # require code changes to build.
 
  1163   # Setup some hard coded includes
 
   741   # Setup some hard coded includes
 
  1164   $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK \
 
   742   $2COMMON_CCXXFLAGS_JDK="[$]$2COMMON_CCXXFLAGS_JDK \
 
  1165       -I\$(SUPPORT_OUTPUTDIR)/modules_include/java.base \
 
   743       -I\$(SUPPORT_OUTPUTDIR)/modules_include/java.base \
 
  1166       -I\$(SUPPORT_OUTPUTDIR)/modules_include/java.base/\$(OPENJDK_TARGET_OS_INCLUDE_SUBDIR) \
 
   744       -I\$(SUPPORT_OUTPUTDIR)/modules_include/java.base/\$(OPENJDK_TARGET_OS_INCLUDE_SUBDIR) \
 
  1167       -I${TOPDIR}/src/java.base/share/native/libjava \
 
   745       -I${TOPDIR}/src/java.base/share/native/libjava \
 
  1168       -I${TOPDIR}/src/java.base/$OPENJDK_$1_OS_TYPE/native/libjava \
 
   746       -I${TOPDIR}/src/java.base/$FLAGS_OS_TYPE/native/libjava \
 
  1169       -I${TOPDIR}/src/hotspot/share/include \
 
   747       -I${TOPDIR}/src/hotspot/share/include \
 
  1170       -I${TOPDIR}/src/hotspot/os/${HOTSPOT_$1_OS_TYPE}/include"
 
   748       -I${TOPDIR}/src/hotspot/os/${HOTSPOT_$1_OS_TYPE}/include"
 
  1171 
   749 
  1172   # The shared libraries are compiled using the picflag.
 
   750   # The shared libraries are compiled using the picflag.
 
  1173   $2CFLAGS_JDKLIB="[$]$2COMMON_CCXXFLAGS_JDK \
 
   751   $2CFLAGS_JDKLIB="[$]$2COMMON_CCXXFLAGS_JDK \
 
  1189 
   767 
  1190   if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 
   768   if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 
  1191     LDFLAGS_MICROSOFT="-nologo -opt:ref"
 
   769     LDFLAGS_MICROSOFT="-nologo -opt:ref"
 
  1192     $2LDFLAGS_JDK="[$]$2LDFLAGS_JDK $LDFLAGS_MICROSOFT -incremental:no"
 
   770     $2LDFLAGS_JDK="[$]$2LDFLAGS_JDK $LDFLAGS_MICROSOFT -incremental:no"
 
  1193     $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS $LDFLAGS_MICROSOFT -opt:icf,8 -subsystem:windows -base:0x8000000"
 
   771     $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS $LDFLAGS_MICROSOFT -opt:icf,8 -subsystem:windows -base:0x8000000"
 
  1194     if test "x$OPENJDK_$1_CPU_BITS" = "x32"; then
 
   772     if test "x$FLAGS_CPU_BITS" = "x32"; then
 
  1195       LDFLAGS_SAFESH="-safeseh"
 
   773       LDFLAGS_SAFESH="-safeseh"
 
  1196       $2LDFLAGS_JDK="[$]$2LDFLAGS_JDK $LDFLAGS_SAFESH"
 
   774       $2LDFLAGS_JDK="[$]$2LDFLAGS_JDK $LDFLAGS_SAFESH"
 
  1197       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS $LDFLAGS_SAFESH"
 
   775       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS $LDFLAGS_SAFESH"
 
  1198       # NOTE: Old build added -machine. Probably not needed.
 
   776       # NOTE: Old build added -machine. Probably not needed.
 
  1199       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -machine:I386"
 
   777       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -machine:I386"
 
  1200     else
 
   778     else
 
  1201       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -machine:AMD64"
 
   779       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -machine:AMD64"
 
  1202     fi
 
   780     fi
 
  1203   elif test "x$TOOLCHAIN_TYPE" = xclang; then
 
   781   elif test "x$TOOLCHAIN_TYPE" = xclang; then
 
  1204       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -mno-omit-leaf-frame-pointer -mstack-alignment=16 -stdlib=libstdc++ -fPIC"
 
   782       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -mno-omit-leaf-frame-pointer -mstack-alignment=16 -stdlib=libstdc++ -fPIC"
 
  1205       if test "x$OPENJDK_$1_OS" = xmacosx; then
 
   783       if test "x$FLAGS_OS" = xmacosx; then
 
  1206         # FIXME: We should really generalize SET_SHARED_LIBRARY_ORIGIN instead.
 
   784         # FIXME: We should really generalize SET_SHARED_LIBRARY_ORIGIN instead.
 
  1207         $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -Wl,-rpath,@loader_path/. -Wl,-rpath,@loader_path/.."
 
   785         $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -Wl,-rpath,@loader_path/. -Wl,-rpath,@loader_path/.."
 
  1208     fi
 
   786     fi
 
  1209   elif test "x$TOOLCHAIN_TYPE" = xgcc; then
 
   787   elif test "x$TOOLCHAIN_TYPE" = xgcc; then
 
  1210     # If this is a --hash-style=gnu system, use --hash-style=both, why?
 
   788     # If this is a --hash-style=gnu system, use --hash-style=both, why?
 
  1212     if test -n "$HAS_GNU_HASH"; then
 
   790     if test -n "$HAS_GNU_HASH"; then
 
  1213       $2LDFLAGS_HASH_STYLE="-Wl,--hash-style=both"
 
   791       $2LDFLAGS_HASH_STYLE="-Wl,--hash-style=both"
 
  1214       $2LDFLAGS_JDK="${$2LDFLAGS_JDK} [$]$2LDFLAGS_HASH_STYLE"
 
   792       $2LDFLAGS_JDK="${$2LDFLAGS_JDK} [$]$2LDFLAGS_HASH_STYLE"
 
  1215       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS [$]$2LDFLAGS_HASH_STYLE"
 
   793       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS [$]$2LDFLAGS_HASH_STYLE"
 
  1216     fi
 
   794     fi
 
  1217       if test "x$OPENJDK_$1_OS" = xmacosx; then
 
   795       if test "x$FLAGS_OS" = xmacosx; then
 
  1218         $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -Wl,-rpath,@loader_path/. -Wl,-rpath,@loader_path/.."
 
   796         $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -Wl,-rpath,@loader_path/. -Wl,-rpath,@loader_path/.."
 
  1219     fi
 
   797     fi
 
  1220     if test "x$OPENJDK_$1_OS" = xlinux; then
 
   798     if test "x$FLAGS_OS" = xlinux; then
 
  1221       # And since we now know that the linker is gnu, then add -z defs, to forbid
 
   799       # And since we now know that the linker is gnu, then add -z defs, to forbid
 
  1222       # undefined symbols in object files.
 
   800       # undefined symbols in object files.
 
  1223       LDFLAGS_NO_UNDEF_SYM="-Wl,-z,defs"
 
   801       LDFLAGS_NO_UNDEF_SYM="-Wl,-z,defs"
 
  1224       $2LDFLAGS_JDK="${$2LDFLAGS_JDK} $LDFLAGS_NO_UNDEF_SYM"
 
   802       $2LDFLAGS_JDK="${$2LDFLAGS_JDK} $LDFLAGS_NO_UNDEF_SYM"
 
  1225       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS  $LDFLAGS_NO_UNDEF_SYM"
 
   803       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS  $LDFLAGS_NO_UNDEF_SYM"
 
  1226       LDFLAGS_NO_EXEC_STACK="-Wl,-z,noexecstack"
 
   804       LDFLAGS_NO_EXEC_STACK="-Wl,-z,noexecstack"
 
  1227       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS $LDFLAGS_NO_EXEC_STACK"
 
   805       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS $LDFLAGS_NO_EXEC_STACK"
 
  1228       if test "x$OPENJDK_$1_CPU" = xx86; then
 
   806       if test "x$FLAGS_CPU" = xx86; then
 
  1229         $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -march=i586"
 
   807         $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -march=i586"
 
  1230       fi
 
   808       fi
 
  1231       case $DEBUG_LEVEL in
 
   809       case $DEBUG_LEVEL in
 
  1232         release )
 
   810         release )
 
  1233           # tell linker to optimize libraries.
 
   811           # tell linker to optimize libraries.
 
  1274     LDFLAGS_SOLSTUDIO="-Wl,-z,defs"
 
   852     LDFLAGS_SOLSTUDIO="-Wl,-z,defs"
 
  1275     $2LDFLAGS_JDK="[$]$2LDFLAGS_JDK $LDFLAGS_SOLSTUDIO -ztext"
 
   853     $2LDFLAGS_JDK="[$]$2LDFLAGS_JDK $LDFLAGS_SOLSTUDIO -ztext"
 
  1276     LDFLAGS_CXX_SOLSTUDIO="-norunpath"
 
   854     LDFLAGS_CXX_SOLSTUDIO="-norunpath"
 
  1277     $2LDFLAGS_CXX_JDK="[$]$2LDFLAGS_CXX_JDK $LDFLAGS_CXX_SOLSTUDIO -xnolib"
 
   855     $2LDFLAGS_CXX_JDK="[$]$2LDFLAGS_CXX_JDK $LDFLAGS_CXX_SOLSTUDIO -xnolib"
 
  1278     $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS $LDFLAGS_SOLSTUDIO -library=%none -mt $LDFLAGS_CXX_SOLSTUDIO -z noversion"
 
   856     $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS $LDFLAGS_SOLSTUDIO -library=%none -mt $LDFLAGS_CXX_SOLSTUDIO -z noversion"
 
  1279     if test "x$OPENJDK_$1_CPU_ARCH" = "xsparc"; then
 
   857     if test "x$FLAGS_CPU_ARCH" = "xsparc"; then
 
  1280       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -xarch=sparc"
 
   858       $2JVM_LDFLAGS="[$]$2JVM_LDFLAGS -xarch=sparc"
 
  1281     fi
 
   859     fi
 
  1282   elif test "x$TOOLCHAIN_TYPE" = xxlc; then
 
   860   elif test "x$TOOLCHAIN_TYPE" = xxlc; then
 
  1283     LDFLAGS_XLC="-b64 -brtl -bnolibpath -bexpall -bernotok -btextpsize:64K -bdatapsize:64K -bstackpsize:64K"
 
   861     LDFLAGS_XLC="-b64 -brtl -bnolibpath -bexpall -bernotok -btextpsize:64K -bdatapsize:64K -bstackpsize:64K"
 
  1284     $2LDFLAGS_JDK="${$2LDFLAGS_JDK} $LDFLAGS_XLC"
 
   862     $2LDFLAGS_JDK="${$2LDFLAGS_JDK} $LDFLAGS_XLC"
 
  1294   # Customize LDFLAGS for executables
 
   872   # Customize LDFLAGS for executables
 
  1295 
   873 
  1296   $2LDFLAGS_JDKEXE="${$2LDFLAGS_JDK}"
 
   874   $2LDFLAGS_JDKEXE="${$2LDFLAGS_JDK}"
 
  1297 
   875 
  1298   if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 
   876   if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
 
  1299     if test "x$OPENJDK_$1_CPU_BITS" = "x64"; then
 
   877     if test "x$FLAGS_CPU_BITS" = "x64"; then
 
  1300       LDFLAGS_STACK_SIZE=1048576
 
   878       LDFLAGS_STACK_SIZE=1048576
 
  1301     else
 
   879     else
 
  1302       LDFLAGS_STACK_SIZE=327680
 
   880       LDFLAGS_STACK_SIZE=327680
 
  1303     fi
 
   881     fi
 
  1304     $2LDFLAGS_JDKEXE="${$2LDFLAGS_JDKEXE} /STACK:$LDFLAGS_STACK_SIZE"
 
   882     $2LDFLAGS_JDKEXE="${$2LDFLAGS_JDKEXE} /STACK:$LDFLAGS_STACK_SIZE"
 
  1305   elif test "x$OPENJDK_$1_OS" = xlinux; then
 
   883   elif test "x$FLAGS_OS" = xlinux; then
 
  1306     $2LDFLAGS_JDKEXE="[$]$2LDFLAGS_JDKEXE -Wl,--allow-shlib-undefined"
 
   884     $2LDFLAGS_JDKEXE="[$]$2LDFLAGS_JDKEXE -Wl,--allow-shlib-undefined"
 
  1307   fi
 
   885   fi
 
  1308 
   886 
  1309   $2LDFLAGS_JDKEXE="${$2LDFLAGS_JDKEXE} ${$2EXTRA_LDFLAGS_JDK}"
 
   887   $2LDFLAGS_JDKEXE="${$2LDFLAGS_JDKEXE} ${$2EXTRA_LDFLAGS_JDK}"
 
  1310 
   888 
  1345       $2JDKLIB_LIBS="[$]$2JDKLIB_LIBS -lc"
 
   923       $2JDKLIB_LIBS="[$]$2JDKLIB_LIBS -lc"
 
  1346     fi
 
   924     fi
 
  1347 
   925 
  1348   fi
 
   926   fi
 
  1349 
   927 
  1350 $2LDFLAGS_JDKLIB="${$2LDFLAGS_JDKLIB} ${$2JAVA_BASE_LDFLAGS}"
 
   928   $2LDFLAGS_JDKLIB="${$2LDFLAGS_JDKLIB} ${$2JAVA_BASE_LDFLAGS}"
 
  1351 
   929 
  1352   # Set $2JVM_LIBS (per os)
 
   930   # Set $2JVM_LIBS (per os)
 
  1353   if test "x$OPENJDK_$1_OS" = xlinux; then
 
   931   if test "x$FLAGS_OS" = xlinux; then
 
  1354     $2JVM_LIBS="[$]$2JVM_LIBS -lm -ldl -lpthread"
 
   932     $2JVM_LIBS="[$]$2JVM_LIBS -lm -ldl -lpthread"
 
  1355   elif test "x$OPENJDK_$1_OS" = xsolaris; then
 
   933   elif test "x$FLAGS_OS" = xsolaris; then
 
  1356     # FIXME: This hard-coded path is not really proper.
 
   934     # FIXME: This hard-coded path is not really proper.
 
  1357     if test "x$OPENJDK_$1_CPU" = xx86_64; then
 
   935     if test "x$FLAGS_CPU" = xx86_64; then
 
  1358       $2SOLARIS_LIBM_LIBS="/usr/lib/amd64/libm.so.1"
 
   936       $2SOLARIS_LIBM_LIBS="/usr/lib/amd64/libm.so.1"
 
  1359     elif test "x$OPENJDK_$1_CPU" = xsparcv9; then
 
   937     elif test "x$FLAGS_CPU" = xsparcv9; then
 
  1360       $2SOLARIS_LIBM_LIBS="/usr/lib/sparcv9/libm.so.1"
 
   938       $2SOLARIS_LIBM_LIBS="/usr/lib/sparcv9/libm.so.1"
 
  1361     fi
 
   939     fi
 
  1362     $2JVM_LIBS="[$]$2JVM_LIBS -lsocket -lsched -ldl $SOLARIS_LIBM_LIBS -lCrun \
 
   940     $2JVM_LIBS="[$]$2JVM_LIBS -lsocket -lsched -ldl $SOLARIS_LIBM_LIBS -lCrun \
 
  1363         -lthread -ldoor -lc -ldemangle -lnsl -lrt"
 
   941         -lthread -ldoor -lc -ldemangle -lnsl -lrt"
 
  1364   elif test "x$OPENJDK_$1_OS" = xmacosx; then
 
   942   elif test "x$FLAGS_OS" = xmacosx; then
 
  1365     $2JVM_LIBS="[$]$2JVM_LIBS -lm"
 
   943     $2JVM_LIBS="[$]$2JVM_LIBS -lm"
 
  1366   elif test "x$OPENJDK_$1_OS" = xaix; then
 
   944   elif test "x$FLAGS_OS" = xaix; then
 
  1367     $2JVM_LIBS="[$]$2JVM_LIBS -Wl,-lC_r -lm -ldl -lpthread"
 
   945     $2JVM_LIBS="[$]$2JVM_LIBS -Wl,-lC_r -lm -ldl -lpthread"
 
  1368   elif test "x$OPENJDK_$1_OS" = xbsd; then
 
   946   elif test "x$FLAGS_OS" = xbsd; then
 
  1369     $2JVM_LIBS="[$]$2JVM_LIBS -lm"
 
   947     $2JVM_LIBS="[$]$2JVM_LIBS -lm"
 
  1370   elif test "x$OPENJDK_$1_OS" = xwindows; then
 
   948   elif test "x$FLAGS_OS" = xwindows; then
 
  1371     $2JVM_LIBS="[$]$2JVM_LIBS kernel32.lib user32.lib gdi32.lib winspool.lib \
 
   949     $2JVM_LIBS="[$]$2JVM_LIBS kernel32.lib user32.lib gdi32.lib winspool.lib \
 
  1372         comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib \
 
   950         comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib \
 
  1373         wsock32.lib winmm.lib version.lib psapi.lib"
 
   951         wsock32.lib winmm.lib version.lib psapi.lib"
 
  1374     fi
 
   952     fi
 
  1375 
   953 
  1376   # Set $2JVM_ASFLAGS
 
   954   # Set $2JVM_ASFLAGS
 
  1377   if test "x$OPENJDK_$1_OS" = xlinux; then
 
   955   if test "x$FLAGS_OS" = xlinux; then
 
  1378     if test "x$OPENJDK_$1_CPU" = xx86; then
 
   956     if test "x$FLAGS_CPU" = xx86; then
 
  1379       $2JVM_ASFLAGS="[$]$2JVM_ASFLAGS -march=i586"
 
   957       $2JVM_ASFLAGS="[$]$2JVM_ASFLAGS -march=i586"
 
  1380     fi
 
   958     fi
 
  1381   elif test "x$OPENJDK_$1_OS" = xmacosx; then
 
   959   elif test "x$FLAGS_OS" = xmacosx; then
 
  1382     $2JVM_ASFLAGS="[$]$2JVM_ASFLAGS -x assembler-with-cpp -mno-omit-leaf-frame-pointer -mstack-alignment=16"
 
   960     $2JVM_ASFLAGS="[$]$2JVM_ASFLAGS -x assembler-with-cpp -mno-omit-leaf-frame-pointer -mstack-alignment=16"
 
  1383   fi
 
   961   fi
 
  1384 
   962 
  1385   $2LDFLAGS_JDKLIB="${$2LDFLAGS_JDKLIB} ${$2EXTRA_LDFLAGS_JDK}"
 
   963   $2LDFLAGS_JDKLIB="${$2LDFLAGS_JDKLIB} ${$2EXTRA_LDFLAGS_JDK}"
 
  1386 
   964
jdk-sandbox