#

# 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.30319.01 for 80x86

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

    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

  $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

      HELP_MSG_MISSING_DEPENDENCY([devkit])

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

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

[

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

  TOOLCHAIN_SETUP_VISUAL_STUDIO_ENV

  TOOLCHAIN_SETUP_DXSDK

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

                    ],

                    [])

if test "x$SYS_ROOT" != "x/" ; then                    

    CFLAGS="--sysroot=$SYS_ROOT $CFLAGS"

    CXXFLAGS="--sysroot=$SYS_ROOT $CXXFLAGS"

    OBJCFLAGS="--sysroot=$SYS_ROOT $OBJCFLAGS" 

    OBJCXXFLAGS="--sysroot=$SYS_ROOT $OBJCFLAGS" 

    CPPFLAGS="--sysroot=$SYS_ROOT $CPPFLAGS"

    LDFLAGS="--sysroot=$SYS_ROOT $LDFLAGS"

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$CC" != x; then

  COMPILER_CHECK_LIST="$CC"

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

  COMPILER_CHECK_LIST="cl"

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

  COMPILER_CHECK_LIST="cc gcc"

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

### Locate C++ compiler (CXX)

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

  COMPILER_CHECK_LIST="$CXX"

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

  COMPILER_CHECK_LIST="cl"

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

  COMPILER_CHECK_LIST="CC g++"

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"

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"

    ])

    JDK_UPDATE_VERSION_NOTNULL=$JDK_UPDATE_VERSION

    AS_IF([test "x$JDK_UPDATE_VERSION" = x], [

        JDK_UPDATE_VERSION_NOTNULL=0

    ])

    RC_FLAGS="$RC_FLAGS -d \"JDK_BUILD_ID=$FULL_VERSION\""

    RC_FLAGS="$RC_FLAGS -d \"JDK_COMPANY=$COMPANY_NAME\""

    RC_FLAGS="$RC_FLAGS -d \"JDK_COMPONENT=$PRODUCT_NAME $JDK_RC_PLATFORM_NAME binary\""

    RC_FLAGS="$RC_FLAGS -d \"JDK_VER=$JDK_MINOR_VERSION.$JDK_MICRO_VERSION.$JDK_UPDATE_VERSION_NOTNULL.$COOKED_BUILD_NUMBER\""

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

    RC_FLAGS="$RC_FLAGS -d \"JDK_NAME=$PRODUCT_NAME $JDK_RC_PLATFORM_NAME $JDK_MINOR_VERSION $JDK_UPDATE_META_TAG\""

    RC_FLAGS="$RC_FLAGS -d \"JDK_FVER=$JDK_MINOR_VERSION,$JDK_MICRO_VERSION,$JDK_UPDATE_VERSION_NOTNULL,$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)

if test "x$OPENJDK_TARGET_OS" = xsolaris; then

    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)

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

    AC_CHECK_TOOL(NM, nm)

    BASIC_FIXUP_EXECUTABLE(NM)

    GNM="$NM"

    AC_SUBST(GNM)

    AC_CHECK_TOOL(STRIP, strip)

    BASIC_FIXUP_EXECUTABLE(STRIP)

fi

# objcopy is used for moving debug symbols to separate files when

# full debug symbols are enabled.

if test "x$OPENJDK_TARGET_OS" = xsolaris || test "x$OPENJDK_TARGET_OS" = xlinux; then

    AC_CHECK_TOOLS(OBJCOPY, [gobjcopy objcopy])

    # Only call fixup if objcopy was found.

    if test -n "$OBJCOPY"; then

        BASIC_FIXUP_EXECUTABLE(OBJCOPY)

    fi

fi

AC_CHECK_TOOLS(OBJDUMP, [gobjdump objdump])

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

  # Only used for compare.sh; we can live without it. BASIC_FIXUP_EXECUTABLE bails if argument is missing.

  BASIC_FIXUP_EXECUTABLE(OBJDUMP)

fi

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

   AC_PATH_PROG(LIPO, lipo)

   BASIC_FIXUP_EXECUTABLE(LIPO)

fi

TOOLCHAIN_SETUP_JTREG

# Restore old path without tools dir

PATH="$OLD_PATH"

])

AC_DEFUN_ONCE([TOOLCHAIN_SETUP_COMPILER_FLAGS_FOR_LIBS],

[

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

#

# How to compile shared libraries. 

#

if test "x$GCC" = xyes; then

    COMPILER_NAME=gcc

    PICFLAG="-fPIC"

    LIBRARY_PREFIX=lib

    SHARED_LIBRARY='lib[$]1.so'

    STATIC_LIBRARY='lib[$]1.a'