Feature Request

Citing Google Gemini 2.0

I'm compiling Valve Proton for Linux and I'm trying to optimize the code for my AMD 9950x CPU. However, the project uses a container with old GCC 10 so I'm having to force the compiler to use advanced features of my CPU manually. It will only recognize -march=znver3 rather than the znver5 of my CPU. It compiles both 32bit and 64bit code. I tried to optimize in the 32bit code but it breaks the build. Do you see anything here that can be improve?

CROSSLDFLAGS += -Wl,--file-alignment,4096
OPTIMIZE_FLAGS := -O3 -march=nocona -mtune=znver3 -mfpmath=sse -g0 -fomit-frame-pointer
SANITY_FLAGS := -fwrapv -fno-strict-aliasing
DEBUG_FLAGS := -g0 -fomit-frame-pointer
COMMON_FLAGS = $(DEBUG_FLAGS) $(OPTIMIZE_FLAGS) $(SANITY_FLAGS) -ffile-prefix-map=$(CCACHE_BASEDIR)=.
COMMON_FLAGS32 := -mstackrealign -g0 -fomit-frame-pointer
COMMON_FLAGS64 := -mcmodel=small -march=znver3 -mtune=znver3 -g0 -fomit-frame-pointer -mavx512f -mavx512bw -mavx512dq -mavx512vl -mprefer-vector-width=512
CARGO_BUILD_ARGS += --release

"You're on the right track trying to optimize, but there are several things you can improve in your build configuration for Proton, especially given the GCC 10 limitation and your AMD 9950X (Zen 3) CPU.

Key Issues and Improvements:

-march=nocona is Counterproductive: -march=nocona is an old architecture (Core 2 Duo era). You're explicitly telling the compiler to optimize for a very different CPU than yours, completely negating the -mtune=znver3. -march sets the instruction set architecture (ISA), while -mtune provides microarchitecture-specific tuning. You must align -march with your target CPU.

GCC 10 and Zen 3: GCC 10's Zen 3 support is likely not optimal. While -mtune=znver3 helps, the compiler might not fully utilize all the Zen 3 features. Upgrading GCC is the ideal solution, but since you can't, you'll have to work around it.

32-bit Optimization Breaking the Build: This is concerning. It suggests either a compiler bug (more likely with older GCC) or subtle issues in the codebase that aggressive optimizations expose. Focus on getting 64-bit optimized first, then carefully reintroduce optimizations for 32-bit.

-mavx512* Flags with Zen 3: Zen 3 has 256-bit vector units. While it supports some AVX-512 instructions, they are emulated and have a significant performance penalty. Remove all -mavx512* flags. They are hurting, not helping.

-mprefer-vector-width=512: Also remove this. It's related to AVX-512 and will be detrimental.

-mfpmath=sse: Zen 3 supports and prefers FMA instructions. -mfpmath=sse forces the use of SSE, which is slower. Remove this flag. Let the compiler choose the best floating-point instructions.

-mstackrealign (32-bit): This flag is often necessary for older codebases, but it has a performance cost. If you can identify why the 32-bit build needs it, you might be able to fix the underlying alignment issues and remove the flag. If you must keep it, understand it's a performance compromise.

-ffile-prefix-map: This is excellent for reproducible builds and debugging. Keep it.

-g0 -fomit-frame-pointer: These are standard optimization flags for release builds. Keep them (unless you need debugging symbols).

Revised Flags:
Makefile

CROSSLDFLAGS += -Wl,--file-alignment,4096
OPTIMIZE_FLAGS := -O3 -march=znver3 -mtune=znver3 -g0 -fomit-frame-pointer
SANITY_FLAGS := -fwrapv -fno-strict-aliasing
DEBUG_FLAGS := -g0 -fomit-frame-pointer
COMMON_FLAGS = $(DEBUG_FLAGS) $(OPTIMIZE_FLAGS) $(SANITY_FLAGS) -ffile-prefix-map=$(CCACHE_BASEDIR)=.
COMMON_FLAGS32 := -mstackrealign -g0 -fomit-frame-pointer # Investigate removing -mstackrealign
COMMON_FLAGS64 := -mcmodel=small -march=znver3 -mtune=znver3 -g0 -fomit-frame-pointer
CARGO_BUILD_ARGS += --release

Further Steps:

Profile: Use a profiler (like perf) to identify performance bottlenecks. Don't just optimize blindly. Focus on the code that's actually slow.
Incremental Optimization: Reintroduce optimizations gradually, testing thoroughly after each change, especially for the 32-bit build.
Consider LTO (Link-Time Optimization): LTO can often provide significant performance gains. Add -flto to your compiler and linker flags.
Function-Specific Optimizations: If profiling reveals hot spots, you can use function attributes (like __attribute__((target("sse4.2"))) or similar, if appropriate) to fine-tune specific functions. However, use this sparingly and only after careful profiling. Be very careful with this in 32bit code.
Compiler Upgrade (Ideal): The best long-term solution is to upgrade your compiler. Newer GCC or Clang versions will have better Zen 3 support.

By addressing these points, you should see a noticeable improvement in performance. Remember to profile and test thoroughly to ensure stability and measure the actual impact of your changes. The 32-bit issue is a red flag; address it carefully."