blob: 5a8d2196c5ff825594f6edb87dacc62b73934516 [file] [log] [blame]
//===- dsymutil.cpp - Debug info dumping utility for llvm -----------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This program is a utility that aims to be a dropin replacement for Darwin's
// dsymutil.
//===----------------------------------------------------------------------===//
#include "dsymutil.h"
#include "BinaryHolder.h"
#include "CFBundle.h"
#include "DebugMap.h"
#include "DwarfLinkerForBinary.h"
#include "LinkUtils.h"
#include "MachOUtils.h"
#include "Reproducer.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/DebugInfo/DIContext.h"
#include "llvm/DebugInfo/DWARF/DWARFContext.h"
#include "llvm/DebugInfo/DWARF/DWARFVerifier.h"
#include "llvm/MC/MCSubtargetInfo.h"
#include "llvm/Object/Binary.h"
#include "llvm/Object/MachO.h"
#include "llvm/Option/Arg.h"
#include "llvm/Option/ArgList.h"
#include "llvm/Option/Option.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/CrashRecoveryContext.h"
#include "llvm/Support/FileCollector.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/InitLLVM.h"
#include "llvm/Support/LLVMDriver.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/TargetSelect.h"
#include "llvm/Support/ThreadPool.h"
#include "llvm/Support/WithColor.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Support/thread.h"
#include "llvm/TargetParser/Triple.h"
#include <algorithm>
#include <cstdint>
#include <cstdlib>
#include <string>
#include <system_error>
using namespace llvm;
using namespace llvm::dsymutil;
using namespace object;
namespace {
enum ID {
OPT_INVALID = 0, // This is not an option ID.
#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
HELPTEXT, METAVAR, VALUES) \
OPT_##ID,
#include "Options.inc"
#undef OPTION
};
#define PREFIX(NAME, VALUE) \
static constexpr StringLiteral NAME##_init[] = VALUE; \
static constexpr ArrayRef<StringLiteral> NAME(NAME##_init, \
std::size(NAME##_init) - 1);
#include "Options.inc"
#undef PREFIX
static constexpr opt::OptTable::Info InfoTable[] = {
#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \
HELPTEXT, METAVAR, VALUES) \
{ \
PREFIX, NAME, HELPTEXT, \
METAVAR, OPT_##ID, opt::Option::KIND##Class, \
PARAM, FLAGS, OPT_##GROUP, \
OPT_##ALIAS, ALIASARGS, VALUES},
#include "Options.inc"
#undef OPTION
};
class DsymutilOptTable : public opt::GenericOptTable {
public:
DsymutilOptTable() : opt::GenericOptTable(InfoTable) {}
};
} // namespace
enum class DWARFVerify : uint8_t {
None = 0,
Input = 1 << 0,
Output = 1 << 1,
OutputOnValidInput = 1 << 2,
All = Input | Output,
Auto = Input | OutputOnValidInput,
#if !defined(NDEBUG) || defined(EXPENSIVE_CHECKS)
Default = None // FIXME: Auto
#else
Default = None
#endif
};
inline bool flagIsSet(DWARFVerify Flags, DWARFVerify SingleFlag) {
return static_cast<uint8_t>(Flags) & static_cast<uint8_t>(SingleFlag);
}
struct DsymutilOptions {
bool DumpDebugMap = false;
bool DumpStab = false;
bool Flat = false;
bool InputIsYAMLDebugMap = false;
bool PaperTrailWarnings = false;
bool ForceKeepFunctionForStatic = false;
std::string SymbolMap;
std::string OutputFile;
std::string Toolchain;
std::string ReproducerPath;
std::vector<std::string> Archs;
std::vector<std::string> InputFiles;
unsigned NumThreads;
DWARFVerify Verify = DWARFVerify::Default;
ReproducerMode ReproMode = ReproducerMode::GenerateOnCrash;
dsymutil::LinkOptions LinkOpts;
};
/// Return a list of input files. This function has logic for dealing with the
/// special case where we might have dSYM bundles as input. The function
/// returns an error when the directory structure doesn't match that of a dSYM
/// bundle.
static Expected<std::vector<std::string>> getInputs(opt::InputArgList &Args,
bool DsymAsInput) {
std::vector<std::string> InputFiles;
for (auto *File : Args.filtered(OPT_INPUT))
InputFiles.push_back(File->getValue());
if (!DsymAsInput)
return InputFiles;
// If we are updating, we might get dSYM bundles as input.
std::vector<std::string> Inputs;
for (const auto &Input : InputFiles) {
if (!sys::fs::is_directory(Input)) {
Inputs.push_back(Input);
continue;
}
// Make sure that we're dealing with a dSYM bundle.
SmallString<256> BundlePath(Input);
sys::path::append(BundlePath, "Contents", "Resources", "DWARF");
if (!sys::fs::is_directory(BundlePath))
return make_error<StringError>(
Input + " is a directory, but doesn't look like a dSYM bundle.",
inconvertibleErrorCode());
// Create a directory iterator to iterate over all the entries in the
// bundle.
std::error_code EC;
sys::fs::directory_iterator DirIt(BundlePath, EC);
sys::fs::directory_iterator DirEnd;
if (EC)
return errorCodeToError(EC);
// Add each entry to the list of inputs.
while (DirIt != DirEnd) {
Inputs.push_back(DirIt->path());
DirIt.increment(EC);
if (EC)
return errorCodeToError(EC);
}
}
return Inputs;
}
// Verify that the given combination of options makes sense.
static Error verifyOptions(const DsymutilOptions &Options) {
if (Options.InputFiles.empty()) {
return make_error<StringError>("no input files specified",
errc::invalid_argument);
}
if (Options.LinkOpts.Update && llvm::is_contained(Options.InputFiles, "-")) {
// FIXME: We cannot use stdin for an update because stdin will be
// consumed by the BinaryHolder during the debugmap parsing, and
// then we will want to consume it again in DwarfLinker. If we
// used a unique BinaryHolder object that could cache multiple
// binaries this restriction would go away.
return make_error<StringError>(
"standard input cannot be used as input for a dSYM update.",
errc::invalid_argument);
}
if (!Options.Flat && Options.OutputFile == "-")
return make_error<StringError>(
"cannot emit to standard output without --flat.",
errc::invalid_argument);
if (Options.InputFiles.size() > 1 && Options.Flat &&
!Options.OutputFile.empty())
return make_error<StringError>(
"cannot use -o with multiple inputs in flat mode.",
errc::invalid_argument);
if (Options.PaperTrailWarnings && Options.InputIsYAMLDebugMap)
return make_error<StringError>(
"paper trail warnings are not supported for YAML input.",
errc::invalid_argument);
if (!Options.ReproducerPath.empty() &&
Options.ReproMode != ReproducerMode::Use)
return make_error<StringError>(
"cannot combine --gen-reproducer and --use-reproducer.",
errc::invalid_argument);
return Error::success();
}
static Expected<DsymutilAccelTableKind>
getAccelTableKind(opt::InputArgList &Args) {
if (opt::Arg *Accelerator = Args.getLastArg(OPT_accelerator)) {
StringRef S = Accelerator->getValue();
if (S == "Apple")
return DsymutilAccelTableKind::Apple;
if (S == "Dwarf")
return DsymutilAccelTableKind::Dwarf;
if (S == "Pub")
return DsymutilAccelTableKind::Pub;
if (S == "Default")
return DsymutilAccelTableKind::Default;
if (S == "None")
return DsymutilAccelTableKind::None;
return make_error<StringError>("invalid accelerator type specified: '" + S +
"'. Supported values are 'Apple', "
"'Dwarf', 'Pub', 'Default' and 'None'.",
inconvertibleErrorCode());
}
return DsymutilAccelTableKind::Default;
}
static Expected<DsymutilDWARFLinkerType>
getDWARFLinkerType(opt::InputArgList &Args) {
if (opt::Arg *LinkerType = Args.getLastArg(OPT_linker)) {
StringRef S = LinkerType->getValue();
if (S == "apple")
return DsymutilDWARFLinkerType::Apple;
if (S == "llvm")
return DsymutilDWARFLinkerType::LLVM;
return make_error<StringError>("invalid DWARF linker type specified: '" +
S +
"'. Supported values are 'apple', "
"'llvm'.",
inconvertibleErrorCode());
}
return DsymutilDWARFLinkerType::Apple;
}
static Expected<ReproducerMode> getReproducerMode(opt::InputArgList &Args) {
if (Args.hasArg(OPT_gen_reproducer))
return ReproducerMode::GenerateOnExit;
if (opt::Arg *Reproducer = Args.getLastArg(OPT_reproducer)) {
StringRef S = Reproducer->getValue();
if (S == "GenerateOnExit")
return ReproducerMode::GenerateOnExit;
if (S == "GenerateOnCrash")
return ReproducerMode::GenerateOnCrash;
if (S == "Off")
return ReproducerMode::Off;
return make_error<StringError>(
"invalid reproducer mode: '" + S +
"'. Supported values are 'GenerateOnExit', 'GenerateOnCrash', "
"'Off'.",
inconvertibleErrorCode());
}
return ReproducerMode::GenerateOnCrash;
}
static Expected<DWARFVerify> getVerifyKind(opt::InputArgList &Args) {
if (Args.hasArg(OPT_verify))
return DWARFVerify::Output;
if (opt::Arg *Verify = Args.getLastArg(OPT_verify_dwarf)) {
StringRef S = Verify->getValue();
if (S == "input")
return DWARFVerify::Input;
if (S == "output")
return DWARFVerify::Output;
if (S == "all")
return DWARFVerify::All;
if (S == "auto")
return DWARFVerify::Auto;
if (S == "none")
return DWARFVerify::None;
return make_error<StringError>("invalid verify type specified: '" + S +
"'. Supported values are 'none', "
"'input', 'output', 'all' and 'auto'.",
inconvertibleErrorCode());
}
return DWARFVerify::Default;
}
/// Parses the command line options into the LinkOptions struct and performs
/// some sanity checking. Returns an error in case the latter fails.
static Expected<DsymutilOptions> getOptions(opt::InputArgList &Args) {
DsymutilOptions Options;
Options.DumpDebugMap = Args.hasArg(OPT_dump_debug_map);
Options.DumpStab = Args.hasArg(OPT_symtab);
Options.Flat = Args.hasArg(OPT_flat);
Options.InputIsYAMLDebugMap = Args.hasArg(OPT_yaml_input);
Options.PaperTrailWarnings = Args.hasArg(OPT_papertrail);
if (Expected<DWARFVerify> Verify = getVerifyKind(Args)) {
Options.Verify = *Verify;
} else {
return Verify.takeError();
}
Options.LinkOpts.NoODR = Args.hasArg(OPT_no_odr);
Options.LinkOpts.VerifyInputDWARF =
flagIsSet(Options.Verify, DWARFVerify::Input);
Options.LinkOpts.NoOutput = Args.hasArg(OPT_no_output);
Options.LinkOpts.NoTimestamp = Args.hasArg(OPT_no_swiftmodule_timestamp);
Options.LinkOpts.Update = Args.hasArg(OPT_update);
Options.LinkOpts.Verbose = Args.hasArg(OPT_verbose);
Options.LinkOpts.Statistics = Args.hasArg(OPT_statistics);
Options.LinkOpts.Fat64 = Args.hasArg(OPT_fat64);
Options.LinkOpts.KeepFunctionForStatic =
Args.hasArg(OPT_keep_func_for_static);
if (opt::Arg *ReproducerPath = Args.getLastArg(OPT_use_reproducer)) {
Options.ReproMode = ReproducerMode::Use;
Options.ReproducerPath = ReproducerPath->getValue();
} else {
if (Expected<ReproducerMode> ReproMode = getReproducerMode(Args)) {
Options.ReproMode = *ReproMode;
} else {
return ReproMode.takeError();
}
}
if (Expected<DsymutilAccelTableKind> AccelKind = getAccelTableKind(Args)) {
Options.LinkOpts.TheAccelTableKind = *AccelKind;
} else {
return AccelKind.takeError();
}
if (Expected<DsymutilDWARFLinkerType> DWARFLinkerType =
getDWARFLinkerType(Args)) {
Options.LinkOpts.DWARFLinkerType = *DWARFLinkerType;
} else {
return DWARFLinkerType.takeError();
}
if (opt::Arg *SymbolMap = Args.getLastArg(OPT_symbolmap))
Options.SymbolMap = SymbolMap->getValue();
if (Args.hasArg(OPT_symbolmap))
Options.LinkOpts.Update = true;
if (Expected<std::vector<std::string>> InputFiles =
getInputs(Args, Options.LinkOpts.Update)) {
Options.InputFiles = std::move(*InputFiles);
} else {
return InputFiles.takeError();
}
for (auto *Arch : Args.filtered(OPT_arch))
Options.Archs.push_back(Arch->getValue());
if (opt::Arg *OsoPrependPath = Args.getLastArg(OPT_oso_prepend_path))
Options.LinkOpts.PrependPath = OsoPrependPath->getValue();
for (const auto &Arg : Args.getAllArgValues(OPT_object_prefix_map)) {
auto Split = StringRef(Arg).split('=');
Options.LinkOpts.ObjectPrefixMap.insert(
{std::string(Split.first), std::string(Split.second)});
}
if (opt::Arg *OutputFile = Args.getLastArg(OPT_output))
Options.OutputFile = OutputFile->getValue();
if (opt::Arg *Toolchain = Args.getLastArg(OPT_toolchain))
Options.Toolchain = Toolchain->getValue();
if (Args.hasArg(OPT_assembly))
Options.LinkOpts.FileType = DWARFLinker::OutputFileType::Assembly;
if (opt::Arg *NumThreads = Args.getLastArg(OPT_threads))
Options.LinkOpts.Threads = atoi(NumThreads->getValue());
else
Options.LinkOpts.Threads = 0; // Use all available hardware threads
if (Options.DumpDebugMap || Options.LinkOpts.Verbose)
Options.LinkOpts.Threads = 1;
if (getenv("RC_DEBUG_OPTIONS"))
Options.PaperTrailWarnings = true;
if (opt::Arg *RemarksPrependPath = Args.getLastArg(OPT_remarks_prepend_path))
Options.LinkOpts.RemarksPrependPath = RemarksPrependPath->getValue();
if (opt::Arg *RemarksOutputFormat =
Args.getLastArg(OPT_remarks_output_format)) {
if (Expected<remarks::Format> FormatOrErr =
remarks::parseFormat(RemarksOutputFormat->getValue()))
Options.LinkOpts.RemarksFormat = *FormatOrErr;
else
return FormatOrErr.takeError();
}
Options.LinkOpts.RemarksKeepAll =
!Args.hasArg(OPT_remarks_drop_without_debug);
if (Error E = verifyOptions(Options))
return std::move(E);
return Options;
}
static Error createPlistFile(StringRef Bin, StringRef BundleRoot,
StringRef Toolchain) {
// Create plist file to write to.
SmallString<128> InfoPlist(BundleRoot);
sys::path::append(InfoPlist, "Contents/Info.plist");
std::error_code EC;
raw_fd_ostream PL(InfoPlist, EC, sys::fs::OF_TextWithCRLF);
if (EC)
return make_error<StringError>(
"cannot create Plist: " + toString(errorCodeToError(EC)), EC);
CFBundleInfo BI = getBundleInfo(Bin);
if (BI.IDStr.empty()) {
StringRef BundleID = *sys::path::rbegin(BundleRoot);
if (sys::path::extension(BundleRoot) == ".dSYM")
BI.IDStr = std::string(sys::path::stem(BundleID));
else
BI.IDStr = std::string(BundleID);
}
// Print out information to the plist file.
PL << "<?xml version=\"1.0\" encoding=\"UTF-8\"\?>\n"
<< "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\" "
<< "\"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
<< "<plist version=\"1.0\">\n"
<< "\t<dict>\n"
<< "\t\t<key>CFBundleDevelopmentRegion</key>\n"
<< "\t\t<string>English</string>\n"
<< "\t\t<key>CFBundleIdentifier</key>\n"
<< "\t\t<string>com.apple.xcode.dsym.";
printHTMLEscaped(BI.IDStr, PL);
PL << "</string>\n"
<< "\t\t<key>CFBundleInfoDictionaryVersion</key>\n"
<< "\t\t<string>6.0</string>\n"
<< "\t\t<key>CFBundlePackageType</key>\n"
<< "\t\t<string>dSYM</string>\n"
<< "\t\t<key>CFBundleSignature</key>\n"
<< "\t\t<string>\?\?\?\?</string>\n";
if (!BI.OmitShortVersion()) {
PL << "\t\t<key>CFBundleShortVersionString</key>\n";
PL << "\t\t<string>";
printHTMLEscaped(BI.ShortVersionStr, PL);
PL << "</string>\n";
}
PL << "\t\t<key>CFBundleVersion</key>\n";
PL << "\t\t<string>";
printHTMLEscaped(BI.VersionStr, PL);
PL << "</string>\n";
if (!Toolchain.empty()) {
PL << "\t\t<key>Toolchain</key>\n";
PL << "\t\t<string>";
printHTMLEscaped(Toolchain, PL);
PL << "</string>\n";
}
PL << "\t</dict>\n"
<< "</plist>\n";
PL.close();
return Error::success();
}
static Error createBundleDir(StringRef BundleBase) {
SmallString<128> Bundle(BundleBase);
sys::path::append(Bundle, "Contents", "Resources", "DWARF");
if (std::error_code EC =
create_directories(Bundle.str(), true, sys::fs::perms::all_all))
return make_error<StringError>(
"cannot create bundle: " + toString(errorCodeToError(EC)), EC);
return Error::success();
}
static bool verifyOutput(StringRef OutputFile, StringRef Arch,
DsymutilOptions Options) {
if (OutputFile == "-") {
WithColor::warning() << "verification skipped for " << Arch
<< " because writing to stdout.\n";
return true;
}
if (Options.LinkOpts.NoOutput) {
WithColor::warning() << "verification skipped for " << Arch
<< " because --no-output was passed.\n";
return true;
}
Expected<OwningBinary<Binary>> BinOrErr = createBinary(OutputFile);
if (!BinOrErr) {
WithColor::error() << OutputFile << ": " << toString(BinOrErr.takeError());
return false;
}
Binary &Binary = *BinOrErr.get().getBinary();
if (auto *Obj = dyn_cast<MachOObjectFile>(&Binary)) {
std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(*Obj);
if (DICtx->getMaxVersion() >= 5) {
WithColor::warning() << "verification skipped for " << Arch
<< " because DWARFv5 is not fully supported yet.\n";
return true;
}
raw_ostream &os = Options.LinkOpts.Verbose ? errs() : nulls();
os << "Verifying DWARF for architecture: " << Arch << "\n";
DIDumpOptions DumpOpts;
bool success = DICtx->verify(os, DumpOpts.noImplicitRecursion());
if (!success)
WithColor::error() << "output verification failed for " << Arch << '\n';
return success;
}
return false;
}
namespace {
struct OutputLocation {
OutputLocation(std::string DWARFFile,
std::optional<std::string> ResourceDir = {})
: DWARFFile(DWARFFile), ResourceDir(ResourceDir) {}
/// This method is a workaround for older compilers.
std::optional<std::string> getResourceDir() const { return ResourceDir; }
std::string DWARFFile;
std::optional<std::string> ResourceDir;
};
} // namespace
static Expected<OutputLocation>
getOutputFileName(StringRef InputFile, const DsymutilOptions &Options) {
if (Options.OutputFile == "-")
return OutputLocation(Options.OutputFile);
// When updating, do in place replacement.
if (Options.OutputFile.empty() &&
(Options.LinkOpts.Update || !Options.SymbolMap.empty()))
return OutputLocation(std::string(InputFile));
// When dumping the debug map, just return an empty output location. This
// allows us to compute the output location once.
if (Options.DumpDebugMap)
return OutputLocation("");
// If a flat dSYM has been requested, things are pretty simple.
if (Options.Flat) {
if (Options.OutputFile.empty()) {
if (InputFile == "-")
return OutputLocation{"a.out.dwarf", {}};
return OutputLocation((InputFile + ".dwarf").str());
}
return OutputLocation(Options.OutputFile);
}
// We need to create/update a dSYM bundle.
// A bundle hierarchy looks like this:
// <bundle name>.dSYM/
// Contents/
// Info.plist
// Resources/
// DWARF/
// <DWARF file(s)>
std::string DwarfFile =
std::string(InputFile == "-" ? StringRef("a.out") : InputFile);
SmallString<128> Path(Options.OutputFile);
if (Path.empty())
Path = DwarfFile + ".dSYM";
if (!Options.LinkOpts.NoOutput) {
if (auto E = createBundleDir(Path))
return std::move(E);
if (auto E = createPlistFile(DwarfFile, Path, Options.Toolchain))
return std::move(E);
}
sys::path::append(Path, "Contents", "Resources");
std::string ResourceDir = std::string(Path.str());
sys::path::append(Path, "DWARF", sys::path::filename(DwarfFile));
return OutputLocation(std::string(Path.str()), ResourceDir);
}
int main(int argc, char **argv) {
InitLLVM X(argc, argv);
// Parse arguments.
DsymutilOptTable T;
unsigned MAI;
unsigned MAC;
ArrayRef<const char *> ArgsArr = ArrayRef(argv + 1, argc - 1);
opt::InputArgList Args = T.ParseArgs(ArgsArr, MAI, MAC);
void *P = (void *)(intptr_t)getOutputFileName;
std::string SDKPath = sys::fs::getMainExecutable(argv[0], P);
SDKPath = std::string(sys::path::parent_path(SDKPath));
for (auto *Arg : Args.filtered(OPT_UNKNOWN)) {
WithColor::warning() << "ignoring unknown option: " << Arg->getSpelling()
<< '\n';
}
if (Args.hasArg(OPT_help)) {
T.printHelp(
outs(), (std::string(argv[0]) + " [options] <input files>").c_str(),
"manipulate archived DWARF debug symbol files.\n\n"
"dsymutil links the DWARF debug information found in the object files\n"
"for the executable <input file> by using debug symbols information\n"
"contained in its symbol table.\n",
false);
return EXIT_SUCCESS;
}
if (Args.hasArg(OPT_version)) {
cl::PrintVersionMessage();
return EXIT_SUCCESS;
}
auto OptionsOrErr = getOptions(Args);
if (!OptionsOrErr) {
WithColor::error() << toString(OptionsOrErr.takeError()) << '\n';
return EXIT_FAILURE;
}
auto &Options = *OptionsOrErr;
InitializeAllTargetInfos();
InitializeAllTargetMCs();
InitializeAllTargets();
InitializeAllAsmPrinters();
auto Repro = Reproducer::createReproducer(Options.ReproMode,
Options.ReproducerPath, argc, argv);
if (!Repro) {
WithColor::error() << toString(Repro.takeError()) << '\n';
return EXIT_FAILURE;
}
Options.LinkOpts.VFS = (*Repro)->getVFS();
for (const auto &Arch : Options.Archs)
if (Arch != "*" && Arch != "all" &&
!object::MachOObjectFile::isValidArch(Arch)) {
WithColor::error() << "unsupported cpu architecture: '" << Arch << "'\n";
return EXIT_FAILURE;
}
SymbolMapLoader SymMapLoader(Options.SymbolMap);
for (auto &InputFile : Options.InputFiles) {
// Dump the symbol table for each input file and requested arch
if (Options.DumpStab) {
if (!dumpStab(Options.LinkOpts.VFS, InputFile, Options.Archs,
Options.LinkOpts.PrependPath))
return EXIT_FAILURE;
continue;
}
auto DebugMapPtrsOrErr =
parseDebugMap(Options.LinkOpts.VFS, InputFile, Options.Archs,
Options.LinkOpts.PrependPath, Options.PaperTrailWarnings,
Options.LinkOpts.Verbose, Options.InputIsYAMLDebugMap);
if (auto EC = DebugMapPtrsOrErr.getError()) {
WithColor::error() << "cannot parse the debug map for '" << InputFile
<< "': " << EC.message() << '\n';
return EXIT_FAILURE;
}
// Remember the number of debug maps that are being processed to decide how
// to name the remark files.
Options.LinkOpts.NumDebugMaps = DebugMapPtrsOrErr->size();
if (Options.LinkOpts.Update) {
// The debug map should be empty. Add one object file corresponding to
// the input file.
for (auto &Map : *DebugMapPtrsOrErr)
Map->addDebugMapObject(InputFile,
sys::TimePoint<std::chrono::seconds>());
}
// Ensure that the debug map is not empty (anymore).
if (DebugMapPtrsOrErr->empty()) {
WithColor::error() << "no architecture to link\n";
return EXIT_FAILURE;
}
// Shared a single binary holder for all the link steps.
BinaryHolder BinHolder(Options.LinkOpts.VFS);
// Compute the output location and update the resource directory.
Expected<OutputLocation> OutputLocationOrErr =
getOutputFileName(InputFile, Options);
if (!OutputLocationOrErr) {
WithColor::error() << toString(OutputLocationOrErr.takeError());
return EXIT_FAILURE;
}
Options.LinkOpts.ResourceDir = OutputLocationOrErr->getResourceDir();
// Statistics only require different architectures to be processed
// sequentially, the link itself can still happen in parallel. Change the
// thread pool strategy here instead of modifying LinkOpts.Threads.
ThreadPoolStrategy S = hardware_concurrency(
Options.LinkOpts.Statistics ? 1 : Options.LinkOpts.Threads);
if (Options.LinkOpts.Threads == 0) {
// If NumThreads is not specified, create one thread for each input, up to
// the number of hardware threads.
S.ThreadsRequested = DebugMapPtrsOrErr->size();
S.Limit = true;
}
ThreadPool Threads(S);
// If there is more than one link to execute, we need to generate
// temporary files.
const bool NeedsTempFiles =
!Options.DumpDebugMap && (Options.OutputFile != "-") &&
(DebugMapPtrsOrErr->size() != 1 || Options.LinkOpts.Update);
// Set up a crash recovery context.
CrashRecoveryContext::Enable();
CrashRecoveryContext CRC;
CRC.DumpStackAndCleanupOnFailure = true;
std::atomic_char AllOK(1);
SmallVector<MachOUtils::ArchAndFile, 4> TempFiles;
std::mutex ErrorHandlerMutex;
const bool Crashed = !CRC.RunSafely([&]() {
for (auto &Map : *DebugMapPtrsOrErr) {
if (Options.LinkOpts.Verbose || Options.DumpDebugMap)
Map->print(outs());
if (Options.DumpDebugMap)
continue;
if (!Options.SymbolMap.empty())
Options.LinkOpts.Translator = SymMapLoader.Load(InputFile, *Map);
if (Map->begin() == Map->end())
WithColor::warning()
<< "no debug symbols in executable (-arch "
<< MachOUtils::getArchName(Map->getTriple().getArchName())
<< ")\n";
// Using a std::shared_ptr rather than std::unique_ptr because move-only
// types don't work with std::bind in the ThreadPool implementation.
std::shared_ptr<raw_fd_ostream> OS;
std::string OutputFile = OutputLocationOrErr->DWARFFile;
if (NeedsTempFiles) {
TempFiles.emplace_back(Map->getTriple().getArchName().str());
auto E = TempFiles.back().createTempFile();
if (E) {
WithColor::error() << toString(std::move(E));
AllOK.fetch_and(false);
return;
}
auto &TempFile = *(TempFiles.back().File);
OS = std::make_shared<raw_fd_ostream>(TempFile.FD,
/*shouldClose*/ false);
OutputFile = TempFile.TmpName;
} else {
std::error_code EC;
OS = std::make_shared<raw_fd_ostream>(
Options.LinkOpts.NoOutput ? "-" : OutputFile, EC,
sys::fs::OF_None);
if (EC) {
WithColor::error() << OutputFile << ": " << EC.message();
AllOK.fetch_and(false);
return;
}
}
auto LinkLambda = [&,
OutputFile](std::shared_ptr<raw_fd_ostream> Stream) {
DwarfLinkerForBinary Linker(*Stream, BinHolder, Options.LinkOpts,
ErrorHandlerMutex);
AllOK.fetch_and(Linker.link(*Map));
Stream->flush();
if (flagIsSet(Options.Verify, DWARFVerify::Output) ||
(flagIsSet(Options.Verify, DWARFVerify::OutputOnValidInput) &&
!Linker.InputVerificationFailed())) {
AllOK.fetch_and(verifyOutput(
OutputFile, Map->getTriple().getArchName(), Options));
}
};
// FIXME: The DwarfLinker can have some very deep recursion that can max
// out the (significantly smaller) stack when using threads. We don't
// want this limitation when we only have a single thread.
if (S.ThreadsRequested == 1)
LinkLambda(OS);
else
Threads.async(LinkLambda, OS);
}
Threads.wait();
});
if (Crashed)
(*Repro)->generate();
if (!AllOK)
return EXIT_FAILURE;
if (NeedsTempFiles) {
const bool Fat64 = Options.LinkOpts.Fat64;
if (!Fat64) {
// Universal Mach-O files can't have an archicture slice that starts
// beyond the 4GB boundary. "lipo" can create a 64 bit universal
// header, but not all tools can parse these files so we want to return
// an error if the file can't be encoded as a file with a 32 bit
// universal header. To detect this, we check the size of each
// architecture's skinny Mach-O file and add up the offsets. If they
// exceed 4GB, then we return an error.
// First we compute the right offset where the first architecture will
// fit followin the 32 bit universal header. The 32 bit universal header
// starts with a uint32_t magic and a uint32_t number of architecture
// infos. Then it is followed by 5 uint32_t values for each
// architecture. So we set the start offset to the right value so we can
// calculate the exact offset that the first architecture slice can
// start at.
constexpr uint64_t MagicAndCountSize = 2 * 4;
constexpr uint64_t UniversalArchInfoSize = 5 * 4;
uint64_t FileOffset =
MagicAndCountSize + UniversalArchInfoSize * TempFiles.size();
for (const auto &File : TempFiles) {
ErrorOr<vfs::Status> stat = Options.LinkOpts.VFS->status(File.path());
if (!stat)
break;
if (FileOffset > UINT32_MAX) {
WithColor::error()
<< formatv("the universal binary has a slice with a starting "
"offset ({0:x}) that exceeds 4GB and will produce "
"an invalid Mach-O file. Use the -fat64 flag to "
"generate a universal binary with a 64-bit header "
"but note that not all tools support this format.",
FileOffset);
return EXIT_FAILURE;
}
FileOffset += stat->getSize();
}
}
if (!MachOUtils::generateUniversalBinary(
TempFiles, OutputLocationOrErr->DWARFFile, Options.LinkOpts,
SDKPath, Fat64))
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}