#

# Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.

# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

#

# This code is free software; you can redistribute it and/or modify it

# under the terms of the GNU General Public License version 2 only, as

# published by the Free Software Foundation.  Oracle designates this

# particular file as subject to the "Classpath" exception as provided

# by Oracle in the LICENSE file that accompanied this code.

#

# This code is distributed in the hope that it will be useful, but WITHOUT

# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

# version 2 for more details (a copy is included in the LICENSE file that

# accompanied this code).

#

# You should have received a copy of the GNU General Public License version

# 2 along with this work; if not, write to the Free Software Foundation,

# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

#

# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

# or visit www.oracle.com if you need additional information or have any

# questions.

#

# $1 = compiler to test (CC or CXX)

# $2 = human readable name of compiler (C or C++)

AC_DEFUN([TOOLCHAIN_CHECK_COMPILER_VERSION],

[

  COMPILER=[$]$1

  COMPILER_NAME=$2

  if test "x$OPENJDK_TARGET_OS" = xsolaris; then

    # Make sure we use the Sun Studio compiler and not gcc on Solaris, which won't work

    COMPILER_VERSION_TEST=`$COMPILER -V 2>&1 | $HEAD -n 1`

    $ECHO $COMPILER_VERSION_TEST | $GREP "^.*: Sun $COMPILER_NAME" > /dev/null

    if test $? -ne 0; then

      GCC_VERSION_TEST=`$COMPILER --version 2>&1 | $HEAD -n 1`

      AC_MSG_NOTICE([The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required Sun Studio compiler.])

      AC_MSG_NOTICE([The result from running with -V was: "$COMPILER_VERSION_TEST" and with --version: "$GCC_VERSION_TEST"])

      AC_MSG_ERROR([Sun Studio compiler is required. Try setting --with-tools-dir.])

    else

      COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^.*@<:@ ,\t@:>@$COMPILER_NAME@<:@ ,\t@:>@\(@<:@1-9@:>@\.@<:@0-9@:>@@<:@0-9@:>@*\).*/\1/p"`

      COMPILER_VENDOR="Sun Studio"

    fi

  elif test  "x$OPENJDK_TARGET_OS" = xaix; then

      COMPILER_VERSION_TEST=`$COMPILER -qversion  2>&1 | $TAIL -n 1`

      $ECHO $COMPILER_VERSION_TEST | $GREP "^Version: " > /dev/null

      if test $? -ne 0; then

        AC_MSG_ERROR([Failed to detect the compiler version of $COMPILER ....])

      else

        COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | $SED -n 's/Version: \([0-9][0-9]\.[0-9][0-9]*\).*/\1/p'`

        COMPILER_VENDOR='IBM'

      fi

  elif test  "x$OPENJDK_TARGET_OS" = xwindows; then

    # First line typically looks something like:

    # Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.40219.01 for 80x86

    COMPILER_VERSION_TEST=`$COMPILER 2>&1 | $HEAD -n 1 | $TR -d '\r'`

    COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^.*Version \(@<:@1-9@:>@@<:@0-9.@:>@*\) .*/\1/p"`

    COMPILER_VENDOR="Microsoft CL.EXE"

    COMPILER_CPU_TEST=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^.* for \(.*\)$/\1/p"`

    if test "x$OPENJDK_TARGET_CPU" = "xx86"; then

      if test "x$COMPILER_CPU_TEST" != "x80x86"; then

        AC_MSG_ERROR([Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for "$COMPILER_CPU_TEST"; expected "80x86".])

      fi

    elif test "x$OPENJDK_TARGET_CPU" = "xx86_64"; then

      if test "x$COMPILER_CPU_TEST" != "xx64"; then

        AC_MSG_ERROR([Target CPU mismatch. We are building for $OPENJDK_TARGET_CPU but CL is for "$COMPILER_CPU_TEST"; expected "x64".])

      fi

    fi

  else

    COMPILER_VERSION_TEST=`$COMPILER --version 2>&1 | $HEAD -n 1`

    # Check that this is likely to be GCC.

    $COMPILER --version 2>&1 | $GREP "Free Software Foundation" > /dev/null

    if test $? -ne 0; then

      AC_MSG_NOTICE([The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required GCC compiler.])

      AC_MSG_NOTICE([The result from running with --version was: "$COMPILER_VERSION_TEST"])

      AC_MSG_ERROR([GCC compiler is required. Try setting --with-tools-dir.])

    fi

    # First line typically looks something like:

    # gcc (Ubuntu/Linaro 4.5.2-8ubuntu4) 4.5.2

    COMPILER_VERSION=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^.* \(@<:@1-9@:>@@<:@0-9.@:>@*\)/\1/p"`

    COMPILER_VENDOR=`$ECHO $COMPILER_VERSION_TEST | $SED -n "s/^\(.*\) @<:@1-9@:>@@<:@0-9.@:>@*/\1/p"`

  fi

  # This sets CC_VERSION or CXX_VERSION. (This comment is a grep marker)

  $1_VERSION="$COMPILER_VERSION"

  # This sets CC_VENDOR or CXX_VENDOR. (This comment is a grep marker)

  $1_VENDOR="$COMPILER_VENDOR"

  AC_MSG_NOTICE([Using $COMPILER_VENDOR $COMPILER_NAME compiler version $COMPILER_VERSION (located at $COMPILER)])

])

AC_DEFUN_ONCE([TOOLCHAIN_SETUP_SYSROOT_AND_OUT_OPTIONS],

[

  ###############################################################################

  #

  # Configure the development tool paths and potential sysroot.

  #

  AC_LANG(C++)

  # The option used to specify the target .o,.a or .so file.

  # When compiling, how to specify the to be created object file.

  CC_OUT_OPTION='-o$(SPACE)'

  # When linking, how to specify the to be created executable.

  EXE_OUT_OPTION='-o$(SPACE)'

  # When linking, how to specify the to be created dynamically linkable library.

  LD_OUT_OPTION='-o$(SPACE)'

  # When archiving, how to specify the to be create static archive for object files.

  AR_OUT_OPTION='rcs$(SPACE)'

  AC_SUBST(CC_OUT_OPTION)

  AC_SUBST(EXE_OUT_OPTION)

  AC_SUBST(LD_OUT_OPTION)

  AC_SUBST(AR_OUT_OPTION)

])

# $1 = compiler to test (CC or CXX)

# $2 = human readable name of compiler (C or C++)

# $3 = list of compiler names to search for

AC_DEFUN([TOOLCHAIN_FIND_COMPILER],

[

  COMPILER_NAME=$2

  SEARCH_LIST="$3"

  if test "x[$]$1" != x; then

    # User has supplied compiler name already, always let that override.

    AC_MSG_NOTICE([Will use user supplied compiler $1=[$]$1])

    if test "x`basename [$]$1`" = "x[$]$1"; then

      # A command without a complete path is provided, search $PATH.

      AC_PATH_PROGS(POTENTIAL_$1, [$]$1)

      if test "x$POTENTIAL_$1" != x; then

        $1=$POTENTIAL_$1

      else

        AC_MSG_ERROR([User supplied compiler $1=[$]$1 could not be found])

      fi

    else

      # Otherwise it might already be a complete path

      if test ! -x "[$]$1"; then

        AC_MSG_ERROR([User supplied compiler $1=[$]$1 does not exist])

      fi

    fi

  else

    # No user supplied value. Locate compiler ourselves

    $1=

    # If TOOLS_DIR is set, check for all compiler names in there first

    # before checking the rest of the PATH.

    if test -n "$TOOLS_DIR"; then

      PATH_save="$PATH"

      PATH="$TOOLS_DIR"

      AC_PATH_PROGS(TOOLS_DIR_$1, $SEARCH_LIST)

      $1=$TOOLS_DIR_$1

      PATH="$PATH_save"

    fi

    # AC_PATH_PROGS can't be run multiple times with the same variable,

    # so create a new name for this run.

    if test "x[$]$1" = x; then

      AC_PATH_PROGS(POTENTIAL_$1, $SEARCH_LIST)

      $1=$POTENTIAL_$1

    fi

    if test "x[$]$1" = x; then

      HELP_MSG_MISSING_DEPENDENCY([devkit])

      AC_MSG_ERROR([Could not find a $COMPILER_NAME compiler. $HELP_MSG])

    fi

  fi

  # Now we have a compiler binary in $1. Make sure it's okay.

  BASIC_FIXUP_EXECUTABLE($1)

  TEST_COMPILER="[$]$1"

  # Don't remove symbolic links on AIX because 'xlc_r' and 'xlC_r' may all be links

  # to 'xlc' but it is crucial that we invoke the compiler with the right name!

  if test "x$OPENJDK_BUILD_OS" != xaix; then

    AC_MSG_CHECKING([resolved symbolic links for $1])

    BASIC_REMOVE_SYMBOLIC_LINKS(TEST_COMPILER)

    AC_MSG_RESULT([$TEST_COMPILER])

  fi

  AC_MSG_CHECKING([if $1 is disguised ccache])

  COMPILER_BASENAME=`$BASENAME "$TEST_COMPILER"`

  if test "x$COMPILER_BASENAME" = "xccache"; then

    AC_MSG_RESULT([yes, trying to find proper $COMPILER_NAME compiler])

    # We /usr/lib/ccache in the path, so cc is a symlink to /usr/bin/ccache.

    # We want to control ccache invocation ourselves, so ignore this cc and try

    # searching again.

    # Remove the path to the fake ccache cc from the PATH

    RETRY_COMPILER_SAVED_PATH="$PATH"

    COMPILER_DIRNAME=`$DIRNAME [$]$1`

    PATH="`$ECHO $PATH | $SED -e "s,$COMPILER_DIRNAME,,g" -e "s,::,:,g" -e "s,^:,,g"`"

    # Try again looking for our compiler

    AC_CHECK_TOOLS(PROPER_COMPILER_$1, $3)

    BASIC_FIXUP_EXECUTABLE(PROPER_COMPILER_$1)

    PATH="$RETRY_COMPILER_SAVED_PATH"

    AC_MSG_CHECKING([for resolved symbolic links for $1])

    BASIC_REMOVE_SYMBOLIC_LINKS(PROPER_COMPILER_$1)

    AC_MSG_RESULT([$PROPER_COMPILER_$1])

    $1="$PROPER_COMPILER_$1"

  else

    AC_MSG_RESULT([no, keeping $1])

  fi

  TOOLCHAIN_CHECK_COMPILER_VERSION([$1], [$COMPILER_NAME])

])

AC_DEFUN([TOOLCHAIN_SETUP_PATHS],

[

  if test "x$OPENJDK_TARGET_OS" = "xwindows"; then

    TOOLCHAIN_SETUP_VISUAL_STUDIO_ENV

    TOOLCHAIN_SETUP_MSVCR_DLL

    BASIC_DEPRECATED_ARG_WITH([dxsdk])

    BASIC_DEPRECATED_ARG_WITH([dxsdk-lib])

    BASIC_DEPRECATED_ARG_WITH([dxsdk-include])

  fi

  AC_SUBST(MSVCR_DLL)

  # If --build AND --host is set, then the configure script will find any

  # cross compilation tools in the PATH. Cross compilation tools

  # follows the cross compilation standard where they are prefixed with ${host}.

  # For example the binary i686-sun-solaris2.10-gcc

  # will cross compile for i686-sun-solaris2.10

  # If neither of build and host is not set, then build=host and the

  # default compiler found in the path will be used.

  # Setting only --host, does not seem to be really supported.

  # Please set both --build and --host if you want to cross compile.

  if test "x$COMPILE_TYPE" = "xcross"; then

    # Now we to find a C/C++ compiler that can build executables for the build

    # platform. We can't use the AC_PROG_CC macro, since it can only be used

    # once. Also, we need to do this before adding a tools dir to the path,

    # otherwise we might pick up cross-compilers which don't use standard naming.

    # Otherwise, we'll set the BUILD_tools to the native tools, but that'll have

    # to wait until they are properly discovered.

    AC_PATH_PROGS(BUILD_CC, [cl cc gcc])

    BASIC_FIXUP_EXECUTABLE(BUILD_CC)

    AC_PATH_PROGS(BUILD_CXX, [cl CC g++])

    BASIC_FIXUP_EXECUTABLE(BUILD_CXX)

    AC_PATH_PROG(BUILD_LD, ld)

    BASIC_FIXUP_EXECUTABLE(BUILD_LD)

  fi

  AC_SUBST(BUILD_CC)

  AC_SUBST(BUILD_CXX)

  AC_SUBST(BUILD_LD)

  # If a devkit is found on the builddeps server, then prepend its path to the

  # PATH variable. If there are cross compilers available in the devkit, these

  # will be found by AC_PROG_CC et al.

  DEVKIT=

  BDEPS_CHECK_MODULE(DEVKIT, devkit, xxx,

      [

        # Found devkit

        PATH="$DEVKIT/bin:$PATH"

        SYS_ROOT="$DEVKIT/${rewritten_target}/sys-root"

        if test "x$x_includes" = "xNONE"; then

          x_includes="$SYS_ROOT/usr/include/X11"

        fi

        if test "x$x_libraries" = "xNONE"; then

          x_libraries="$SYS_ROOT/usr/lib"

        fi

      ],

      [])

  # Store the CFLAGS etal passed to the configure script.

  ORG_CFLAGS="$CFLAGS"

  ORG_CXXFLAGS="$CXXFLAGS"

  ORG_OBJCFLAGS="$OBJCFLAGS"

  # autoconf magic only relies on PATH, so update it if tools dir is specified

  OLD_PATH="$PATH"

  if test "x$TOOLS_DIR" != x; then

    PATH=$TOOLS_DIR:$PATH

  fi

  ### Locate C compiler (CC)

  # On windows, only cl.exe is supported.

  # On Solaris, cc is preferred to gcc.

  # Elsewhere, gcc is preferred to cc.

  if test "x$OPENJDK_TARGET_OS" = "xwindows"; then

    COMPILER_CHECK_LIST="cl"

  elif test "x$OPENJDK_TARGET_OS" = "xsolaris"; then

    COMPILER_CHECK_LIST="cc gcc"

  elif test "x$OPENJDK_TARGET_OS" = "xaix"; then

    # Do not probe for cc on AIX.

    COMPILER_CHECK_LIST="xlc_r"

  else

    COMPILER_CHECK_LIST="gcc cc"

  fi

  TOOLCHAIN_FIND_COMPILER([CC],[C],[$COMPILER_CHECK_LIST])

  # Now that we have resolved CC ourself, let autoconf have its go at it

  AC_PROG_CC([$CC])

  # Option used to tell the compiler whether to create 32- or 64-bit executables

  # Notice that CC contains the full compiler path at this point.

  case $CC in

    *xlc_r) COMPILER_TARGET_BITS_FLAG="-q";;

    *)      COMPILER_TARGET_BITS_FLAG="-m";;

  esac

  AC_SUBST(COMPILER_TARGET_BITS_FLAG)

  ### Locate C++ compiler (CXX)

  if test "x$OPENJDK_TARGET_OS" = "xwindows"; then

    COMPILER_CHECK_LIST="cl"

  elif test "x$OPENJDK_TARGET_OS" = "xsolaris"; then

    COMPILER_CHECK_LIST="CC g++"

  elif test "x$OPENJDK_TARGET_OS" = "xaix"; then

    # Do not probe for CC on AIX .

    COMPILER_CHECK_LIST="xlC_r"

  else

    COMPILER_CHECK_LIST="g++ CC"

  fi

  TOOLCHAIN_FIND_COMPILER([CXX],[C++],[$COMPILER_CHECK_LIST])

  # Now that we have resolved CXX ourself, let autoconf have its go at it

  AC_PROG_CXX([$CXX])

  ### Locate other tools

  if test "x$OPENJDK_TARGET_OS" = xmacosx; then

    AC_PROG_OBJC

    BASIC_FIXUP_EXECUTABLE(OBJC)

  else

    OBJC=

  fi

  # Restore the flags to the user specified values.

  # This is necessary since AC_PROG_CC defaults CFLAGS to "-g -O2"

  CFLAGS="$ORG_CFLAGS"

  CXXFLAGS="$ORG_CXXFLAGS"

  OBJCFLAGS="$ORG_OBJCFLAGS"

  LD="$CC"

  LDEXE="$CC"

  LDCXX="$CXX"

  LDEXECXX="$CXX"

  AC_SUBST(LD)

  # LDEXE is the linker to use, when creating executables.

  AC_SUBST(LDEXE)

  # Linking C++ libraries.

  AC_SUBST(LDCXX)

  # Linking C++ executables.

  AC_SUBST(LDEXECXX)

  if test "x$OPENJDK_TARGET_OS" != xwindows; then

    AC_CHECK_TOOL(AR, ar)

    BASIC_FIXUP_EXECUTABLE(AR)

  fi

  if test "x$OPENJDK_TARGET_OS" = xmacosx; then

    ARFLAGS="-r"

  elif test "x$OPENJDK_TARGET_OS" = xaix; then

    ARFLAGS="-X64"

  else

    ARFLAGS=""

  fi

  AC_SUBST(ARFLAGS)

  # For hotspot, we need these in Windows mixed path; other platforms keep them the same

  HOTSPOT_CXX="$CXX"

  HOTSPOT_LD="$LD"

  AC_SUBST(HOTSPOT_CXX)

  AC_SUBST(HOTSPOT_LD)

  COMPILER_NAME=gcc

  COMPILER_TYPE=CC

  AS_IF([test "x$OPENJDK_TARGET_OS" = xwindows], [

    # For now, assume that we are always compiling using cl.exe.

    CC_OUT_OPTION=-Fo

    EXE_OUT_OPTION=-out:

    LD_OUT_OPTION=-out:

    AR_OUT_OPTION=-out:

    # On Windows, reject /usr/bin/link (as determined in CYGWIN_LINK), which is a cygwin

    # program for something completely different.

    AC_CHECK_PROG([WINLD], [link],[link],,, [$CYGWIN_LINK])

    # Since we must ignore the first found link, WINLD will contain

    # the full path to the link.exe program.

    BASIC_FIXUP_EXECUTABLE(WINLD)

    printf "Windows linker was found at $WINLD\n"

    AC_MSG_CHECKING([if the found link.exe is actually the Visual Studio linker])

    "$WINLD" --version > /dev/null

    if test $? -eq 0 ; then

      AC_MSG_RESULT([no])

      AC_MSG_ERROR([This is the Cygwin link tool. Please check your PATH and rerun configure.])

    else

      AC_MSG_RESULT([yes])

    fi

    LD="$WINLD"

    LDEXE="$WINLD"

    LDCXX="$WINLD"

    LDEXECXX="$WINLD"

    AC_CHECK_PROG([MT], [mt], [mt],,, [/usr/bin/mt])

    BASIC_FIXUP_EXECUTABLE(MT)

    # The resource compiler

    AC_CHECK_PROG([RC], [rc], [rc],,, [/usr/bin/rc])

    BASIC_FIXUP_EXECUTABLE(RC)

    # For hotspot, we need these in Windows mixed path,

    # so rewrite them all. Need added .exe suffix.

    HOTSPOT_CXX="$CXX.exe"

    HOTSPOT_LD="$LD.exe"

    HOTSPOT_MT="$MT.exe"

    HOTSPOT_RC="$RC.exe"

    BASIC_WINDOWS_REWRITE_AS_WINDOWS_MIXED_PATH(HOTSPOT_CXX)

    BASIC_WINDOWS_REWRITE_AS_WINDOWS_MIXED_PATH(HOTSPOT_LD)

    BASIC_WINDOWS_REWRITE_AS_WINDOWS_MIXED_PATH(HOTSPOT_MT)

    BASIC_WINDOWS_REWRITE_AS_WINDOWS_MIXED_PATH(HOTSPOT_RC)

    AC_SUBST(HOTSPOT_MT)

    AC_SUBST(HOTSPOT_RC)

    RC_FLAGS="-nologo -l 0x409 -r"

    AS_IF([test "x$VARIANT" = xOPT], [

    RC_FLAGS="$RC_FLAGS -d NDEBUG"

  ])

  # The version variables used to create RC_FLAGS may be overridden

  # in a custom configure script, or possibly the command line.

  # Let those variables be expanded at make time in spec.gmk.

  # The \$ are escaped to the shell, and the $(...) variables

  # are evaluated by make.

  RC_FLAGS="$RC_FLAGS \

      -d \"JDK_BUILD_ID=\$(FULL_VERSION)\" \

      -d \"JDK_COMPANY=\$(COMPANY_NAME)\" \

      -d \"JDK_COMPONENT=\$(PRODUCT_NAME) \$(JDK_RC_PLATFORM_NAME) binary\" \

      -d \"JDK_VER=\$(JDK_MINOR_VERSION).\$(JDK_MICRO_VERSION).\$(if \$(JDK_UPDATE_VERSION),\$(JDK_UPDATE_VERSION),0).\$(COOKED_BUILD_NUMBER)\" \

      -d \"JDK_COPYRIGHT=Copyright \xA9 $COPYRIGHT_YEAR\" \

      -d \"JDK_NAME=\$(PRODUCT_NAME) \$(JDK_RC_PLATFORM_NAME) \$(JDK_MINOR_VERSION) \$(JDK_UPDATE_META_TAG)\" \

      -d \"JDK_FVER=\$(JDK_MINOR_VERSION),\$(JDK_MICRO_VERSION),\$(if \$(JDK_UPDATE_VERSION),\$(JDK_UPDATE_VERSION),0),\$(COOKED_BUILD_NUMBER)\""

  # lib.exe is used to create static libraries.

  AC_CHECK_PROG([WINAR], [lib],[lib],,,)

  BASIC_FIXUP_EXECUTABLE(WINAR)

  AR="$WINAR"

  ARFLAGS="-nologo -NODEFAULTLIB:MSVCRT"

  AC_CHECK_PROG([DUMPBIN], [dumpbin], [dumpbin],,,)

      BASIC_FIXUP_EXECUTABLE(DUMPBIN)

      COMPILER_TYPE=CL

      CCXXFLAGS="$CCXXFLAGS -nologo"

  ])

  AC_SUBST(RC_FLAGS)

  AC_SUBST(COMPILER_TYPE)

  AC_PROG_CPP

  BASIC_FIXUP_EXECUTABLE(CPP)

  AC_PROG_CXXCPP

  BASIC_FIXUP_EXECUTABLE(CXXCPP)

  if test "x$COMPILE_TYPE" != "xcross"; then

    # If we are not cross compiling, use the same compilers for

    # building the build platform executables. The cross-compilation

    # case needed to be done earlier, but this can only be done after

    # the native tools have been localized.

    BUILD_CC="$CC"

    BUILD_CXX="$CXX"

    BUILD_LD="$LD"

  fi

  # for solaris we really need solaris tools, and not gnu equivalent

  #   these seems to normally reside in /usr/ccs/bin so add that to path before

  #   starting to probe

  #

  #   NOTE: I add this /usr/ccs/bin after TOOLS but before OLD_PATH

  #         so that it can be overriden --with-tools-dir

  if test "x$OPENJDK_BUILD_OS" = xsolaris; then

    PATH="${TOOLS_DIR}:/usr/ccs/bin:${OLD_PATH}"

  fi

  # Find the right assembler.

  if test "x$OPENJDK_TARGET_OS" = xsolaris; then

    AC_PATH_PROG(AS, as)

    BASIC_FIXUP_EXECUTABLE(AS)

  else

    AS="$CC -c"

  fi

  AC_SUBST(AS)