Share compiler config code between libs and coreclr (#1072)

* Share compiler config code between libs and coreclr

src/coreclr/src/pal/tools/gen-buildsys.sh → eng/common/cross/gen-buildsys.sh

@@ -19,10 +19,14 @@ scriptroot="$( cd -P "$( dirname "$source" )" && pwd )"
 if [ $# -lt 4 ]
 then
   echo "Usage..."
-  echo "gen-buildsys.sh <path to top level CMakeLists.txt> <path to intermediate directory> <Architecture> [build flavor] [ninja] [scan-build] [cmakeargs]"
+  echo "gen-buildsys.sh <path to top level CMakeLists.txt> <path to intermediate directory> <path to tryrun.cmake directory> <Architecture> <compiler> <compiler major version> <compiler minor version> [build flavor] [ninja] [scan-build] [cmakeargs]"
   echo "Specify the path to the top level CMake file."
+  echo "Specify the path to the directory with tryrun.cmake file."
   echo "Specify the path that the build system files are generated in."
   echo "Specify the target architecture."
+  echo "Specify the name of compiler (clang or gcc)."
+  echo "Specify the major version of compiler."
+  echo "Specify the minor version of compiler."
   echo "Optionally specify the build configuration (flavor.) Defaults to DEBUG."
   echo "Optionally specify 'scan-build' to enable build with clang static analyzer."
   echo "Use the Ninja generator instead of the Unix Makefiles generator."
@@ -30,10 +34,100 @@ then
   exit 1
 fi
 
-__CoreClrDir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )/../../.."
-__RepoRootDir=${__CoreClrDir}/../..
+tryrun_dir="$2"
+build_arch="$4"
+compiler="$5"
+cxxCompiler="$compiler++"
+majorVersion="$6"
+minorVersion="$7"
+
+if [ "$compiler" = "gcc" ]; then cxxCompiler="g++"; fi
+
+check_version_exists() {
+    desired_version=-1
+
+    # Set up the environment to be used for building with the desired compiler.
+    if command -v "$compiler-$1.$2" > /dev/null; then
+        desired_version="-$1.$2"
+    elif command -v "$compier$1$2" > /dev/null; then
+        desired_version="$1$2"
+    elif command -v "$compiler-$1$2" > /dev/null; then
+        desired_version="-$1$2"
+    fi
+
+    echo "$desired_version"
+}
+
+if [ -z "$CLR_CC" ]; then
+
+    # Set default versions
+    if [ -z "$majorVersion" ]; then
+        # note: gcc (all versions) and clang versions higher than 6 do not have minor version in file name, if it is zero.
+        if [ "$compiler" = "clang" ]; then versions=( 9 8 7 6.0 5.0 4.0 3.9 3.8 3.7 3.6 3.5 )
+        elif [ "$compiler" = "gcc" ]; then versions=( 9 8 7 6 5 4.9 ); fi
+
+        for version in "${versions[@]}"; do
+            parts=(${version//./ })
+            desired_version="$(check_version_exists "${parts[0]}" "${parts[1]}")"
+            if [ "$desired_version" != "-1" ]; then majorVersion="${parts[0]}"; break; fi
+        done
+
+        if [ -z "$majorVersion" ]; then
+            if command -v "$compiler" > /dev/null; then
+                if [ "$(uname)" != "Darwin" ]; then
+                    echo "WARN: Specific version of $compiler not found, falling back to use the one in PATH."
+                fi
+                export CC="$(command -v "$compiler")"
+                export CXX="$(command -v "$cxxCompiler")"
+            else
+                echo "ERROR: No usable version of $compiler found."
+                exit 1
+            fi
+        else
+            if [ "$compiler" = "clang" ] && [ "$majorVersion" -lt 5 ]; then
+                if [ "$build_arch" = "arm" ] || [ "$build_arch" = "armel" ]; then
+                    if command -v "$compiler" > /dev/null; then
+                        echo "WARN: Found clang version $majorVersion which is not supported on arm/armel architectures, falling back to use clang from PATH."
+                        export CC="$(command -v "$compiler")"
+                        export CXX="$(command -v "$cxxCompiler")"
+                    else
+                        echo "ERROR: Found clang version $majorVersion which is not supported on arm/armel architectures, and there is no clang in PATH."
+                        exit 1
+                    fi
+                fi
+            fi
+        fi
+    else
+        desired_version="$(check_version_exists "$majorVersion" "$minorVersion")"
+        if [ "$desired_version" = "-1" ]; then
+            echo "ERROR: Could not find specific version of $compiler: $majorVersion $minorVersion."
+            exit 1
+        fi
+    fi
+
+    if [ -z "$CC" ]; then
+        export CC="$(command -v "$compiler$desired_version")"
+        export CXX="$(command -v "$cxxCompiler$desired_version")"
+        if [ -z "$CXX" ]; then export CXX="$(command -v "$cxxCompiler")"; fi
+    fi
+else
+    if [ ! -f "$CLR_CC" ]; then
+        echo "ERROR: CLR_CC is set but path '$CLR_CC' does not exist"
+        exit 1
+    fi
+    export CC="$CLR_CC"
+    export CXX="$CLR_CXX"
+fi
+
+if [ -z "$CC" ]; then
+    echo "ERROR: Unable to find $compiler."
+    exit 1
+fi
+
+export CCC_CC="$CC"
+export CCC_CXX="$CXX"
+export SCAN_BUILD_COMMAND="$(command -v "scan-build$desired_version")"
 
-build_arch="$3"
 buildtype=DEBUG
 code_coverage=OFF
 build_tests=OFF
@@ -41,7 +135,7 @@ scan_build=OFF
 generator="Unix Makefiles"
 __UnprocessedCMakeArgs=""
 
-for i in "${@:4}"; do
+for i in "${@:8}"; do
     upperI="$(echo $i | awk '{print toupper($0)}')"
     case $upperI in
       # Possible build types are DEBUG, CHECKED, RELEASE, RELWITHDEBINFO.
@@ -69,8 +163,8 @@ if [ "$CROSSCOMPILE" == "1" ]; then
         exit 1
     fi
     export TARGET_BUILD_ARCH=$build_arch
-    cmake_extra_defines="$cmake_extra_defines -C ${__CoreClrDir}/tryrun.cmake"
-    cmake_extra_defines="$cmake_extra_defines -DCMAKE_TOOLCHAIN_FILE=${__RepoRootDir}/eng/common/cross/toolchain.cmake"
+    cmake_extra_defines="$cmake_extra_defines -C $tryrun_dir/tryrun.cmake"
+    cmake_extra_defines="$cmake_extra_defines -DCMAKE_TOOLCHAIN_FILE=$scriptroot/toolchain.cmake"
 fi
 
 cmake_command=$(command -v cmake)
@@ -87,4 +181,4 @@ $cmake_command \
   $cmake_extra_defines \
   $__UnprocessedCMakeArgs \
   -S "$1" \
-  -B "$2"
+  -B "$3"

eng/pipelines/coreclr/templates/build-job.yml

@@ -67,6 +67,10 @@ jobs:
       - ${{ if and(eq(parameters.osGroup, 'Linux'), eq(parameters.osSubgroup, '_musl'), eq(parameters.archType, 'x64')) }}:
         - name: clangArg
           value: ''
+      # AppleClang has different version scheme, so we let complier introspection pick up the available clang from PATH
+      - ${{ if eq(parameters.osGroup, 'OSX') }}:
+        - name: clangArg
+          value: ''
     - ${{ if and(ne(variables['System.TeamProject'], 'public'), ne(variables['Build.Reason'], 'PullRequest')) }}:
       # Variables used to publish packages to blob feed
       - name: dotnetfeedUrl

src/coreclr/CMakeLists.txt

@@ -115,7 +115,7 @@ endif(WIN32)
 # Configure compiler settings for environment
 #----------------------------------------------------
 include(configurecompiler.cmake)
-include(configuretools.cmake)
+include(${CLR_COMMON_DIR}/configuretools.cmake)
 
 #----------------------------------------------------
 # Cross target Component build specific configuration

src/coreclr/_build-commons.sh

@@ -2,13 +2,13 @@
 
 initTargetDistroRid()
 {
-    source ${__ProjectDir}/init-distro-rid.sh
+    source "${__ProjectDir}/init-distro-rid.sh"
 
     local passedRootfsDir=""
 
     # Only pass ROOTFS_DIR if cross is specified.
     if [ "$__CrossBuild" = 1 ]; then
-        passedRootfsDir=${ROOTFS_DIR}
+        passedRootfsDir="${ROOTFS_DIR}"
     fi
 
     initDistroRidGlobal "$__BuildOS" "$__BuildArch" "$__PortableBuild" "$passedRootfsDir"
@@ -16,7 +16,7 @@ initTargetDistroRid()
 
 isMSBuildOnNETCoreSupported()
 {
-    __isMSBuildOnNETCoreSupported=$__msbuildonunsupportedplatform
+    __isMSBuildOnNETCoreSupported="$__msbuildonunsupportedplatform"
 
     if [ "$__isMSBuildOnNETCoreSupported" = 1 ]; then
         return
@@ -64,7 +64,7 @@ usage()
     echo ""
     echo "Additional Options:"
     echo ""
-    for i in ${!usage_list[@]}; do
+    for i in "${!usage_list[@]}"; do
         echo "${usage_list[${i}]}"
     done
     echo ""
@@ -79,7 +79,7 @@ if [ "$CPUName" = "unknown" ]; then
     CPUName=$(uname -m)
 fi
 
-case $CPUName in
+case "$CPUName" in
     aarch64)
         __BuildArch=arm64
         __HostArch=arm64
@@ -116,7 +116,7 @@ esac
 
 # Use uname to determine what the OS is.
 OSName=$(uname -s)
-case $OSName in
+case "$OSName" in
     Darwin)
         __BuildOS=OSX
         __HostOS=OSX
@@ -155,12 +155,12 @@ case $OSName in
 esac
 
 while :; do
-    if [ $# -le 0 ]; then
+    if [ "$#" -le 0 ]; then
         break
     fi
 
     lowerI="$(echo "$1" | awk '{print tolower($0)}')"
-    case $lowerI in
+    case "$lowerI" in
         -\?|-h|--help)
             usage
             exit 1
@@ -185,7 +185,7 @@ while :; do
                     mkdir "$__RootBinDir"
                 fi
                 __RootBinParent=$(dirname "$__RootBinDir")
-                __RootBinName=${__RootBinDir##*/}
+                __RootBinName="${__RootBinDir##*/}"
                 __RootBinDir="$(cd "$__RootBinParent" &>/dev/null && printf %s/%s "$PWD" "$__RootBinName")"
                 shift
             else
@@ -203,59 +203,16 @@ while :; do
             __ErrMsgPrefix="##vso[task.logissue type=error]"
             ;;
 
-        clang3.5|-clang3.5)
-            __ClangMajorVersion=3
-            __ClangMinorVersion=5
-            ;;
-
-        clang3.6|-clang3.6)
-            __ClangMajorVersion=3
-            __ClangMinorVersion=6
-            ;;
-
-        clang3.7|-clang3.7)
-            __ClangMajorVersion=3
-            __ClangMinorVersion=7
-            ;;
-
-        clang3.8|-clang3.8)
-            __ClangMajorVersion=3
-            __ClangMinorVersion=8
-            ;;
-
-        clang3.9|-clang3.9)
-            __ClangMajorVersion=3
-            __ClangMinorVersion=9
-            ;;
-
-        clang4.0|-clang4.0)
-            __ClangMajorVersion=4
-            __ClangMinorVersion=0
-            ;;
-
-        clang5.0|-clang5.0)
-            __ClangMajorVersion=5
-            __ClangMinorVersion=0
-            ;;
-
-        clang6.0|-clang6.0)
-            __ClangMajorVersion=6
-            __ClangMinorVersion=0
-            ;;
-
-        clang7|-clang7)
-            __ClangMajorVersion=7
-            __ClangMinorVersion=
-            ;;
-
-        clang8|-clang8)
-            __ClangMajorVersion=8
-            __ClangMinorVersion=
-            ;;
-
-        clang9|-clang9)
-            __ClangMajorVersion=9
-            __ClangMinorVersion=
+        clang*|-clang*)
+                __Compiler=clang
+                # clangx.y or clang-x.y
+                version="$(echo "$lowerI" | tr -d '[:alpha:]-=')"
+                parts=(${version//./ })
+                __CompilerMajorVersion="${parts[0]}"
+                __CompilerMinorVersion="${parts[1]}"
+                if [ -z "$__CompilerMinorVersion" ] && [ "$__CompilerMajorVersion" -le 6 ]; then
+                    __CompilerMinorVersion=0;
+                fi
             ;;
 
         cmakeargs|-cmakeargs)
@@ -286,40 +243,13 @@ while :; do
             __BuildType=Debug
             ;;
 
-        gcc5|-gcc5)
-            __GccMajorVersion=5
-            __GccMinorVersion=
-            __GccBuild=1
-            ;;
-
-        gcc6|-gcc6)
-            __GccMajorVersion=6
-            __GccMinorVersion=
-            __GccBuild=1
-            ;;
-
-        gcc7|-gcc7)
-            __GccMajorVersion=7
-            __GccMinorVersion=
-            __GccBuild=1
-            ;;
-
-        gcc8|-gcc8)
-            __GccMajorVersion=8
-            __GccMinorVersion=
-            __GccBuild=1
-            ;;
-
-        gcc9|-gcc9)
-            __GccMajorVersion=9
-            __GccMinorVersion=
-            __GccBuild=1
-            ;;
-
-        gcc|-gcc)
-            __GccMajorVersion=
-            __GccMinorVersion=
-            __GccBuild=1
+        gcc*|-gcc*)
+                __Compiler=gcc
+                # gccx.y or gcc-x.y
+                version="$(echo "$lowerI" | tr -d '[:alpha:]-=')"
+                parts=(${version//./ })
+                __CompilerMajorVersion="${parts[0]}"
+                __CompilerMinorVersion="${parts[1]}"
             ;;
 
         msbuildonunsupportedplatform|-msbuildonunsupportedplatform)
@@ -412,14 +342,3 @@ if [ "$__VerboseBuild" = 1 ]; then
     export VERBOSE=1
     __CommonMSBuildArgs="$__CommonMSBuildArgs /v:detailed"
 fi
-
-# Set default clang version
-if [ "$__ClangMajorVersion" = 0 ] && [ "$__ClangMinorVersion" = 0 ]; then
-    if [ "$__BuildArch" = "arm" ] || [ "$__BuildArch" = "armel" ]; then
-        __ClangMajorVersion=5
-        __ClangMinorVersion=0
-    else
-        __ClangMajorVersion=3
-        __ClangMinorVersion=9
-    fi
-fi

src/coreclr/build-test.cmd

@@ -234,7 +234,7 @@ if not defined VSINSTALLDIR (
 )
 if not exist "%VSINSTALLDIR%DIA SDK" goto NoDIA
 
-set __ExtraCmakeArgs="-DCMAKE_SYSTEM_VERSION=10.0"
+set __ExtraCmakeArgs="-DCMAKE_SYSTEM_VERSION=10.0" "-DCLR_COMMON_DIR=%__RepoRootDir%/eng/common"
 call "%__SourceDir%\pal\tools\gen-buildsys.cmd" "%__ProjectFilesDir%" "%__NativeTestIntermediatesDir%" %__VSVersion% %__BuildArch% !__ExtraCmakeArgs!
 
 if not !errorlevel! == 0 (

src/coreclr/build-test.sh

@@ -493,20 +493,13 @@ build_native_projects()
             fi
         fi
 
-        scriptDir="$__ProjectRoot/src/pal/tools"
-        if [[ $__GccBuild == 0 ]]; then
-            echo "Invoking \"$scriptDir/find-clang.sh\" $__ClangMajorVersion \"$__ClangMinorVersion\""
-            source "$scriptDir/find-clang.sh" $__ClangMajorVersion "$__ClangMinorVersion"
-        else
-            echo "Invoking \"$scriptDir/find-gcc.sh\" \"$__GccMajorVersion\" \"$__GccMinorVersion\""
-            source "$scriptDir/find-gcc.sh" "$__GccMajorVersion" "$__GccMinorVersion"
-        fi
-
         if [[ -n "$__CodeCoverage" ]]; then
             extraCmakeArguments="$extraCmakeArguments -DCLR_CMAKE_ENABLE_CODE_COVERAGE=1"
         fi
 
-        nextCommand="\"$scriptDir/gen-buildsys.sh\" \"$__TestDir\" \"$intermediatesForBuild\" $platformArch $__BuildType $generator $extraCmakeArguments $__cmakeargs"
+        commonDir="$__RepoRootDir/eng/common"
+        __cmakeargs="$__cmakeargs -DCLR_COMMON_DIR=\"$commonDir\""
+        nextCommand="\"$commonDir/cross/gen-buildsys.sh\" \"$__TestDir\" \"$__ProjectRoot\" \"$intermediatesForBuild\" $platformArch $__Compiler \"$__CompilerMajorVersion\" \"$__CompilerMinorVersion\" $__BuildType $generator $extraCmakeArguments $__cmakeargs"
         echo "Invoking $nextCommand"
         eval $nextCommand
 
@@ -614,8 +607,9 @@ __IncludeTests=INCLUDE_TESTS
 export __ProjectDir="$__ProjectRoot"
 __BuildTestWrappers=1
 __BuildTestWrappersOnly=
-__ClangMajorVersion=0
-__ClangMinorVersion=0
+__Compiler=clang
+__CompilerMajorVersion=
+__CompilerMinorVersion=
 __CommonMSBuildArgs=
 __ConfigureOnly=0
 __CopyNativeProjectsAfterCombinedTestBuild=true
@@ -625,9 +619,6 @@ __DistroRid=""
 __DoCrossgen=0
 __DoCrossgen2=0
 __DotNetCli="$__RepoRootDir/dotnet.sh"
-__GccBuild=0
-__GccMajorVersion=0
-__GccMinorVersion=0
 __GenerateLayoutOnly=
 __GenerateTestHostOnly=
 __MSBCleanBuildArgs=

src/coreclr/build.cmd

@@ -484,7 +484,7 @@ if %__BuildCrossArchNative% EQU 1 (
 
     set __CMakeBinDir=%__CrossComponentBinDir%
     set "__CMakeBinDir=!__CMakeBinDir:\=/!"
-    set __ExtraCmakeArgs="-DCLR_CROSS_COMPONENTS_BUILD=1" "-DCLR_CMAKE_TARGET_ARCH=%__BuildArch%" "-DCLR_CMAKE_PGO_INSTRUMENT=%__PgoInstrument%" "-DCLR_CMAKE_OPTDATA_PATH=%__PgoOptDataPath%" "-DCLR_CMAKE_PGO_OPTIMIZE=%__PgoOptimize%" "-DCMAKE_SYSTEM_VERSION=10.0"
+    set __ExtraCmakeArgs="-DCLR_CROSS_COMPONENTS_BUILD=1" "-DCLR_CMAKE_TARGET_ARCH=%__BuildArch%" "-DCLR_CMAKE_PGO_INSTRUMENT=%__PgoInstrument%" "-DCLR_CMAKE_OPTDATA_PATH=%__PgoOptDataPath%" "-DCLR_CMAKE_PGO_OPTIMIZE=%__PgoOptimize%" "-DCMAKE_SYSTEM_VERSION=10.0" "-DCLR_COMMON_DIR=%__RepoRootDir%/eng/common"
     call "%__SourceDir%\pal\tools\gen-buildsys.cmd" "%__ProjectDir%" "%__CrossCompIntermediatesDir%" %__VSVersion% %__CrossArch% !__ExtraCmakeArgs!
     
     if not !errorlevel! == 0 (
@@ -567,7 +567,7 @@ if %__BuildNative% EQU 1 (
 
     echo %__MsgPrefix%Regenerating the Visual Studio solution
 
-    set __ExtraCmakeArgs=!___SDKVersion! !___CrossBuildDefine! "-DCLR_CMAKE_PGO_INSTRUMENT=%__PgoInstrument%" "-DCLR_CMAKE_OPTDATA_PATH=%__PgoOptDataPath%" "-DCLR_CMAKE_PGO_OPTIMIZE=%__PgoOptimize%"
+    set __ExtraCmakeArgs=!___SDKVersion! !___CrossBuildDefine! "-DCLR_CMAKE_PGO_INSTRUMENT=%__PgoInstrument%" "-DCLR_CMAKE_OPTDATA_PATH=%__PgoOptDataPath%" "-DCLR_CMAKE_PGO_OPTIMIZE=%__PgoOptimize%" "-DCLR_COMMON_DIR=%__RepoRootDir%/eng/common"
     call "%__SourceDir%\pal\tools\gen-buildsys.cmd" "%__ProjectDir%" "%__IntermediatesDir%" %__VSVersion% %__BuildArch% !__ExtraCmakeArgs!
     if not !errorlevel! == 0 (
         echo %__ErrMsgPrefix%%__MsgPrefix%Error: failed to generate native component build project!

src/coreclr/build.sh

@@ -71,29 +71,6 @@ check_prereqs()
     if [[ $(version $cmake_version) -lt $(version 3.14.0) ]]; then
         echo "Please install CMake 3.14 or newer from http://www.cmake.org/download/ or https://apt.kitware.com and ensure it is on your path."; exit 1;
     fi
-
-    # Minimum required version of clang is version 4.0 for arm/armel cross build
-    if [[ $__CrossBuild == 1 && $__GccBuild == 0 &&  ("$__BuildArch" == "arm" || "$__BuildArch" == "armel") ]]; then
-        if ! [[ "$__ClangMajorVersion" -ge "4" ]]; then
-            echo "Please install clang4.0 or latest for arm/armel cross build"; exit 1;
-        fi
-    fi
-
-    # Check for clang
-    if [[ $__GccBuild == 0 ]]; then
-        __ClangCombinedDottedVersion=$__ClangMajorVersion;
-        if [[ "$__ClangMinorVersion" != "" ]]; then
-            __ClangCombinedDottedVersion=$__ClangCombinedDottedVersion.$__ClangMinorVersion
-        fi
-        hash clang-$__ClangCombinedDottedVersion 2>/dev/null ||  hash clang$__ClangMajorVersion$__ClangMinorVersion 2>/dev/null || hash clang 2>/dev/null || { echo >&2 "Please install clang-$__ClangMajorVersion.$__ClangMinorVersion before running this script"; exit 1; }
-    else
-        __GccCombinedDottedVersion=$__GccMajorVersion;
-        if [[ "$__GccMinorVersion" != "" ]]; then
-            __GccCombinedDottedVersion=$__GccCombinedDottedVersion.$__GccMinorVersion
-        fi
-        hash gcc-$__GccCombinedDottedVersion 2>/dev/null ||  hash gcc$__GccMajorVersion$__GccMinorVersion 2>/dev/null || hash gcc 2>/dev/null || { echo >&2 "Please install gcc-$__GccMajorVersion.$__GccMinorVersion before running this script"; exit 1; }
-    fi
-
 }
 
 restore_optdata()
@@ -215,23 +192,16 @@ build_native()
 
         # Regenerate the CMake solution
 
-        scriptDir="$__ProjectRoot/src/pal/tools"
-        if [[ $__GccBuild == 0 ]]; then
-            echo "Invoking \"$scriptDir/find-clang.sh\" $__ClangMajorVersion \"$__ClangMinorVersion\""
-            source "$scriptDir/find-clang.sh" $__ClangMajorVersion "$__ClangMinorVersion"
-            if [[ $__StaticAnalyzer == 1 ]]; then
-                scan_build=scan-build
-            fi
-        else
-            echo "Invoking \"$scriptDir/find-gcc.sh\" \"$__GccMajorVersion\" \"$__GccMinorVersion\""
-            source "$scriptDir/find-gcc.sh" "$__GccMajorVersion" "$__GccMinorVersion"
+        if [ "$__StaticAnalyzer" = 1 ]; then
+            scan_build=scan-build
         fi
-
         if [[ -n "$__CodeCoverage" ]]; then
             extraCmakeArguments="$extraCmakeArguments -DCLR_CMAKE_ENABLE_CODE_COVERAGE=1"
         fi
 
-        nextCommand="\"$scriptDir/gen-buildsys.sh\" \"$__ProjectRoot\" \"$intermediatesForBuild\" $platformArch $__BuildType $generator $scan_build $extraCmakeArguments $__cmakeargs"
+        commonDir="$__RepoRootDir/eng/common"
+        __cmakeargs="$__cmakeargs -DCLR_COMMON_DIR=\"$commonDir\""
+        nextCommand="\"$commonDir/cross/gen-buildsys.sh\" \"$__ProjectRoot\" \"$__ProjectRoot\" \"$intermediatesForBuild\" $platformArch $__Compiler \"$__CompilerMajorVersion\" \"$__CompilerMinorVersion\" $__BuildType $generator $scan_build $extraCmakeArguments $__cmakeargs"
         echo "Invoking $nextCommand"
         eval $nextCommand
 
@@ -588,16 +558,14 @@ __IgnoreWarnings=0
 
 # Set the various build properties here so that CMake and MSBuild can pick them up
 __BuildManagedTools=1
-__ClangMajorVersion=0
-__ClangMinorVersion=0
+__Compiler=clang
+__CompilerMajorVersion=
+__CompilerMinorVersion=
 __CommonMSBuildArgs=
 __ConfigureOnly=0
 __CrossBuild=0
 __CrossgenOnly=0
 __DistroRid=""
-__GccBuild=0
-__GccMajorVersion=0
-__GccMinorVersion=0
 __IbcOptDataPath=""
 __IbcTuning=""
 __MSBCleanBuildArgs=

src/coreclr/src/pal/tools/find-clang.sh

-#!/usr/bin/env bash
-#
-# This file finds Clang on the system.
-#
-
-if [ $# -lt 2 ]
-then
-  echo "Usage..."
-  echo "find-clang.sh <ClangMajorVersion> <ClangMinorVersion>"
-  echo "Specify the clang version to use, split into major and minor version"
-  exit 1
-fi
-
-# Set up the environment to be used for building with clang.
-if command -v "clang-$1.$2" > /dev/null
-    then
-        desired_llvm_version="-$1.$2"
-elif command -v "clang$1$2" > /dev/null
-    then
-        desired_llvm_version="$1$2"
-elif command -v "clang-$1$2" > /dev/null
-    then
-        desired_llvm_version="-$1$2"
-elif command -v clang > /dev/null
-    then
-        desired_llvm_version=
-else
-    echo "Unable to find Clang Compiler"
-    exit 1
-fi
-
-export CC="$(command -v clang$desired_llvm_version)"
-export CXX="$(command -v clang++$desired_llvm_version)"
-export CCC_CC=$CC
-export CCC_CXX=$CXX
-export SCAN_BUILD_COMMAND=$(command -v scan-build$desired_llvm_version)

src/coreclr/src/pal/tools/find-gcc.sh

-#!/usr/bin/env sh
-#
-# This file finds GCC on the system.
-#
-
-if [ $# -lt 2 ]
-then
-  echo "Usage..."
-  echo "find-gcc.sh <GccMajorVersion> <GccMinorVersion>"
-  echo "Specify the Gcc version to use, split into major and minor version"
-  exit 1
-fi
-
-# Locate gcc
-gcc_prefix=""
-
-if [ "$CROSSCOMPILE" = "1" ]; then
-  # Locate gcc
-  if [ -n "$TOOLCHAIN" ]; then
-    gcc_prefix="$TOOLCHAIN-"
-  fi
-fi
-
-# Set up the environment to be used for building with gcc.
-if command -v "${gcc_prefix}gcc-$1.$2" > /dev/null
-    then
-        desired_gcc_version="-$1.$2"
-elif command -v "${gcc_prefix}gcc$1$2" > /dev/null
-    then
-        desired_gcc_version="$1$2"
-elif command -v "${gcc_prefix}gcc-$1$2" > /dev/null
-    then
-        desired_gcc_version="-$1$2"
-elif command -v "${gcc_prefix}gcc" > /dev/null
-    then
-        desired_gcc_version=
-else
-    echo "Unable to find ${gcc_prefix}gcc Compiler"
-    exit 1
-fi
-
-if [ -z "$CLR_CC" ]; then
-    CC="$(command -v "${gcc_prefix}gcc$desired_gcc_version")"
-else
-    CC="$CLR_CC"
-fi
-
-if [ -z "$CLR_CXX" ]; then
-    CXX="$(command -v "${gcc_prefix}g++$desired_gcc_version")"
-else
-    CXX="$CLR_CXX"
-fi
-
-export CC
-export CXX

src/coreclr/tests/CMakeLists.txt

@@ -10,7 +10,7 @@ endif()
 
 # Include global configure settings
 include(${CMAKE_CURRENT_SOURCE_DIR}/../configurecompiler.cmake)
-include(${CMAKE_CURRENT_SOURCE_DIR}/../configuretools.cmake)
+include(${CLR_COMMON_DIR}/configuretools.cmake)
 # Compile options
 
 if (WIN32)

src/libraries/Native/Unix/CMakeLists.txt

-cmake_minimum_required(VERSION 2.8.12)
+cmake_minimum_required(VERSION 3.14)
+cmake_policy(SET CMP0042 NEW)
+
 project(CoreFX C)
 
 if(NOT CMAKE_SYSTEM_NAME STREQUAL Emscripten)
@@ -279,6 +281,7 @@ function(install_library_and_symbols targetName)
 endfunction()
 
 include(configure.cmake)
+include(${CLR_COMMON_DIR}/configuretools.cmake)
 
 add_subdirectory(System.IO.Compression.Native)
 

src/libraries/Native/Unix/System.Globalization.Native/CMakeLists.txt

@@ -40,14 +40,6 @@ else()
         message(FATAL_ERROR "Cannot find libicui18n, try installing libicu-dev (or the appropriate package for your platform)")
         return()
     endif()
-
-    add_custom_command(TARGET System.Globalization.Native POST_BUILD
-        COMMENT "Verifying System.Globalization.Native.so dependencies"
-        COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/../verify-so.sh 
-            $<TARGET_FILE:System.Globalization.Native> 
-            "Verification failed. System.Globalization.Native.so has undefined dependencies. These are likely ICU APIs that need to be added to icushim.h."
-        VERBATIM
-    )
 endif()
 
 include(configure.cmake)
@@ -90,3 +82,13 @@ set_target_properties(System.Globalization.Native-Static PROPERTIES PREFIX "")
 set_target_properties(System.Globalization.Native-Static PROPERTIES OUTPUT_NAME System.Globalization.Native  CLEAN_DIRECT_OUTPUT 1)
 
 install (TARGETS System.Globalization.Native-Static DESTINATION .)
+
+if(NOT CMAKE_SYSTEM_NAME STREQUAL Darwin)
+    add_custom_command(TARGET System.Globalization.Native POST_BUILD
+        COMMENT "Verifying System.Globalization.Native.so dependencies"
+        COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/../verify-so.sh
+            $<TARGET_FILE:System.Globalization.Native>
+            "Verification failed. System.Globalization.Native.so has undefined dependencies. These are likely ICU APIs that need to be added to icushim.h."
+        VERBATIM
+    )
+endif()

src/libraries/Native/Unix/gen-buildsys-clang.sh

-#!/usr/bin/env bash
-#
-# This file invokes cmake and generates the build system for Clang.
-#
-
-source="${BASH_SOURCE[0]}"
-
-# resolve $SOURCE until the file is no longer a symlink
-while [[ -h $source ]]; do
-  scriptroot="$( cd -P "$( dirname "$source" )" && pwd )"
-  source="$(readlink "$source")"
-
-  # if $source was a relative symlink, we need to resolve it relative to the path where the
-  # symlink file was located
-  [[ $source != /* ]] && source="$scriptroot/$source"
-done
-scriptroot="$( cd -P "$( dirname "$source" )" && pwd )"
-
-if [ $# -lt 5 -o $# -gt 7 ]
-then
-  echo "Usage..."
-  echo "gen-buildsys-clang.sh <path to repo root> <path to top level CMakeLists.txt> <ClangMajorVersion> <ClangMinorVersion> <Architecture> [build flavor] [cmakeargs]"
-  echo "Specify the path to the top level CMake file - <corefx>/src/Native/Unix"
-  echo "Specify the clang version to use, split into major and minor version"
-  echo "Specify the target architecture." 
-  echo "Optionally specify the build configuration (flavor.) Defaults to DEBUG." 
-  echo "Optionally pass additional arguments to CMake call."
-  exit 1
-fi
-
-#root directory of the project
-repo_root=$1
-
-# Set up the environment to be used for building with clang.
-if which "clang-$3.$4" > /dev/null 2>&1
-    then
-        export CC="$(which clang-$3.$4)"
-elif which "clang-$3$4" > /dev/null 2>&1
-    then
-        export CC="$(which clang-$3$4)"
-elif which "clang$3$4" > /dev/null 2>&1
-    then
-        export CC="$(which clang$3$4)"
-elif which clang > /dev/null 2>&1
-    then
-        export CC="$(which clang)"
-else
-    echo "Unable to find Clang Compiler"
-    exit 1
-fi
-
-build_arch="$5"
-# Possible build types are DEBUG, RELEASE, RELWITHDEBINFO, MINSIZEREL.
-# Default to DEBUG
-if [ -z "$6" ]
-then
-  echo "Defaulting to DEBUG build."
-  buildtype="DEBUG"
-else
-  buildtype="$6"
-fi
-
-cmake_cmd=cmake
-cmake_extra_defines="-DCMAKE_BUILD_TYPE=$buildtype"
-if [[ -n "$CROSSCOMPILE" ]]; then
-    if ! [[ -n "$ROOTFS_DIR" ]]; then
-        echo "ROOTFS_DIR not set for crosscompile"
-        exit 1
-    fi
-    if [[ -z "$CONFIG_DIR" ]]; then
-        CONFIG_DIR="$repo_root/eng/common/cross"
-    fi
-    export TARGET_BUILD_ARCH=$build_arch
-    cmake_extra_defines="$cmake_extra_defines -C $scriptroot/tryrun.cmake"
-    cmake_extra_defines="$cmake_extra_defines -DCMAKE_TOOLCHAIN_FILE=$CONFIG_DIR/toolchain.cmake"
-fi
-if [ "$build_arch" == "armel" ]; then
-    cmake_extra_defines="$cmake_extra_defines -DARM_SOFTFP=1"
-fi
-if [ "$build_arch" == "wasm" ]; then
-   if [ "$EMSCRIPTEN_ROOT" == "" ]; then
-       EMSCRIPTEN_ROOT="$EMSDK_PATH/upstream/emscripten"
-   fi
-   cmake_cmd="emcmake cmake"
-   cmake_extra_defines="$cmake_extra_defines -DCMAKE_TOOLCHAIN_FILE=$EMSCRIPTEN_ROOT/cmake/Modules/Platform/Emscripten.cmake -DEMSCRIPTEN_GENERATE_BITCODE_STATIC_LIBRARIES=1"
-fi
-
-__UnprocessedCMakeArgs=""
-if [ -z "$7" ]; then
-    echo "No CMake extra Args specified"
-else
-    __UnprocessedCMakeArgs="$7"
-fi
-
-echo "Invoking \"$cmake_cmd $cmake_extra_defines $__UnprocessedCMakeArgs $2\""
-$cmake_cmd $cmake_extra_defines \
-    $__UnprocessedCMakeArgs \
-    $2

src/libraries/Native/Unix/gen-buildsys-gcc.sh

-#!/usr/bin/env sh
-#
-# This file invokes cmake and generates the build system for Gcc.
-#
-
-source="${BASH_SOURCE[0]}"
-
-# resolve $SOURCE until the file is no longer a symlink
-while [[ -h $source ]]; do
-  scriptroot="$( cd -P "$( dirname "$source" )" && pwd )"
-  source="$(readlink "$source")"
-
-  # if $source was a relative symlink, we need to resolve it relative to the path where the
-  # symlink file was located
-  [[ $source != /* ]] && source="$scriptroot/$source"
-done
-scriptroot="$( cd -P "$( dirname "$source" )" && pwd )"
-
-if [ $# -lt 5 ]
-then
-  echo "Usage..."
-  echo "gen-buildsys-gcc.sh <path to repo root> <path to top level CMakeLists.txt> <GccMajorVersion> <GccMinorVersion> <Architecture> [build flavor] [cmakeargs]"
-  echo "Specify the path to the top level CMake file - <corefx>/src/Native/Unix"
-  echo "Specify the gcc version to use, split into major and minor version"
-  echo "Specify the target architecture."
-  echo "Optionally specify the build configuration (flavor.) Defaults to DEBUG." 
-  echo "Optionally pass additional arguments to CMake call."
-  exit 1
-fi
-
-#root directory of the project
-repo_root=$1
-
-# Locate gcc
-gcc_prefix=""
-
-if [ "$CROSSCOMPILE" = "1" ]; then
-  # Locate gcc
-  if [ -n "$TOOLCHAIN" ]; then
-    gcc_prefix="$TOOLCHAIN-"
-  fi
-fi
-
-# Set up the environment to be used for building with gcc.
-if command -v "${gcc_prefix}gcc-$3.$4" > /dev/null
-    then
-        desired_gcc_version="-$3.$4"
-elif command -v "${gcc_prefix}gcc$3$4" > /dev/null
-    then
-        desired_gcc_version="$3$4"
-elif command -v "${gcc_prefix}gcc-$3$4" > /dev/null
-    then
-        desired_gcc_version="-$3$4"
-elif command -v "${gcc_prefix}gcc" > /dev/null
-    then
-        desired_gcc_version=
-else
-    echo "Unable to find ${gcc_prefix}gcc Compiler"
-    exit 1
-fi
-
-if [ -z "$CLR_CC" ]; then
-    CC="$(command -v "${gcc_prefix}gcc$desired_gcc_version")"
-else
-    CC="$CLR_CC"
-fi
-
-if [ -z "$CLR_CXX" ]; then
-    CXX="$(command -v "${gcc_prefix}g++$desired_gcc_version")"
-else
-    CXX="$CLR_CXX"
-fi
-
-export CC CXX
-
-build_arch="$5"
-buildtype=DEBUG
-__UnprocessedCMakeArgs=""
-
-ITER=-1
-for i in "$@"; do
-    ITER=$((ITER + 1))
-    if [ $ITER -lt 5 ]; then continue; fi
-    upperI="$(echo "$i" | awk '{print toupper($0)}')"
-    case $upperI in
-      # Possible build types are DEBUG, CHECKED, RELEASE, RELWITHDEBINFO, MINSIZEREL.
-      DEBUG | CHECKED | RELEASE | RELWITHDEBINFO | MINSIZEREL)
-      buildtype=$upperI
-      ;;
-      *)
-      __UnprocessedCMakeArgs="${__UnprocessedCMakeArgs}${__UnprocessedCMakeArgs:+ }$i"
-    esac
-done
-
-OS=$(uname)
-
-locate_gcc_exec() {
-  ENV_KNOB="CLR_$(echo "$2" | tr '[:lower:]' '[:upper:]')"
-  if env | grep -q "^$ENV_KNOB="; then
-    eval "echo \"\$$ENV_KNOB\""
-    return
-  fi
-
-  if command -v "$gcc_prefix$2$desired_gcc_version" > /dev/null 2>&1
-  then
-    command -v "$gcc_prefix$2$desired_gcc_version"
-  elif command -v "$gcc_prefix$2" > /dev/null 2>&1
-  then
-    command -v "$gcc_prefix$2"
-  else
-    exit 1
-  fi
-}
-
-if ! gcc_link="$(locate_gcc_exec link)"; then { echo "Unable to locate link"; exit 1; } fi
-
-if ! gcc_ar="$(locate_gcc_exec ar)"; then { echo "Unable to locate gcc-ar"; exit 1; } fi
-
-if ! gcc_nm="$(locate_gcc_exec nm)"; then { echo "Unable to locate gcc-nm"; exit 1; } fi
-
-if [ "$OS" = "Linux" ] || [ "$OS" = "FreeBSD" ] || [ "$OS" = "OpenBSD" ] || [ "$OS" = "NetBSD" ] || [ "$OS" = "SunOS" ]; then
-  if ! gcc_objdump="$(locate_gcc_exec objdump)"; then { echo "Unable to locate gcc-objdump"; exit 1; } fi
-fi
-
-if ! gcc_objcopy="$(locate_gcc_exec objcopy)"; then { echo "Unable to locate gcc-objcopy"; exit 1; } fi
-
-if ! gcc_ranlib="$(locate_gcc_exec ranlib)"; then { echo "Unable to locate gcc-ranlib"; exit 1; } fi
-
-cmake_extra_defines=
-if [ -n "$LLDB_LIB_DIR" ]; then
-    cmake_extra_defines="$cmake_extra_defines -DWITH_LLDB_LIBS=$LLDB_LIB_DIR"
-fi
-if [ -n "$LLDB_INCLUDE_DIR" ]; then
-    cmake_extra_defines="$cmake_extra_defines -DWITH_LLDB_INCLUDES=$LLDB_INCLUDE_DIR"
-fi
-if [ "$CROSSCOMPILE" = "1" ]; then
-    if [ -z "$ROOTFS_DIR" ]; then
-        echo "ROOTFS_DIR not set for crosscompile"
-        exit 1
-    fi
-    if [ -z "$CONFIG_DIR" ]; then
-        CONFIG_DIR="$repo_root/eng/common/cross"
-    fi
-    export TARGET_BUILD_ARCH=$build_arch
-    cmake_extra_defines="$cmake_extra_defines -C $scriptroot/tryrun.cmake"
-    cmake_extra_defines="$cmake_extra_defines -DCMAKE_TOOLCHAIN_FILE=$CONFIG_DIR/toolchain.cmake"
-    cmake_extra_defines="$cmake_extra_defines --sysroot=$ROOTFS_DIR"
-    cmake_extra_defines="$cmake_extra_defines -DCLR_UNIX_CROSS_BUILD=1"
-fi
-if [ "$build_arch" = "armel" ]; then
-    cmake_extra_defines="$cmake_extra_defines -DARM_SOFTFP=1"
-fi
-
-cmake \
-  "-DCMAKE_AR=$gcc_ar" \
-  "-DCMAKE_LINKER=$gcc_link" \
-  "-DCMAKE_NM=$gcc_nm" \
-  "-DCMAKE_RANLIB=$gcc_ranlib" \
-  "-DCMAKE_OBJCOPY=$gcc_objcopy" \
-  "-DCMAKE_OBJDUMP=$gcc_objdump" \
-  "-DCMAKE_BUILD_TYPE=$buildtype" \
-  "-DCMAKE_EXPORT_COMPILE_COMMANDS=1 " \
-  $cmake_extra_defines \
-  "$__UnprocessedCMakeArgs" \
-  "$2"

src/libraries/Native/build-native.sh

@@ -92,28 +92,6 @@ check_native_prereqs()
 
     # Check presence of CMake on the path
     hash cmake 2>/dev/null || { echo >&2 "Please install cmake before running this script"; exit 1; }
-
-    if [ "$__GccBuild" = 0 ]; then
-        # Minimum required version of clang is version 3.9 for arm/armel cross build
-        if [ "$__CrossBuild" = 1 ] && { [ "$__BuildArch" = "arm" ] || [ "$__BuildArch" = "armel" ]; }; then
-            if [ "$__ClangMajorVersion" -lt 3 ] || { [ "$__ClangMajorVersion" -eq 3 ] && [ "$__ClangMinorVersion" -lt 9 ]; }; then
-                echo "Please install clang3.9 or latest for arm/armel cross build"; exit 1;
-            fi
-        fi
-
-        # Check for clang
-        hash "clang-$__ClangMajorVersion.$__ClangMinorVersion" 2>/dev/null || hash "clang-$__ClangMajorVersion$__ClangMinorVersion" 2>/dev/null || hash "clang$__ClangMajorVersion$__ClangMinorVersion" 2>/dev/null ||  hash clang 2>/dev/null || { echo >&2 "Please install clang before running this script"; exit 1; }
-    else
-        # Minimum required version of gcc is version 5.0 for arm/armel cross build
-        if [ "$__CrossBuild" = 1 ] && { [ "$__BuildArch" = "arm" ] || [ "$__BuildArch" = "armel" ]; }; then
-            if [ "$__GccMajorVersion" -lt 5 ]; then
-                echo "Please install gcc version 5 or latest for arm/armel cross build"; exit 1;
-            fi
-        fi
-
-        # Check for gcc
-        hash "gcc-$__GccMajorVersion.$__GccMinorVersion" 2>/dev/null || hash "gcc$__GccMajorVersion$__GccMinorVersion" 2>/dev/null ||  hash gcc 2>/dev/null || { echo >&2 "Please install gcc before running this script"; exit 1; }
-    fi
 }
 
 prepare_native_build()
@@ -151,18 +129,21 @@ build_native()
     fi
 
     # Regenerate the CMake solution
-    if [ "$__GccBuild" = 0 ]; then
-        echo "Invoking \"$__nativeroot/gen-buildsys-clang.sh\" \"$__rootRepo\" \"$__nativeroot\" \"$__ClangMajorVersion\" \"$__ClangMinorVersion\" \"$__BuildArch\" \"$__CMakeArgs\" \"$__CMakeExtraArgs\""
-        "$__nativeroot/gen-buildsys-clang.sh" "$__rootRepo" "$__nativeroot" "$__ClangMajorVersion" "$__ClangMinorVersion" "$__BuildArch" "$__CMakeArgs" "$__CMakeExtraArgs"
-    else
-        echo "Invoking \"$__nativeroot/gen-buildsys-gcc.sh\" \"$__rootRepo\" \"$__nativeroot\" \"$__GccMajorVersion\" \"$__GccMinorVersion\" \"$__BuildArch\" \"$__CMakeArgs\" \"$__CMakeExtraArgs\""
-        "$__nativeroot/gen-buildsys-gcc.sh" "$__rootRepo" "$__nativeroot" "$__GccMajorVersion" "$__GccMinorVersion" "$__BuildArch" "$__CMakeArgs" "$__CMakeExtraArgs"
+    commonDir="$__rootRepo/eng/common"
+    __CMakeExtraArgs="$__CMakeExtraArgs -DCLR_COMMON_DIR=\"$commonDir\""
+    nextCommand="\"$commonDir/cross/gen-buildsys.sh\" \"$__nativeroot\" \"$__nativeroot\" \"$__IntermediatesDir\" $__BuildArch $__Compiler \"$__CompilerMajorVersion\" \"$__CompilerMinorVersion\"  $__BuildType $__CMakeArgs $__CMakeExtraArgs"
+    echo "Invoking $nextCommand"
+    eval "$nextCommand"
+
+    if [ $? != 0  ]; then
+        echo "Failed to generate $message build project!"
+        exit 1
     fi
 
     # Check that the makefiles were created.
 
-    if [ ! -f "$__IntermediatesDir/Makefile" ]; then
-        echo "Failed to generate native component build project!"
+    if [ ! -f "$__IntermediatesDir/CMakeCache.txt" ]; then
+        echo "Unable to find generated build files for native component project!"
         exit 1
     fi
 
@@ -186,14 +167,12 @@ __CMakeArgs=DEBUG
 __BuildOS=Linux
 __NumProc=1
 __UnprocessedBuildArgs=
-__GccBuild=0
-__GccMajorVersion=0
-__GccMinorVersion=0
 __CrossBuild=0
 __ServerGC=0
 __VerboseBuild=false
-__ClangMajorVersion=0
-__ClangMinorVersion=0
+__Compiler=clang
+__CompilerMajorVersion=
+__CompilerMinorVersion=
 __StaticLibLink=0
 __PortableBuild=0
 
@@ -297,7 +276,7 @@ while :; do
         stripsymbols|-stripsymbols)
             __CMakeExtraArgs="$__CMakeExtraArgs -DSTRIP_SYMBOLS=true"
             ;;
-        --numproc|-numproc|numproc)
+        numproc|-numproc|--numproc)
             shift
             __NumProc=$1
             ;;
@@ -307,66 +286,30 @@ while :; do
         staticliblink|-staticliblink)
             __StaticLibLink=1
             ;;
-        -portable|-portable)
+        portable|-portable)
             # Portable native components are only supported on Linux
             if [ "$__HostOS" == "Linux" ]; then
                 __PortableBuild=1
             fi
             ;;
-        --clang*)
+        clang*|-clang*|--clang*)
+                __Compiler=clang
                 # clangx.y or clang-x.y
-                v=`echo $lowerI | tr -d '[:alpha:]-='`
-                __ClangMajorVersion=`echo $v | cut -d '.' -f1`
-                __ClangMinorVersion=`echo $v | cut -d '.' -f2`
-            ;;
-        clang3.5|-clang3.5)
-            __ClangMajorVersion=3
-            __ClangMinorVersion=5
-            ;;
-        clang3.6|-clang3.6)
-            __ClangMajorVersion=3
-            __ClangMinorVersion=6
-            ;;
-        clang3.7|-clang3.7)
-            __ClangMajorVersion=3
-            __ClangMinorVersion=7
-            ;;
-        clang3.8|-clang3.8)
-            __ClangMajorVersion=3
-            __ClangMinorVersion=8
-            ;;
-        clang3.9|-clang3.9)
-            __ClangMajorVersion=3
-            __ClangMinorVersion=9
-            ;;
-        clang4.0|-clang4.0)
-            __ClangMajorVersion=4
-            __ClangMinorVersion=0
-            ;;
-        gcc5|-gcc5)
-            __GccMajorVersion=5
-            __GccMinorVersion=
-            __GccBuild=1
-            ;;
-        gcc6|-gcc6)
-            __GccMajorVersion=6
-            __GccMinorVersion=
-            __GccBuild=1
-            ;;
-        gcc7|-gcc7)
-            __GccMajorVersion=7
-            __GccMinorVersion=
-            __GccBuild=1
-            ;;
-        gcc8|-gcc8)
-            __GccMajorVersion=8
-            __GccMinorVersion=
-            __GccBuild=1
-            ;;
-        gcc|-gcc)
-            __GccMajorVersion=
-            __GccMinorVersion=
-            __GccBuild=1
+                version="$(echo "$lowerI" | tr -d '[:alpha:]-=')"
+                parts=(${version//./ })
+                __CompilerMajorVersion="${parts[0]}"
+                __CompilerMinorVersion="${parts[1]}"
+                if [ -z "$__CompilerMinorVersion" ] && [ "$__CompilerMajorVersion" -le 6 ]; then
+                    __CompilerMinorVersion=0;
+                fi
+            ;;
+        gcc*|-gcc*)
+                __Compiler=gcc
+                # gccx.y or gcc-x.y
+                version="$(echo "$lowerI" | tr -d '[:alpha:]-=')"
+                parts=(${version//./ })
+                __CompilerMajorVersion="${parts[0]}"
+                __CompilerMinorVersion="${parts[1]}"
             ;;
         cross|-cross)
             __CrossBuild=1
@@ -425,12 +368,6 @@ if [[ $__BuildOS == OSX ]]; then
     __CMakeExtraArgs="$__CMakeExtraArgs -DCMAKE_OSX_DEPLOYMENT_TARGET=10.13"
 fi
 
-# Set the default clang version if not already set
-if [[ $__ClangMajorVersion == 0 && $__ClangMinorVersion == 0 ]]; then
-    __ClangMajorVersion=9
-    __ClangMinorVersion=
-fi
-
 # Set the remaining variables based upon the determined build configuration
 __outConfig=${__outConfig:-"$__BuildOS-$__BuildArch-$__BuildType"}
 __IntermediatesDir="$__artifactsDir/obj/native/$__outConfig"