How to disable flag detection?

[davidchisnall]

I have a toolchain with a custom build of clang. When I use it, xmake keeps trying to use the system clang to detect whether any of the flags that I'm passing work and failing because they are only in ours (or, worse, because the host is Linux and does not have clang installed in $PATH). This impacts a bunch of built-in features, for example xmake decides not to pass -std=c++20 because it tries that flag with /usr/bin/clang++ and detects that it is unsupported and then removes it from invocations of my/custom/clang++.

How do I disable this flag detection globally? I expected set_policy("check.auto_ignore_flags", false) to work.

[waruqi]

set_policy("check.auto_ignore_flags", false)

it should work for add_cxxflags

add_cxxflags("-std=c++20")

[waruqi]

It works for explicit flags, but not for set_languages("c2x", "cxx20").

Yes, it only works for primitive flags such as add_cxflags to set the interface. set_languages will probably always need to detect them internally.

[davidchisnall]

I have rewritten a lot of my toolchain to make it more idiomatically correct xmake and I am suspecting a bug. My clang definitely does accept -std=c++20 and works correctly when it is passed, but xmake says:

checking for clang++ ... /mnt/vss/_work/1/LLVM/LLVM/bin/clang++
checking for the c++ compiler (cxx) ... clang++
checking for /mnt/vss/_work/1/LLVM/LLVM/bin/clang++ ... ok
checking for flags (-fPIC) ... no
checking for flags (-fvisibility-inlines-hidden) ... ok
checking for flags (-std=c++20) ... no
checking for flags (-std=c++2a) ... no

It then does not pass std=c++20. This happens when running in CI. When I run locally, I see this:

checking for clang++ ... /home/theraven/build/llvm-trunk-release/bin/clang++
checking for the c++ compiler (cxx) ... clang++
checking for /home/theraven/build/llvm-trunk-release/bin/clang++ ... ok
checking for flags (-fPIC) ... ok
checking for flags (-fvisibility-inlines-hidden) ... ok
checking for flags (-std=c++20) ... ok

The difference is that the CI machines (Ubuntu 20.04) do not have a system-wide clang installed and c++ on this system is gcc 9.4.0, which does not recognise this flag. My local machine (FreeBSD 14) does, and my local machine has a sufficiently recent clang that it supports this flag.

It looks as if the flag detection is not using the tool that the compilation step then uses.

[waruqi]

it works for me.

default toolchains

set_languages("c++20")
target("test")
    set_kind("binary")
    add_files("src/*.cpp")

ruki:test ruki$ xmake f -cvD; xmake -rvD
checking for xcrun -sdk macosx clang ... /usr/bin/xcrun -sdk macosx clang
checking for the c++ compiler (cxx) ... xcrun -sdk macosx clang
checking for /usr/bin/xcrun -sdk macosx clang ... ok
checking for flags (-fPIC) ... ok
> xcrun -sdk macosx clang "-fPIC"
checking for flags (-fvisibility-inlines-hidden) ... ok
> xcrun -sdk macosx clang "-fvisibility-inlines-hidden"
checking for flags (-O3) ... ok
> xcrun -sdk macosx clang "-O3"
checking for flags (-std=c++20) ... ok
> xcrun -sdk macosx clang "-std=c++20" <---------------------------- use xcrun -sdk macosx clang
[ 25%]: cache compiling.release src/main.cpp
"/usr/bin/xcrun -sdk macosx clang" -c -Qunused-arguments -target x86_64-apple-macos12.3 -isysroot /Applications/Xcode.app/Conten
ts/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX12.3.sdk -fvisibility=hidden -fvisibility-inlines-hidden -O3 -std=c+
+20 -DNDEBUG -o build/.objs/test/macosx/x86_64/release/src/main.cpp.o src/main.cpp
checking for flags (-MMD -MF) ... ok
> xcrun -sdk macosx clang "-MMD" "-MF" "/dev/null"
checking for flags (-fdiagnostics-color=always) ... ok
> xcrun -sdk macosx clang "-fdiagnostics-color=always"
checking for xcrun -sdk macosx clang++ ... /usr/bin/xcrun -sdk macosx clang++
checking for the linker (ld) ... xcrun -sdk macosx clang++
checking for /usr/bin/xcrun -sdk macosx clang++ ... ok
checking for flags (-fPIC) ... ok
> xcrun -sdk macosx clang++ "-fPIC"
[ 50%]: linking.release test
"/usr/bin/xcrun -sdk macosx clang++" -o build/macosx/x86_64/release/test build/.objs/test/macosx/x86_64/release/src/main.cpp.o -
target x86_64-apple-macos12.3 -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacO
SX12.3.sdk -stdlib=libc++ -Wl,-x -lz

use gcc toolchains

set_languages("c++20")
target("test")
    set_kind("binary")
    add_files("src/*.cpp")
    set_toolchains("gcc")

ruki:test ruki$ xmake f -cvD; xmake -rvD
checking for gcc ... /usr/bin/gcc
checking for the c++ compiler (cxx) ... gcc
checking for /usr/bin/gcc ... ok
checking for flags (-fPIC) ... ok
> gcc "-fPIC"
checking for flags (-fvisibility-inlines-hidden) ... ok
> gcc "-fvisibility-inlines-hidden"
checking for flags (-O3) ... ok
> gcc "-O3"
checking for flags (-std=c++20) ... ok
> gcc "-std=c++20".  <------------------------------------ use gcc
[ 25%]: cache compiling.release src/main.cpp
/usr/bin/gcc -c -Qunused-arguments -m64 -fvisibility=hidden -fvisibility-inlines-hidden -O3 -std=c++20 -DNDEBUG -o build/.objs/t
est/macosx/x86_64/release/src/main.cpp.o src/main.cpp
checking for flags (-MMD -MF) ... ok
> gcc "-MMD" "-MF" "/dev/null"
checking for flags (-fdiagnostics-color=always) ... ok
> gcc "-fdiagnostics-color=always"
checking for g++ ... /usr/bin/g++
checking for the linker (ld) ... g++
checking for /usr/bin/g++ ... ok
checking for flags (-fPIC) ... ok
> g++ "-fPIC"
[ 50%]: linking.release test
/usr/bin/g++ -o build/macosx/x86_64/release/test build/.objs/test/macosx/x86_64/release/src/main.cpp.o -m64 -Wl,-x

[davidchisnall]

None of your examples have a custom toolchain. I have defined a custom toolchain and set it with set_toolchains. The tools are correctly detected but the feature detection appears to be using a different clang to the one that I have provided with --bin=.

There is a lot of magic going on in xmake that I would like to simply disable.

[waruqi]

None of your examples have a custom toolchain. I have defined a custom toolchain and set it with set_toolchains.

It still works for custom toolchain on my machine.

checking for flags (-std=c++20) ... no
> arm-linux-musleabi-gcc "-std=c++20".  <-------- use custom toolchain
checkinfo: @programdir/core/sandbox/modules/os.lua:267: arm-linux-musleabi-gcc-raw: error: unreco
gnized command line option ‘-std=c++20’; did you mean ‘-std=c++2a’?

stack traceback:
    [C]: in function 'error'
    [@programdir/core/base/os.lua:897]:
    [@programdir/core/sandbox/modules/os.lua:267]: in function 'runv'
    [@programdir/modules/detect/tools/gcc/has_flags.lua:42]:
checking for flags (-std=c++2a) ... ok
> arm-linux-musleabi-gcc "-std=c++2a"

-- custom toolchain
toolchain("my_muslcc")
    set_homepage("https://musl.cc/")
    set_description("The musl-based cross-compilation toolchains")
    set_kind("cross")
    on_load(function (toolchain)
        toolchain:load_cross_toolchain()
        if toolchain:is_arch("arm") then
            toolchain:add("cxflags", "-march=armv7-a", "-msoft-float", {force = true})
            toolchain:add("ldflags", "-march=armv7-a", "-msoft-float", {force = true})
        end
        toolchain:add("syslinks", "gcc", "c")
    end)
toolchain_end()

-- add toolchains package
add_requires("muslcc")

-- set global toolchains for target and packages
set_toolchains("my_muslcc@muslcc")

target("test")
    set_kind("binary")
    add_files("src/*.cpp")
    set_languages("c++20")

There is a lot of magic going on in xmake that I would like to simply disable.

Probing is necessary, the value of set_languages is an abstract value which can be mapped to c++20, c++2a etc depending on the support of different compilers and versions.

Therefore we cannot hardcode a particular flag by disabling probing, unless you use add_cxflags("-std=c++20") instead of set_languages

xmake/xmake/modules/core/tools/gcc.lua

Line 208 in 919c16a

, cxx20 = {"-std=c++20", "-std=c++2a"}

xmake/xmake/modules/core/tools/gcc.lua

Line 216 in 919c16a

, cxxlatest = {"-std=c++23", "-std=c++2b", "-std=c++20", "-std=c++2a", "-std=c++17", "-std=c++14", "-std=c++11", "-std=c++1z", "-std=c++98"}

for example, arm-linux-musleabi-gcc toolchain

it will be -std=c++2a not -std=c++20, -std=c++20 is not supported.

If flags detection is disabled, then we need to hardcode different flags according to the various compilers and toolchains, and depending on the version