[WIP] Add flang (Fortran) compiler support

build-all.sh

@@ -236,6 +236,7 @@ fi
 ./build-mingw-w64.sh $PREFIX $MINGW_ARGS $CFGUARD_ARGS
 ./build-compiler-rt.sh $PREFIX $CFGUARD_ARGS
 ./build-libcxx.sh $PREFIX $CFGUARD_ARGS
+./build-flang-rt.sh $PREFIX $CFGUARD_ARGS
 ./build-mingw-w64-libraries.sh $PREFIX $CFGUARD_ARGS
 ./build-compiler-rt.sh $PREFIX --build-sanitizers # CFGUARD_ARGS intentionally omitted
 ./build-openmp.sh $PREFIX $CFGUARD_ARGS

build-flang-rt.sh

@@ -0,0 +1,135 @@
+#!/bin/sh
+#
+# Copyright (c) 2018 Martin Storsjo
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+set -e
+
+BUILD_STATIC=ON
+# Shared library not supported on Windows yet per flang-rt CMakeLists.txt
+BUILD_SHARED=OFF
+CFGUARD_CFLAGS="-mguard=cf"
+
+while [ $# -gt 0 ]; do
+    if [ "$1" = "--disable-static" ]; then
+        BUILD_STATIC=OFF
+    elif [ "$1" = "--enable-static" ]; then
+        BUILD_STATIC=ON
+    elif [ "$1" = "--enable-cfguard" ]; then
+        CFGUARD_CFLAGS="-mguard=cf"
+    elif [ "$1" = "--disable-cfguard" ]; then
+        CFGUARD_CFLAGS=
+    else
+        PREFIX="$1"
+    fi
+    shift
+done
+if [ -z "$PREFIX" ]; then
+    echo "$0 [--disable-static] [--enable-cfguard|--disable-cfguard] dest"
+    exit 1
+fi
+
+mkdir -p "$PREFIX"
+PREFIX="$(cd "$PREFIX" && pwd)"
+
+export PATH="$PREFIX/bin:$PATH"
+
+# i686 and armv7 are excluded due to compile-time asserts in flang-rt
+# arm64ec is excluded due to not building flang for it (unknown if it would work)
+: ${ARCHS:=${TOOLCHAIN_ARCHS-x86_64 aarch64}}
+
+CLANG_RESOURCE_DIR="$("$PREFIX/bin/clang" --print-resource-dir)"
+CLANG_VERSION=$(basename "$CLANG_RESOURCE_DIR")
+CLANG_MAJOR="${CLANG_VERSION%%.*}"
+
+if [ ! -d llvm-project/flang-rt ] || [ -n "$SYNC" ]; then
+    CHECKOUT_ONLY=1 ./build-llvm.sh
+fi
+
+# Find the Fortran compiler - prefer flang-new if available, otherwise use flang
+if [ -x "$PREFIX/bin/flang-new" ]; then
+    FLANG="$PREFIX/bin/flang-new"
+elif [ -x "$PREFIX/bin/flang" ]; then
+    FLANG="$PREFIX/bin/flang"
+else
+    echo "Error: No flang compiler found in $PREFIX/bin"
+    exit 1
+fi
+
+cd llvm-project
+
+cd runtimes
+
+if command -v ninja >/dev/null; then
+    CMAKE_GENERATOR="Ninja"
+else
+    : ${CORES:=$(nproc 2>/dev/null)}
+    : ${CORES:=$(sysctl -n hw.ncpu 2>/dev/null)}
+    : ${CORES:=4}
+
+    case $(uname) in
+    MINGW*)
+        CMAKE_GENERATOR="MSYS Makefiles"
+        ;;
+    esac
+fi
+
+for arch in $ARCHS; do
+    [ -z "$CLEAN" ] || rm -rf build-flang-rt-$arch
+    mkdir -p build-flang-rt-$arch
+    cd build-flang-rt-$arch
+    [ -n "$NO_RECONF" ] || rm -rf CMake*
+    cmake \
+        ${CMAKE_GENERATOR+-G} "$CMAKE_GENERATOR" \
+        -DCMAKE_BUILD_TYPE=Release \
+        -DCMAKE_INSTALL_PREFIX="$PREFIX" \
+        -DCMAKE_C_COMPILER=$arch-w64-mingw32-clang \
+        -DCMAKE_CXX_COMPILER=$arch-w64-mingw32-clang++ \
+        -DCMAKE_Fortran_COMPILER="$FLANG" \
+        -DCMAKE_C_COMPILER_TARGET=$arch-w64-windows-gnu \
+        -DCMAKE_CXX_COMPILER_TARGET=$arch-w64-windows-gnu \
+        -DCMAKE_Fortran_COMPILER_TARGET=$arch-w64-windows-gnu \
+        -DCMAKE_SYSTEM_NAME=Windows \
+        -DCMAKE_C_COMPILER_WORKS=TRUE \
+        -DCMAKE_CXX_COMPILER_WORKS=TRUE \
+        -DCMAKE_Fortran_COMPILER_WORKS=TRUE \
+        -DCMAKE_Fortran_COMPILER_ID=LLVMFlang \
+        -DCMAKE_Fortran_COMPILER_ID_RUN=TRUE \
+        -DCMAKE_Fortran_SIMULATE_ID=GNU \
+        -DCMAKE_Fortran_COMPILER_SUPPORTS_F90=TRUE \
+        -DCMAKE_AR="$PREFIX/bin/llvm-ar" \
+        -DCMAKE_RANLIB="$PREFIX/bin/llvm-ranlib" \
+        -DLLVM_ENABLE_RUNTIMES="flang-rt" \
+        -DLLVM_DEFAULT_TARGET_TRIPLE=$arch-w64-windows-gnu \
+        -DLLVM_VERSION_MAJOR="$CLANG_MAJOR" \
+        -DFLANG_RT_ENABLE_STATIC=$BUILD_STATIC \
+        -DFLANG_RT_ENABLE_SHARED=$BUILD_SHARED \
+        -DFLANG_RT_INCLUDE_TESTS=OFF \
+        -DCMAKE_C_FLAGS_INIT="$CFGUARD_CFLAGS" \
+        -DCMAKE_CXX_FLAGS_INIT="$CFGUARD_CFLAGS" \
+        -DCMAKE_Fortran_FLAGS_INIT="--target=$arch-w64-windows-gnu --no-default-config" \
+        ..
+
+    cmake --build . ${CORES:+-j${CORES}}
+    cmake --install .
+
+    # Create symlink for the runtime library without the .static suffix
+    # Flang looks for libflang_rt.runtime.a but we build libflang_rt.runtime.static.a
+    FLANG_RT_DIR="$CLANG_RESOURCE_DIR/lib/$arch-w64-windows-gnu"
+    if [ -f "$FLANG_RT_DIR/libflang_rt.runtime.static.a" ] && [ ! -e "$FLANG_RT_DIR/libflang_rt.runtime.a" ]; then
+        ln -sf libflang_rt.runtime.static.a "$FLANG_RT_DIR/libflang_rt.runtime.a"
+    fi
+
+    cd ..
+done

build-llvm.sh

@@ -365,7 +365,7 @@ fi
 
 cd llvm-project/llvm
 
-PROJECTS="clang;lld"
+PROJECTS="clang;lld;flang"
 if [ -n "$LLDB" ]; then
     PROJECTS="$PROJECTS;lldb"
 fi

install-wrappers.sh

@@ -90,6 +90,13 @@ if [ -n "${HOST_CLANG}" ]; then
     ln -sf clang $PREFIX/bin/clang++
     ln -sf clang $PREFIX/bin/clang-cpp
 
+    HOST_FLANG_EXE=$(PATH=$llvmexec command -v flang-new || true)
+    if [ -n "$HOST_FLANG_EXE" ]; then
+        printf '#!/bin/sh\nsr=$(dirname "$(dirname "$(readlink -f "$0")")")\nexec %s -resource-dir="$sr"%s --sysroot="$sr" --config-system-dir="$sr"/bin "$@"\n' "$HOST_FLANG_EXE" "$clangres" > $PREFIX/bin/flang
+        chmod 755 $PREFIX/bin/flang
+        echo "Using existing flang $HOST_FLANG_EXE"
+    fi
+
     echo "Using existing clang $HOST_CLANG_EXE ($HOST_CLANG_VER)"
     $PREFIX/bin/clang -v
 
@@ -152,7 +159,7 @@ fi
 cd "$PREFIX/bin"
 for arch in $ARCHS; do
     for target_os in $TARGET_OSES; do
-        for exec in clang clang++ gcc g++ c++ as; do
+        for exec in clang clang++ gcc g++ c++ as flang gfortran; do
             ln -sf clang-target-wrapper$CTW_SUFFIX $arch-w64-$target_os-$exec$CTW_LINK_SUFFIX
         done
         ln -sf $CSDW $arch-w64-$target_os-clang-scan-deps$CTW_LINK_SUFFIX
@@ -195,7 +202,7 @@ if [ -n "$EXEEXT" ]; then
     # we are installing wrappers for.
     case $ARCHS in
     *$HOST_ARCH*)
-        for exec in clang clang++ gcc g++ c++ addr2line ar dlltool ranlib nm objcopy readelf size strings strip windres clang-scan-deps; do
+        for exec in clang clang++ gcc g++ c++ addr2line ar dlltool ranlib nm objcopy readelf size strings strip windres clang-scan-deps flang gfortran; do
             ln -sf $HOST-$exec$EXEEXT $exec$EXEEXT
         done
         for exec in cc c99 c11; do

strip-llvm.sh

@@ -149,7 +149,7 @@ rm -f *.dll.a
 rm -f lib*.a
 for i in *.so* *.dylib* cmake; do
     case $i in
-    liblldb*|libclang-cpp*|libLLVM*)
+    liblldb*|libclang-cpp*|libLLVM*|libMLIR*|libFortran*|libflang*)
         ;;
     *)
         rm -rf $i

wrappers/clang-target-wrapper.c

@@ -53,18 +53,42 @@ int _tmain(int argc, TCHAR* argv[]) {
     int max_arg = argc + 18;
     const TCHAR **exec_argv = malloc((max_arg + 1) * sizeof(*exec_argv));
     int arg = 0;
+    int is_flang = 0;
     if (getenv("CCACHE"))
         exec_argv[arg++] = _T("ccache");
-    exec_argv[arg++] = concat(dir, _T(CLANG));
-    exec_argv[arg++] = _T("--start-no-unused-arguments");
 
     // If changing this wrapper, change clang-target-wrapper.sh accordingly.
-    if (!_tcscmp(exe, _T("clang++")) || !_tcscmp(exe, _T("g++")) || !_tcscmp(exe, _T("c++")))
+    if (!_tcscmp(exe, _T("clang++")) || !_tcscmp(exe, _T("g++")) || !_tcscmp(exe, _T("c++"))) {
+        exec_argv[arg++] = concat(dir, _T(CLANG));
+        exec_argv[arg++] = _T("--start-no-unused-arguments");
         exec_argv[arg++] = _T("--driver-mode=g++");
-    else if (!_tcscmp(exe, _T("c99")))
+    } else if (!_tcscmp(exe, _T("flang")) || !_tcscmp(exe, _T("gfortran"))) {
+        // Use flang directly instead of clang --driver-mode=flang
+        // If called with -fc1, pass through directly without adding flags (frontend invocation)
+        if (argc > 1 && !_tcscmp(argv[1], _T("-fc1"))) {
+            exec_argv[arg++] = concat(dir, _T("flang"));
+            for (int i = 1; i < argc; i++)
+                exec_argv[arg++] = argv[i];
+            exec_argv[arg] = NULL;
+            return run_final(exec_argv[0], exec_argv);
+        }
+        // Use --no-default-config to avoid reading clang config files with C++-specific flags
+        exec_argv[arg++] = concat(dir, _T("flang"));
+        exec_argv[arg++] = _T("--no-default-config");
+        exec_argv[arg++] = _T("-rtlib=compiler-rt");
+        is_flang = 1;
+    } else if (!_tcscmp(exe, _T("c99"))) {
+        exec_argv[arg++] = concat(dir, _T(CLANG));
+        exec_argv[arg++] = _T("--start-no-unused-arguments");
         exec_argv[arg++] = _T("-std=c99");
-    else if (!_tcscmp(exe, _T("c11")))
+    } else if (!_tcscmp(exe, _T("c11"))) {
+        exec_argv[arg++] = concat(dir, _T(CLANG));
+        exec_argv[arg++] = _T("--start-no-unused-arguments");
         exec_argv[arg++] = _T("-std=c11");
+    } else {
+        exec_argv[arg++] = concat(dir, _T(CLANG));
+        exec_argv[arg++] = _T("--start-no-unused-arguments");
+    }
 
     if (target_os && !_tcscmp(target_os, _T("mingw32uwp"))) {
         // the UWP target is for Windows 10
@@ -80,7 +104,8 @@ int _tmain(int argc, TCHAR* argv[]) {
 
     exec_argv[arg++] = _T("-target");
     exec_argv[arg++] = target;
-    exec_argv[arg++] = _T("--end-no-unused-arguments");
+    if (!is_flang)
+        exec_argv[arg++] = _T("--end-no-unused-arguments");
 
     for (int i = 1; i < argc; i++)
         exec_argv[arg++] = argv[i];

wrappers/clang-target-wrapper.sh

@@ -53,20 +53,37 @@ if [ -n "$CCACHE" ]; then
 fi
 
 # If changing this wrapper, change clang-target-wrapper.c accordingly.
-CLANG="$DIR/clang"
+DRIVER="$DIR/clang"
 FLAGS=""
-FLAGS="$FLAGS --start-no-unused-arguments"
+IS_FLANG=0
 case $EXE in
 clang++|g++|c++)
     FLAGS="$FLAGS --driver-mode=g++"
     ;;
+flang|gfortran)
+    # Use flang directly instead of clang --driver-mode=flang
+    # Use --no-default-config to avoid reading clang config files with C++-specific flags
+    DRIVER="$DIR/flang"
+    # If called with -fc1, pass through directly without adding flags (frontend invocation)
+    case "$1" in
+    -fc1)
+        exec "$DRIVER" "$@"
+        ;;
+    esac
+    FLAGS="$FLAGS --no-default-config"
+    FLAGS="$FLAGS -rtlib=compiler-rt"
+    IS_FLANG=1
+    ;;
 c99)
     FLAGS="$FLAGS -std=c99"
     ;;
 c11)
     FLAGS="$FLAGS -std=c11"
     ;;
 esac
+if [ "$IS_FLANG" -eq 0 ]; then
+    FLAGS="--start-no-unused-arguments $FLAGS"
+fi
 LINKER_FLAGS=""
 case $TARGET_OS in
 mingw32uwp)
@@ -93,6 +110,8 @@ mingw32uwp)
 esac
 
 FLAGS="$FLAGS -target $TARGET"
-FLAGS="$FLAGS --end-no-unused-arguments"
+if [ "$IS_FLANG" -eq 0 ]; then
+    FLAGS="$FLAGS --end-no-unused-arguments"
+fi
 
-$CCACHE "$CLANG" $FLAGS "$@" $LINKER_FLAGS
+$CCACHE "$DRIVER" $FLAGS "$@" $LINKER_FLAGS