mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-09-24 22:02:23 +01:00
Jon Ross-Perkins
3070e5cfc6
When finding an executable, this validates that the returned binary is a symlink back to the same thing as /proc/self/exe, also using that as a fallback for different things. Looking back at #3912, we started using `findProgramByName` in order to avoid path canonicalization done by `GetMainExecutable`. That created issues as in #5096, wherein an `argv[0]` that's not explicit enough (`llvm-symbolizer` instead of the full path, done in [LLVM's Signals.cpp](https://github.com/llvm/llvm-project/blob/4f60f45130c6bd96c79e468fe9927a29af760f56/llvm/lib/Support/Signals.cpp#L198)) leads to incorrect results (finding an `llvm-symbolizer` in `$PATH`). One option to fix this would be to patch LLVM to provide an absolute path for `llvm-symbolizer`. However, I'll suggest that passing a filename in `argv[0]` is not terribly uncommon, and could be a migration limitation if we force it. The failure mode is also opaque; for example: ``` $ /bin/sh -c "exec -a llvm-symbolizer ./bazel-bin/toolchain/carbon" error: expected carbon-busybox symlink at `/usr/lib/llvm-19/bin/llvm-symbolizer` ``` Combined with the `setenv` of `LLVM_SYMBOLIZER_PATH` in `busybox_main.cpp`, this is intended to fix #5096.
62 lines
1.9 KiB
C++
62 lines
1.9 KiB
C++
// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
|
|
// Exceptions. See /LICENSE for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
|
|
#include "common/exe_path.h"
|
|
|
|
#include <optional>
|
|
#include <string>
|
|
#include <utility>
|
|
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/Support/FileSystem.h"
|
|
#include "llvm/Support/Program.h"
|
|
|
|
namespace Carbon {
|
|
|
|
// Returns true if a found path resolves to the actual executable path.
|
|
static auto RealPathMatches(const char* found_path, llvm::StringRef exe_path)
|
|
-> bool {
|
|
char* buffer = realpath(found_path, nullptr);
|
|
if (!buffer) {
|
|
return false;
|
|
}
|
|
bool matches = exe_path == buffer;
|
|
free(buffer);
|
|
return matches;
|
|
}
|
|
|
|
auto FindExecutablePath(const char* argv0) -> std::string {
|
|
static int static_for_main_addr;
|
|
// Note this returns the canonical path, dropping symlink information that we
|
|
// might want. As a consequence, we use it as a last resort. However, it's
|
|
// also helpful to use to ensure we found the correct tool through other
|
|
// means.
|
|
std::string exe_path =
|
|
llvm::sys::fs::getMainExecutable(argv0, &static_for_main_addr);
|
|
|
|
llvm::StringRef argv0_ref = argv0;
|
|
|
|
// If `argv[0]` is path-like and points at the executable, use the form in
|
|
// `argv[0]`.
|
|
if (argv0_ref.contains('/') && RealPathMatches(argv0, exe_path)) {
|
|
return argv0_ref.str();
|
|
}
|
|
|
|
// If we can find `argv[0]` in `$PATH`, use the form from that.
|
|
//
|
|
// For example, `llvm-symbolizer` is subprocessed with `argv[0]` that uses
|
|
// this path. If `LLVM_SYMBOLIZER_PATH` is set to Carbon, but
|
|
// `llvm-symbolizer` in `$PATH` is a different binary, that can lead to
|
|
// problems -- which is why we verify the match.
|
|
if (llvm::ErrorOr<std::string> path = llvm::sys::findProgramByName(argv0_ref);
|
|
path && RealPathMatches(path->c_str(), exe_path)) {
|
|
return std::move(*path);
|
|
}
|
|
|
|
// As a fallback, use exe_path.
|
|
return exe_path;
|
|
}
|
|
|
|
} // namespace Carbon
|