Replace #4505 with a different set of workarounds (#4527)

This restores the symlinks for the installation, but teaches the busybox
info search to look for a relative path to the busybox binary itself
before walking through symlinks. This let's it find the tree structure
when directly invoking `prefix_root/bin/carbon` or similar, either
inside of a Bazel rule or from the command line, and mirrors how we
expect the installed tree to look. This works even when Bazel resolves
the symlink target fully, and potentially to something nonsensical like
a CAS file.

In order to make a convenient Bazel target that can be used with `bazel
run //toolchain`, this adds an override to explicitly set the desired
argv[0] to use when selecting a mode for the busybox and a busybox
binary. Currently, the workaround uses an environment variable because
that required the least amount of plumbing, and seems a useful override
mechanism generally, but I'm open to other approaches.

This should allow a few things to work a bit more nicely:
- It should handle sibling symlinks like `clang++` to `clang` or
  `ld.lld` to `lld`, where that symlink in turn points at the busybox.
  We want to use *initial* `argv[0]` value to select the mode there.
- It avoids bouncing through Python (or other subprocesses) when
  invoking the `carbon` binary in Bazel rules, which will be nice for
  building the example code and benchmarking.

It does come at a cost of removing one feature: the initial symlink
can't be some unrelated alias like `my_carbon_symlink` -- we expect the
*first* argv[0] name to have the meaningful filename for selecting
a busybox mode.

It also trades the complexity of the Python script for some complexity
in the busybox search in order to look for a relative `carbon-busybox`
binary. On the whole, I think that tradeoff is worthwhile, but it isn't
free.

---------

Co-authored-by: Jon Ross-Perkins <[email protected]>

Author: chandlerc

.vscode/gdb_launch.json

@@ -14,7 +14,7 @@
       "type": "by-gdb",
       "request": "launch",
       "name": "carbon compile (gdb)",
-      "program": "bazel-bin/toolchain/install/prefix_root/lib/carbon/carbon-busybox",
+      "program": "bazel-bin/toolchain/carbon",
       "programArgs": "compile --phase=lower --dump-sem-ir --stream-errors ${relativeFile}",
       "cwd": "${workspaceFolder}"
     }

.vscode/lldb_launch.json

@@ -18,7 +18,7 @@
       "type": "lldb-dap",
       "request": "launch",
       "name": "carbon compile (lldb)",
-      "program": "bazel-bin/toolchain/install/prefix_root/lib/carbon/carbon-busybox",
+      "program": "bazel-bin/toolchain/carbon",
       "args": [
         "compile",
         "--phase=lower",

docs/project/contribution_tools.md

@@ -345,7 +345,7 @@ bazel build -c dbg //toolchain
 Then debugging works with LLDB:
 
 ```shell
-lldb bazel-bin/toolchain/install/prefix_root/lib/carbon/carbon-busybox
+lldb bazel-bin/toolchain/carbon
 ```
 
 Any installed version of LLDB at least as recent as the installed Clang used for

toolchain/BUILD

@@ -2,9 +2,21 @@
 # Exceptions. See /LICENSE for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
+load("//bazel/cc_toolchains:defs.bzl", "cc_env")
+load("run_tool.bzl", "run_tool")
+
+# Support `bazel run` and create a convenience symlink for the tool in the
+# toolchain's install.
+run_tool(
+    name = "carbon",
+    data = ["//toolchain/install:install_data"],
+    env = cc_env(),
+    tool = "//toolchain/install:prefix_root/bin/carbon",
+)
+
 # A convenience target for running the toolchain with the full prelude
 # available.
 alias(
     name = "toolchain",
-    actual = "//toolchain/install:run_carbon",
+    actual = ":carbon",
 )

toolchain/docs/adding_features.md

@@ -467,8 +467,10 @@ example, with `toolchain/parse/testdata/basics/empty.carbon`:
     -   Executes an individual test.
 -   `bazel run //toolchain -- compile --phase=parse --dump-parse-tree toolchain/parse/testdata/basics/empty.carbon`
     -   Explicitly runs `carbon` with the provided arguments.
--   `bazel-bin/toolchain/install/run_carbon compile --phase=parse --dump-parse-tree toolchain/parse/testdata/basics/empty.carbon`
-    -   Similar to the previous command, but without using `bazel`.
+-   `bazel-bin/toolchain/carbon compile --phase=parse --dump-parse-tree toolchain/parse/testdata/basics/empty.carbon`
+    -   Similar to the previous command, but without using `bazel run`. This can
+        be useful with a debugger or other tool that needs to directly run the
+        binary.
 -   `bazel run //toolchain -- -v compile --phase=check toolchain/check/testdata/basics/run.carbon`
     -   Runs using `-v` for verbose log output, and running through the `check`
         phase.

toolchain/install/BUILD

@@ -5,9 +5,8 @@
 load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_library", "cc_test")
 load("//bazel/cc_toolchains:defs.bzl", "cc_env")
 load("//bazel/manifest:defs.bzl", "manifest")
-load("install_filegroups.bzl", "install_busybox_wrapper", "install_filegroup", "install_symlink", "install_target", "make_install_filegroups")
+load("install_filegroups.bzl", "install_filegroup", "install_symlink", "install_target", "make_install_filegroups")
 load("pkg_helpers.bzl", "pkg_naming_variables", "pkg_tar_and_test")
-load("run_tool.bzl", "run_tool")
 
 package(default_visibility = ["//visibility:public"])
 
@@ -89,6 +88,7 @@ cc_test(
         "//common:check",
         "//testing/base:gtest_main",
         "@googletest//:gtest",
+        "@llvm-project//llvm:Support",
     ],
 )
 
@@ -130,9 +130,10 @@ lld_aliases = [
 # based on the FHS (Filesystem Hierarchy Standard).
 install_dirs = {
     "bin": [
-        install_busybox_wrapper(
+        install_symlink(
             "carbon",
             "../lib/carbon/carbon-busybox",
+            is_driver = True,
         ),
     ],
     "lib/carbon": [
@@ -151,13 +152,10 @@ install_dirs = {
             "@llvm-project//lld:lld",
             executable = True,
         ),
-        install_busybox_wrapper(
+        install_symlink(
             "clang",
             "../../carbon-busybox",
-            [
-                "clang",
-                "--",
-            ],
+            is_driver = True,
         ),
     ] + [install_symlink(name, "lld") for name in lld_aliases],
 }
@@ -194,11 +192,3 @@ pkg_tar_and_test(
     package_variables = ":packaging_variables",
     stamp = -1,  # Allow `--stamp` builds to produce file timestamps.
 )
-
-# Support `bazel run` on specific binaries.
-run_tool(
-    name = "run_carbon",
-    data = [":install_data"],
-    env = cc_env(),
-    tool = "prefix_root/bin/carbon",
-)

toolchain/install/busybox_info.h

@@ -6,6 +6,7 @@
 #define CARBON_TOOLCHAIN_INSTALL_BUSYBOX_INFO_H_
 
 #include <filesystem>
+#include <iterator>
 #include <optional>
 #include <string>
 
@@ -14,31 +15,85 @@
 
 namespace Carbon {
 
+constexpr const char* Argv0OverrideEnv = "CARBON_ARGV0_OVERRIDE";
+
 struct BusyboxInfo {
   // The path to `carbon-busybox`.
   std::filesystem::path bin_path;
   // The mode, such as `carbon` or `clang`.
   std::optional<std::string> mode;
 };
 
-// Returns the busybox information, given argv[0]. This primarily handles
-// resolving symlinks that point at the busybox.
+// Returns the busybox information, given argv[0].
+//
+// Extracts the desired mode for the busybox from the initial command name.
+//
+// Checks if the path in argv0 is an executable in a valid Carbon install, or a
+// symlink to such an executable, and sets `bin_path` to the path of
+// `lib/carbon/carbon-busybox` within that install.
+//
+// If unable to locate a plausible busybox binary, returns an error instead.
 inline auto GetBusyboxInfo(llvm::StringRef argv0) -> ErrorOr<BusyboxInfo> {
-  BusyboxInfo info = BusyboxInfo{argv0.str(), std::nullopt};
+  // Check for an override of `argv[0]` from the environment and apply it.
+  if (const char* argv0_override = getenv(Argv0OverrideEnv)) {
+    argv0 = argv0_override;
+  }
+
+  BusyboxInfo info = {.bin_path = argv0.str(), .mode = std::nullopt};
+  std::filesystem::path filename = info.bin_path.filename();
+  // The mode is set to the initial filename used for `argv[0]`.
+  if (filename != "carbon" && filename != "carbon-busybox") {
+    info.mode = filename;
+  }
+
+  // Now search through any symlinks to locate the installed busybox binary.
   while (true) {
-    std::string filename = info.bin_path.filename();
+    filename = info.bin_path.filename();
     if (filename == "carbon-busybox") {
       return info;
     }
+
+    // If we've not already reached the busybox, look for it relative to the
+    // current binary path. This can help more immediately locate an
+    // installation tree, and avoids walking through a final layer of symlinks
+    // which may point to content-addressed storage or other parts of a build
+    // output tree.
+    //
+    // We break this into two cases we need to handle:
+    // - Carbon's CLI will be: `<prefix>/bin/carbon`
+    // - Other tools will be: `<prefix>/lib/carbon/<group>/bin/<tool>`
+    //
+    // We also check that the current path is within a `bin` directory to
+    // provide best-effort checking for accidentally walking up from symlinks
+    // that aren't within an installation-shaped tree.
+    auto parent_path = info.bin_path.parent_path();
+    // Strip any `.` path components at the end to simplify processing.
+    while (parent_path.filename() == ".") {
+      parent_path = parent_path.parent_path();
+    }
+    if (parent_path.filename() == "bin") {
+      auto lib_path = filename == "carbon"
+                          ? parent_path / ".." / "lib" / "carbon"
+                          : parent_path / ".." / "..";
+      auto busybox_path = lib_path / "carbon-busybox";
+      std::error_code ec;
+      if (std::filesystem::exists(busybox_path, ec)) {
+        info.bin_path = busybox_path;
+        return info;
+      }
+    }
+
+    // Try to walk through another layer of symlinks and see if we can find the
+    // installation there or are linked directly to the busybox.
     std::error_code ec;
     auto symlink_target = std::filesystem::read_symlink(info.bin_path, ec);
     if (ec) {
       return ErrorBuilder()
              << "expected carbon-busybox symlink at `" << info.bin_path << "`";
     }
-    info.mode = filename;
+
     // Do a path join, to handle relative symlinks.
-    info.bin_path = info.bin_path.parent_path() / symlink_target;
+    info.bin_path = parent_path / symlink_target;
   }
 }