glandium
commented
7 months ago TL;DR: Add -arch x86_64 to your CFLAGS instead of running the entire build as x86_64. There are too many things that can go wrong with the way you're doing it (plus, it's slower to build the way you do).
Full version: sccache can only really work with what it can know. What it can know is:
- what the compiler binary is
- what the command line arguments are
In both your builds, all these are identical, so of course it's going to use what's in cache (more on that later).
But I suspect that's also not the full story.
arch -x86_64 foowill run foo a x86_64 binary... if it is one. But as you're saying, sccache is arm64-only, so in practice whatsccache clang <flags>is doing is running as arm64. But what happens next also depends on what happened before: - if it's the first time you run sccache, it will spawn a server.
- if it's not, it will talk to an existing server.
In both cases, it's the server that will actually execute clang.
What happens next depends on which case it is, and on what
arch -x86_64does, which I'm not too sure:. - If
arch -x86_64still applies to subprocesses when the intermediate process is arm64 (which your final note seems to indicate would be the case), then:- If the server was already running, the way clang is executed will depend on whether sccache was run with
arch -x86_64when the server was spawned. So if you start withsccache clangand then doarch -x86_64 sccache clang, the second time it's still going to be running as arm64. - If the server was not running, clang will be executed as x86_64.
- If the server was already running, the way clang is executed will depend on whether sccache was run with
- If
arch -x86_64doesn't propagate to subprocesses, then clang will always run as arm64. We're probably in the first situation, so the first thing is that what you get with yourarch -x86_64 makecommand depends on whether sccache is already running or not. The first thing you can try is to runsccache --stop-serverin between builds. Another thing you can try to validate which case you're actually in, is to set SCCACHE_RECACHE to 1 in your environment, which would disable caching entirely and rebuild files every time, validating whether the build would produce x86_64 objects ever. But then, that's still not the full story. One of the sources of the cache key is the preprocessed source. In many cases, the preprocessed source will likely be identical whether you're building for x86_64 or for arm64. If you add something like:#ifdef __x86_64__ const int foo = 1; #else const int foo = 2; #endifto your source files, I'd expect things to somehow work, if we're indeed in the case where clang may actually run either as x86_64 or as arm64, but you'd still be dependent on whether sccache itself was started first from
arch -x86_64or not. However, the more usual way to build something for x86_64 mac on an arm64 mac is not to run the entire build as x86_64, but to pass arguments to the compiler. Either--target=x86_64-apple-darwinor-arch x86_64. And in this case, that would mean different command line arguments, and different cache keys. It would also be faster, because your compiler itself wouldn't be emulated.
blaztinn
clangandmakeon macOS are fat binaries with both having arm64 and x86_64 parts. You can select which architecture you want to run witharchcommand and here is wheresccachefails to detect the right target architecture when caching compiled artifacts. It always returns the artifacts for the architecture you compiled with first (probably because of not hashing the (right) target architecture?).A quick way to reproduce this on arm64 Apple HW:
main.c(int main(){})make build:arch -x86_64 make build:As you can see the
sccachecached the arm64 binary on the first compilation and returned it when running the x86_64 compiler targeting the x86_64 binary. On the other hand if we first compiled - with an empty cache - for x86_64 we would always get an x86_64 binary.This example needs the
makecommand becausesccacheI downloaded is an arm64-only binary and directly callingarch -x86_64 sccachefails.Note: Having
sccache -- clang --versioninside the makefile and running the makefile witharch -x86_64 makereports that clang is an x86_64 binary, so the arm64-only sccache binary forwards commands to the right compiler arch.