Update

[ghstack-poisoned]

Author: shoumikhin

.ci/scripts/wheel/test_cpp_sdk.py

@@ -177,6 +177,8 @@ def test_cpp_consumer(work_dir: Path) -> None:
     subprocess.run([str(consumer)], check=True, env=environment)
     print("✓ C++ consumer builds and runs against the installed wheel")
 
+    _assert_runs_relocated(consumer, package_dir, work_dir, environment)
+
     assert shutil.which("readelf") is not None, "readelf is required to check the ELF"
 
     dynamic = subprocess.run(
@@ -193,6 +195,49 @@ def test_cpp_consumer(work_dir: Path) -> None:
     print("✓ consumer depends on the shipped runtime with a relocatable RUNPATH")
 
 
+def _assert_runs_relocated(consumer, package_dir, work_dir, environment) -> None:
+    """The app still runs after being moved away from the wheel.
+
+    Building in place leaves an absolute path to the wheel's lib directory in the
+    binary's RUNPATH, which resolves the runtime no matter what `$ORIGIN` says.
+    Copying the app next to a copy of the runtime, with that absolute entry
+    removed, is what actually proves the package is relocatable.
+
+    The layout mirrors what the package config supports: the app in `bin/` with
+    the libraries in a sibling `lib/`, which is what `$ORIGIN/../lib` resolves.
+    """
+    if shutil.which("patchelf") is None:
+        print("- patchelf not available, skipping the relocated run")
+        return
+
+    deploy = work_dir / "deployed"
+    (deploy / "bin").mkdir(parents=True, exist_ok=True)
+    (deploy / "lib").mkdir(parents=True, exist_ok=True)
+    moved = deploy / "bin" / consumer.name
+    shutil.copy2(consumer, moved)
+    for library in (package_dir / "lib").glob("*.so*"):
+        shutil.copy2(library, deploy / "lib" / library.name)
+
+    # Keep only the $ORIGIN-relative entries, so nothing absolute can help.
+    current = subprocess.run(
+        ["patchelf", "--print-rpath", str(moved)],
+        capture_output=True,
+        text=True,
+        check=True,
+    ).stdout.strip()
+    relative = [entry for entry in current.split(":") if entry.startswith("$ORIGIN")]
+    assert relative, (
+        "the consumer has no $ORIGIN-relative RUNPATH entry, so it cannot be "
+        f"relocated; RUNPATH was: {current}"
+    )
+    subprocess.run(
+        ["patchelf", "--set-rpath", ":".join(relative), str(moved)], check=True
+    )
+
+    subprocess.run([str(moved)], check=True, env=environment, cwd=str(deploy))
+    print("✓ consumer still runs when deployed beside a copy of the runtime")
+
+
 def run_tests(work_dir: Path) -> None:
     test_single_backend_registry()
     test_single_threadpool()

CMakeLists.txt

@@ -1289,17 +1289,10 @@ if(EXECUTORCH_BUILD_PYBIND)
   strip_python_lib(data_loader)
   target_include_directories(data_loader PRIVATE ${_common_include_directories})
   target_compile_options(data_loader PUBLIC ${_pybind_compile_options})
-  # This module only exposes a pybind type; it calls into no runtime symbols, so
-  # it links the static core as before and does not need the shared runtime. The
-  # RPATH entry is still useful because sibling extensions in this directory do
-  # resolve libexecutorch.so from ../../lib.
+  # This module only exposes a pybind type and calls into no runtime symbols, so
+  # it links the static core as before and needs nothing from the shared
+  # runtime.
   target_link_libraries(data_loader PRIVATE executorch)
-  if(EXECUTORCH_BUILD_SHARED AND NOT APPLE)
-    set_target_properties(
-      data_loader PROPERTIES BUILD_RPATH "$ORIGIN/../../lib"
-                             INSTALL_RPATH "$ORIGIN/../../lib"
-    )
-  endif()
   install(TARGETS data_loader
           LIBRARY DESTINATION executorch/extension/pybindings
   )

kernels/quantized/CMakeLists.txt

@@ -86,6 +86,16 @@ if(NOT CMAKE_GENERATOR STREQUAL "Xcode"
     gen_custom_ops_aot_lib(
       LIB_NAME "quantized_ops_aot_lib" KERNEL_SOURCES "${_quantized_sources}"
     )
+    if(EXECUTORCH_BUILD_SHARED AND NOT APPLE)
+      # The generated library resolves the runtime from libexecutorch.so, so it
+      # needs the path to it whether or not pybindings are also being built.
+      # This library lands in <site-packages>/executorch/kernels/quantized, two
+      # levels below the wheel's lib/ directory.
+      set_target_properties(
+        quantized_ops_aot_lib PROPERTIES BUILD_RPATH "$ORIGIN/../../lib"
+                                         INSTALL_RPATH "$ORIGIN/../../lib"
+      )
+    endif()
 
     # Register quantized ops to portable_lib, so that they're available via
     # pybindings.

tools/cmake/Utils.cmake

@@ -251,7 +251,9 @@ function(executorch_target_link_shared_runtime target_name)
     return()
   endif()
   if(APPLE OR MSVC)
-    set(_runtime_flags "SHELL:$<TARGET_FILE:executorch_shared>")
+    # TARGET_LINKER_FILE rather than TARGET_FILE: on Windows the linker needs
+    # the import library, not the DLL itself.
+    set(_runtime_flags "SHELL:$<TARGET_LINKER_FILE:executorch_shared>")
   else()
     # --no-as-needed keeps the runtime in DT_NEEDED even though no symbol has
     # been referenced yet at this point on the link line. It is wrapped in