Nhat Minh Le

This commit **refactors** the **C++ compilation system** to replace the boolean `use_header_units` flag with a more expressive `UseHeaderUnitsMode` enum, offering `none`, `pcm`, and `stub` options. This **new capability** enables the integration of header unit stub usage by wiring a dedicated argsfile into the C++ compile command line. The change affects core compilation functions in `prelude/cxx/compile.bzl` and updates user-facing C++ rules like `cxx_library_generate` to leverage this new enum. This enhancement provides finer control over header unit processing, paving the way for more efficient C++ module compilation by pulling in precompiled module stubs.

This commit introduces a **new capability** to the **C++ compilation system** by adding a `header_unit_stubs_argsfile` field to the `CxxCompileCommand` record in `prelude/cxx/compile_types.bzl`. The `prelude/cxx/compile.bzl` module is updated to generate and populate this new field, specifically within functions like `_generate_base_compile_command` and `precompile_cxx`. This enhancement allows the **C++ build system** to correctly pass arguments for **header unit stubs**, improving the handling and compilation of C++ header units. The change primarily affects the internal mechanics of C++ compilation command generation.

This commit introduces a **new feature** to the **C++ build system** by adding a `stub` option for `use_header_units`, enabling the generation of lightweight stub header units. This involves modifying the **C++ precompilation logic** in `prelude/cxx/compile.bzl` and updating core **C++ rule implementations** like `cxx_library_generate` and `cxx_binary_impl` to support this new mode. A new Python script, `prelude/cxx/tools/stub_header_unit.py`, is added to preprocess C++ headers, hash their output, and create these stub files. This **pre-migration assessment tool** allows developers to simulate module-like workflows and realistic cache behavior without full module compilation. The primary goal is to estimate the migration cost, risk, and performance impact of adopting C++ modules, providing a crucial step for identifying good initial candidates.

This commit introduces a new `stub` artifact and field for **C++ header units**, enhancing their processing within the build system. It modifies `prelude/cxx/preprocessor.bzl` to add the `stub` field to the `HeaderUnit` record and new functions to generate preprocessor arguments for these stubs. Concurrently, `prelude/cxx/compile.bzl` is updated to integrate this `stub` artifact into the compilation logic. This **new capability** ensures that stub-related command-line arguments are correctly generated and passed during C++ compilation, improving support for C++ modules.

This commit **enables content-based path hashing** for C++ compilation commands across the build system. It modifies the `create_compile_cmds` function within `prelude/cxx/compile.bzl` to leverage the `cxx_compile_cmd.allow_content_based_paths` flag. This **feature enablement** aims to improve build caching and reproducibility by deriving paths from file content for most **C++ compile rules**. A key scope limitation is that this change **explicitly excludes Apple rules** to preserve compatibility with Xcode.

This commit **corrects the logic** within the **debug information processing** pipeline by **removing an unnecessary check** for the `separate_debug_info` attribute during `dwo rewrite` operations. Previously, the system would incorrectly block `dwo rewrite` if this attribute was not explicitly set on the binary, even when content-based paths from inputs indicated that a rewrite was necessary. This **bug fix** ensures that `dwo rewrite` can proceed as intended, improving the robustness and reliability of **debug information handling** for binaries that require it, regardless of the explicit presence of the `separate_debug_info` flag. The change prevents erroneous rejections and allows for more consistent processing of debug object files.

This commit **optimizes the linking process** by **removing the spurious requirement for DWO files themselves as direct inputs** during "dwo rewriting". It clarifies that only the *paths* to these DWARF object files are necessary, not their full contents, streamlining the **debug information handling** within the linker. This **maintenance improvement** enhances the efficiency and precision of the build system's interaction with debug data, potentially reducing unnecessary file I/O and processing overhead. The change refines how the linker manages debug information, ensuring only truly required data is considered.

This commit introduces an **inert `use_content_based_paths` attribute** across the **C++ compilation rules** (`cxx_binary`, `cxx_library`, `cxx_test`). This **preparatory feature addition** modifies `prelude/decls/cxx_common.bzl` to define the attribute and integrates it into rule definitions in `prelude/decls/cxx_rules.bzl`. The attribute's value is threaded into `_generate_base_compile_command` in `prelude/cxx/compile.bzl` to determine `allow_content_based_paths`. While not yet active, this change lays the groundwork for enabling **content-based paths in C++ compilation** in a subsequent diff, impacting how C++ sources are referenced.

This commit **implements DWO path rewriting** for the **Rust build system**, specifically within the `rust_compile` function in `prelude/rust/build.bzl`. This **new feature** ensures that Debug WithOut (DWO) file paths are correctly resolved and rewritten during **Rust linking** when **split debug is enabled** and content-based paths are supported. Additionally, it includes a **refactoring** of debug information inheritance in `prelude/rust/link_info.bzl` to better manage dependency debug infos. This change improves the robustness of **Rust debugging workflows** by correctly handling DWO file locations, ensuring proper debug information resolution for compiled Rust binaries.

This commit **enables DWO path rewriting** for fbcode, resolving a "file name too long" issue encountered in a previous attempt. It modifies the `cxx_link_into` function within `prelude/cxx/link.bzl` to conditionally rewrite DWO paths, specifically for **split debug modes**. The change ensures that the generated argsfile now has a path of the exact required length and composition, preventing build failures. This **feature enhancement** is crucial for correct **C++ linking** and **debug information generation** within the fbcode build environment.

This commit **enables DWO path rewriting** within the **C++ linking process** by modifying `prelude/cxx/link.bzl`. It updates the `cxx_link_into` function to conditionally pass arguments to the linker command, activating a previously implemented rewriting feature for **fbcode split debug** information. This **new capability** ensures that debug info files can have their paths rewritten, improving the management of debug symbols in complex build environments. The change also exercises the no-op rewrite code path, verifying the mechanism's robustness even when no actual rewriting is needed.

This commit **reverts a series of previous reverts**, thereby **re-enabling the original behavior** for **`split_dwarf` debugging information generation**. It restores the process to **always create `.dwp` files from `.so` or executable binaries**, rather than directly from `.dwo` files, as initially proposed in `D68817857`. This **maintenance** action is taken to prepare for a new, more compatible solution (`D81839350`) that is designed to be entirely backward compatible. The change impacts the **build system's handling of debug symbols** and aims to ensure consistent `.dwp` file creation, ultimately yielding identical `.dwp` outputs.

This commit **enhances C++ module support** by correctly propagating the `use_header_units` parameter to compilation steps. It modifies the `cxx_compile_srcs` function within `prelude/cxx/cxx_library.bzl` to pass this flag to all underlying `cxx_compile` calls. This **feature enhancement** addresses an oversight during the initial implementation of C++ modules, ensuring that header units are properly utilized. The change applies to both `pic_optimized` and `pic_debuggable` configurations, which should lead to improved build performance and correctness for projects leveraging C++ modules.

This commit introduces a **new capability** by adding a `supports_content_based_paths` field to the **Cxx toolchain definition**, specifically extending the `AsCompilerInfo` provider. This boolean flag, named `allow_content_based_paths`, is now included in the `CxxCompileCommand` record and is propagated during **C++ precompilation and base compilation command generation** within `prelude/cxx/compile.bzl`. While the field is successfully passed down to the compilation commands, the underlying code does not yet read or act upon it. Consequently, **content-based paths remain functionally disabled**, though the infrastructure for their future enablement is now in place.

This commit **prepares the C++ compilation system** for the future adoption of **content-based paths** for build artifacts. It introduces a new field, `uses_experimental_content_based_path_hashing`, to the `CxxSrcCompileCommand` record type in `prelude/cxx/compile_types.bzl`. Concurrently, the `_compile_single_cxx` function in `prelude/cxx/compile.bzl` is updated to pass and utilize this flag within the compilation logic. This work is a **foundational infrastructure change** that exposes the necessary attributes, but does not yet enable content-based paths for any artifacts, setting the stage for future improvements in build reproducibility or caching.

This commit **extends the DWP (Debug With Pointers) generation process** to properly support **Rust libraries and binaries** built with single-file DWO information. It **refactors the `rust_compile` rule** within `prelude/rust/build.bzl` to correctly manage DWP inputs using `cmd_args`. This **enhancement** ensures that debug information is accurately handled for Rust code, building upon existing DWP infrastructure. The change significantly **improves debugging capabilities** for Rust projects by providing more comprehensive debug data.

This commit introduces a **new capability** to the **DWP action** within the `prelude/cxx/dwp.bzl` module. It explicitly enables the use of an argsfile for the DWP command by setting `allow_args = True` during its generation. This **feature enhancement** is crucial for supporting more complex DWP invocations, as required by specific build rules (e.g., D80819887 and D80796092). The change improves the flexibility and scalability of the DWP build process by allowing command-line arguments to be passed via a file.

This commit **refactors** the **C++ DWP tool invocation** by modifying the `run_dwp_action` function within `prelude/cxx/dwp.bzl`. It now leverages an argsfile to pass referenced objects to the `dwp` tool, rather than directly on the command line. This **maintenance improvement** specifically addresses and resolves issues related to excessively long argument lists. Consequently, it **enhances the robustness and scalability** of builds that process a large number of Debug With Objects (DWOs).

This commit implements a **build system optimization** by configuring **`rust_cxx_bridge`** to use **content-based genrules**. This change is specifically designed to **deduplicate C++ compilations** that are generated by the bridge, improving overall build efficiency. Consequently, the paths for these generated C++ files have been altered, necessitating updates to the regular expression patterns within the **`tests/e2e/test/coverage`** suite to maintain accurate coverage reporting. The core impact is a more efficient build process for projects utilizing `rust_cxx_bridge` by avoiding redundant C++ compilations.

This commit implements a **temporary workaround** within the **C++ compilation prelude** to **exclude Xcode argument files from content-based path hashing**. The `gen_argsfiles` function in `prelude/cxx/compile.bzl` is now conditionally modified to bypass this hashing specifically for Xcode argsfiles. This **critical bug fix** addresses widespread test failures that were occurring due to the previous behavior, ensuring **Xcode-related builds remain functional**. It serves as a **maintenance step** to stabilize the build system while a proper migration strategy for Xcode argsfiles is determined.