git: f28517db4ed0 - stable/12 - clang: Support building with GCC and DEBUG_FILES disabled

The branch stable/12 has been updated by dim:

URL: https://cgit.FreeBSD.org/src/commit/?id=f28517db4ed04e186a8ef12ddb5f68b73ce1e51d

commit f28517db4ed04e186a8ef12ddb5f68b73ce1e51d
Author:     Jessica Clarke <jrtc27@FreeBSD.org>
AuthorDate: 2021-08-24 13:59:18 +0000
Commit:     Dimitry Andric <dim@FreeBSD.org>
CommitDate: 2021-12-25 11:51:19 +0000

    clang: Support building with GCC and DEBUG_FILES disabled
    
    If MK_DEBUG_FILES=no then the Clang link rule has clang as .TARGET,
    rather than clang.full, causing the implicit ${CFLAGS.${.TARGET:T}} to
    be CFLAGS.clang, and thus pull in flags intended for when your compiler
    is Clang, not when linking Clang itself. This doesn't matter if your
    compiler is in fact Clang, but it breaks using GCC as, for example,
    bsd.sys.mk adds -Qunused-arguments to CFLAGS.clang. This is seen when
    trying to build a bootstrap toolchain on Linux where GCC is the system
    compiler.
    
    Thus, introduce a new internal NO_TARGET_FLAGS variable that is set by
    Clang to disable the addition of these implicit flags. This is a bigger
    hammer than necessary, as flags for .o files would be safe, but that is
    not needed for Clang.
    
    Note that the same problem does not arise for LDFLAGS when building LLD
    with BFD, since our build produces a program called ld.lld, not plain
    lld (unlike upstream, where ld.lld is a symlink to lld so they can
    support multiple different flavours in one binary).
    
    Suggested by:   sjg
    Fixes:          31ba4ce8898f ("Allow bootstrapping llvm-tblgen on macOS and Linux")
    MFC after:      1 week
    Reviewed by:    dim, imp, emaste
    Differential Revision:  https://reviews.freebsd.org/D31532
    
    (cherry picked from commit c8edd0542647f59ab07dd73e865edd34706397a5)
---
 share/mk/bsd.sys.mk          | 9 ++++++++-
 usr.bin/clang/clang/Makefile | 3 +++
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/share/mk/bsd.sys.mk b/share/mk/bsd.sys.mk
index 375df956b4fd..f228984719c7 100644
--- a/share/mk/bsd.sys.mk
+++ b/share/mk/bsd.sys.mk
@@ -272,7 +272,14 @@ LDFLAGS+=	${LDFLAGS.${LINKER_TYPE}}
 # Only allow .TARGET when not using PROGS as it has the same syntax
 # per PROG which is ambiguous with this syntax. This is only needed
 # for PROG_VARS vars.
-.if !defined(_RECURSING_PROGS)
+#
+# Some directories (currently just clang) also need to disable this since
+# CFLAGS.${COMPILER_TYPE}, CFLAGS.${.IMPSRC:T} and CFLAGS.${.TARGET:T} all live
+# in the same namespace, meaning that, for example, GCC builds of clang pick up
+# CFLAGS.clang via CFLAGS.${.TARGET:T} and thus try to pass Clang-specific
+# flags. Ideally the different sources of CFLAGS would be namespaced to avoid
+# collisions.
+.if !defined(_RECURSING_PROGS) && !defined(NO_TARGET_FLAGS)
 .if ${MK_WARNS} != "no"
 CFLAGS+=	${CWARNFLAGS.${.TARGET:T}}
 .endif
diff --git a/usr.bin/clang/clang/Makefile b/usr.bin/clang/clang/Makefile
index ec42fe78cf90..31f092608583 100644
--- a/usr.bin/clang/clang/Makefile
+++ b/usr.bin/clang/clang/Makefile
@@ -34,4 +34,7 @@ MLINKS+= clang.1 cc.1 \
 
 LIBADD+=	z
 
+# Ensure we don't add CFLAGS.clang when using GCC
+NO_TARGET_FLAGS=
+
 .include "../clang.prog.mk"