Link torch_cpu_library, not torch, so the CUDA wheel imports with a CPU-only torch (#24060)

### Problem

The Linux CUDA wheel cannot be used with a CPU-only PyTorch. Four of its
libraries record a load-time dependency (`DT_NEEDED`) on
`libtorch_cuda.so`, one also on `libc10_cuda.so`:

- `extension/training/pybindings/_training_lib`
- `extension/llm/runner/_llm_runner`
- `extension/llm/custom_ops/libcustom_ops_aot_lib.so`
- `kernels/quantized/libquantized_ops_aot_lib.so`

None of them uses those libraries, yet with a CPU-only torch they fail
to load:

```
ImportError: libtorch_cuda.so: cannot open shared object file: No such file or directory
```

It comes from linking the `torch` CMake target (or
`${TORCH_LIBRARIES}`). In a CUDA build of PyTorch that target adds
`libtorch_cuda.so` wrapped in `-Wl,--no-as-needed`, so it is recorded
even when unused, and `--as-needed` on our side cannot drop it.

### Fix

Link `torch_cpu_library` instead of `torch` where these libraries are
built. `torch` is `torch_cpu_library` plus `torch_cuda_library`, so the
CPU half is linked exactly as before, including the `--as-needed`
handling that keeps unused libraries such as MKL out of `DT_NEEDED`.
With a CPU-only PyTorch the link is unchanged.

The CUDA wheel smoke test gets a new check that fails if any shipped
library depends on `libtorch_cuda.so` or `libc10_cuda.so`.

### Testing

Built the CUDA 13.0 wheel on Linux x86_64 before and after the change.

`readelf -d` on `_llm_runner`, before:

```
libexecutorch.so libtorch_python.so libtorch.so libc10.so libc10_cuda.so libtorch_cpu.so libtorch_cuda.so libcudart.so.13
```

after:

```
libexecutorch.so libtorch_python.so libcudart.so.13 libtorch_cpu.so libc10.so
```

The other three lose `libtorch_cuda.so` the same way.

- The new check fails on the old wheel and passes on the new one.
- With CUDA torch 2.14.0 on an A100, the CUDA wheel smoke test gives the
same results before and after, apart from the new check. That includes
running models through the CUDA delegate and building a C++ app against
the wheel. Checks needing the full release setup (every GPU
architecture, the Qualcomm backend) could not run locally.
- The Python tests for the training bindings, the LLM runner bindings,
the custom ops and the quantized ops give the same results before and
after.
- With a PyTorch that links MKL as shared libraries, linking plain
`torch_cpu` would pull MKL into `DT_NEEDED` and the operator libraries
then fail to load (`undefined symbol: __kmpc_flush`).
`torch_cpu_library` keeps MKL out and they load.
- In a fresh environment with torch 2.14.0+cpu: before, the training
bindings, the LLM runner and both operator libraries fail to load.
After, `import executorch` works, all four modules import, and both
operator libraries load.

Author: shoumikhin

.ci/scripts/wheel/test_cuda_linux.py

@@ -143,6 +143,27 @@ def test_cuda_libraries_resolve_relatively() -> None:
         print(f"✓ {name} resolves the CUDA runtime relatively ({relative[0]})")
 
 
+def test_no_library_needs_cuda_torch() -> None:
+    """No shipped library may record a dependency on PyTorch's own CUDA libraries.
+
+    The CUDA delegate needs only the CUDA runtime. A library that names libtorch_cuda or
+    libc10_cuda cannot load next to a CPU-only torch, so the whole wheel then fails to import
+    there even though nothing in it calls into those libraries.
+    """
+    package_dir = _package_dir()
+    cuda_torch = {"libtorch_cuda.so", "libc10_cuda.so"}
+    offenders = {}
+    for library in test_shared_libraries._shipped_shared_objects(package_dir):
+        needed = test_shared_libraries._recorded_dependencies(library) & cuda_torch
+        if needed:
+            offenders[str(library.relative_to(package_dir))] = sorted(needed)
+    assert not offenders, (
+        f"these libraries depend on PyTorch's CUDA libraries, so the wheel cannot be imported "
+        f"with a CPU-only torch: {offenders}"
+    )
+    print("✓ no shipped library depends on PyTorch's CUDA libraries")
+
+
 def _row_architectures() -> list[str]:
     """The architectures this row claims, from the same script the build uses.
 
@@ -586,6 +607,7 @@ def test_a_model_runs_through_the_delegate() -> None:
     test_cuda_libraries_are_shipped()
     test_cuda_runtime_is_declared()
     test_cuda_libraries_resolve_relatively()
+    test_no_library_needs_cuda_torch()
     test_device_code_covers_the_row()
     test_portable_device_code_is_present()
     test_the_delegate_registers()

CMakeLists.txt

@@ -1450,11 +1450,16 @@ if(EXECUTORCH_BUILD_PYBIND)
       aten_bridge PUBLIC C10_USING_CUSTOM_GENERATED_MACROS
     )
     target_compile_options(aten_bridge PUBLIC ${_pybind_compile_options})
+    # torch_cpu_library is the CPU half of torch. Linking torch would also force
+    # libtorch_cuda into DT_NEEDED in a CUDA build, and a CPU-only torch could
+    # then not load this library.
     if(EXECUTORCH_BUILD_SHARED)
-      target_link_libraries(aten_bridge PRIVATE torch c10 executorch_shared)
+      target_link_libraries(
+        aten_bridge PRIVATE torch_cpu_library c10 executorch_shared
+      )
     else()
       target_link_libraries(
-        aten_bridge PRIVATE torch c10 executorch extension_tensor
+        aten_bridge PRIVATE torch_cpu_library c10 executorch extension_tensor
       )
     endif()
   endif()

extension/llm/custom_ops/CMakeLists.txt

@@ -230,8 +230,11 @@ if(EXECUTORCH_BUILD_KERNELS_LLM_AOT)
   endif()
   executorch_target_link_shared_runtime(custom_ops_aot_lib)
 
+  # torch_cpu_library is the CPU half of torch. Linking torch would also force
+  # libtorch_cuda into DT_NEEDED in a CUDA build, and a CPU-only torch could
+  # then not load this library.
   target_link_libraries(
-    custom_ops_aot_lib PUBLIC cpublas torch extension_tensor
+    custom_ops_aot_lib PUBLIC cpublas torch_cpu_library extension_tensor
                               extension_threadpool
   )
   if(EXECUTORCH_BUILD_KERNELS_LLM_QUANTIZED_MOE_OPTIMIZED)

extension/llm/runner/CMakeLists.txt

@@ -120,10 +120,14 @@ if(EXECUTORCH_BUILD_PYBIND)
   find_library(
     TORCH_PYTHON_LIBRARY torch_python PATHS "${TORCH_INSTALL_PREFIX}/lib"
   )
-  # Link with the extension_llm_runner library and its dependencies
+  # Link with the extension_llm_runner library and its dependencies.
+  #
+  # torch_cpu_library is the CPU half of torch. Linking torch would also force
+  # libtorch_cuda into DT_NEEDED in a CUDA build, and a CPU-only torch could
+  # then not load this library.
   target_link_libraries(
     _llm_runner PRIVATE extension_llm_runner tokenizers::tokenizers
-                        portable_lib ${TORCH_PYTHON_LIBRARY} ${TORCH_LIBRARIES}
+                        portable_lib ${TORCH_PYTHON_LIBRARY} torch_cpu_library
   )
   executorch_target_link_shared_runtime(_llm_runner)
 

extension/training/CMakeLists.txt

@@ -52,13 +52,18 @@ if(EXECUTORCH_BUILD_PYBIND)
   # Pybind library. When the consolidated shared runtime is built, the runtime
   # is resolved from it rather than from the whole-archive-forcing static
   # `executorch` target, so this module shares the one backend registry.
+  #
+  # torch_cpu_library is the CPU half of torch. Linking torch would also force
+  # libtorch_cuda into DT_NEEDED in a CUDA build, and a CPU-only torch could
+  # then not load this library.
   if(EXECUTORCH_BUILD_SHARED)
     set(_pybind_training_dep_libs ${TORCH_PYTHON_LIBRARY} etdump aten_bridge
-                                  torch extension_training
+                                  torch_cpu_library extension_training
     )
   else()
-    set(_pybind_training_dep_libs ${TORCH_PYTHON_LIBRARY} etdump executorch
-                                  aten_bridge torch extension_training
+    set(_pybind_training_dep_libs
+        ${TORCH_PYTHON_LIBRARY} etdump executorch aten_bridge torch_cpu_library
+        extension_training
     )
   endif()
 

tools/cmake/Codegen.cmake

@@ -334,7 +334,10 @@ function(gen_custom_ops_aot_lib)
   set_target_properties(${GEN_LIB_NAME} PROPERTIES CXX_STANDARD 20)
   target_compile_definitions(${GEN_LIB_NAME} PRIVATE USE_ATEN_LIB=1)
   include_directories(${TORCH_INCLUDE_DIRS})
-  target_link_libraries(${GEN_LIB_NAME} PRIVATE torch)
+  # torch_cpu_library is the CPU half of torch. Linking torch would also force
+  # libtorch_cuda into DT_NEEDED in a CUDA build, and a CPU-only torch could
+  # then not load this library.
+  target_link_libraries(${GEN_LIB_NAME} PRIVATE torch_cpu_library)
 
   executorch_target_link_options_shared_lib(${GEN_LIB_NAME})
   if(TARGET portable_lib)