#

# 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" = 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],

[

])

# $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

  $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, $3)

    $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, $3)

    $1=$POTENTIAL_$1

  fi

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

  fi

  BASIC_FIXUP_EXECUTABLE($1)

  AC_MSG_CHECKING([resolved symbolic links for $1])

  TEST_COMPILER="[$]$1"

  BASIC_REMOVE_SYMBOLIC_LINKS(TEST_COMPILER)

  AC_MSG_RESULT([$TEST_COMPILER])

  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])

    $1="$TEST_COMPILER"

  fi

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

])

AC_DEFUN([TOOLCHAIN_SETUP_PATHS],

[

    # 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)

    AC_PROG_OBJC

    BASIC_FIXUP_EXECUTABLE(OBJC)

    OBJC=

    AC_CHECK_TOOL(AR, ar)

    BASIC_FIXUP_EXECUTABLE(AR)

    ARFLAGS="-r"

    ARFLAGS=""

    # 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], [

    # 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"

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

    AC_PATH_PROG(AS, as)

    BASIC_FIXUP_EXECUTABLE(AS)

    AS="$CC -c"

    AC_PATH_PROG(NM, nm)

    BASIC_FIXUP_EXECUTABLE(NM)

    AC_PATH_PROG(GNM, gnm)

    BASIC_FIXUP_EXECUTABLE(GNM)

    AC_PATH_PROG(STRIP, strip)

    BASIC_FIXUP_EXECUTABLE(STRIP)

    AC_PATH_PROG(MCS, mcs)

    BASIC_FIXUP_EXECUTABLE(MCS)

    AC_CHECK_TOOL(NM, nm)

    BASIC_FIXUP_EXECUTABLE(NM)

    GNM="$NM"

    AC_SUBST(GNM)

    AC_CHECK_TOOL(STRIP, strip)

    BASIC_FIXUP_EXECUTABLE(STRIP)

    AC_CHECK_TOOLS(OBJCOPY, [gobjcopy objcopy])

    # Only call fixup if objcopy was found.

    if test -n "$OBJCOPY"; then

    fi

])

AC_DEFUN_ONCE([TOOLCHAIN_SETUP_COMPILER_FLAGS_FOR_LIBS],

[