[lld-macho] Add support for -image_base, -static, -pagezero_size, and -version_load_command

[Link1J]

Summary

This adds the -image_base, -static, -pagezero_size, and -version_load_command.

-image_base, -static, and -pagezero_size commonly used for kernel development. So I don't know how useful these will be to most people, but I do believe that having lld be a more complete replacement for the Apple linker is a good thing.

-image_base sets the virtual address of the first section, changing the starting address the binary is loaded at. Basically the same thing as /BASE from link and lld-link.

-pagezero_size changes the __PAGEZERO size, removing that segment if it is set to zero. I personally have no idea what __PAGEZERO is for, but it isn't useful with a custom image base.

-static does alot. It changes the entry point command from LC_MAIN to LC_UNIXTHREAD. It also stops the LC_BUILD_VERSION, LC_VERSION_MIN_*, LC_LOAD_DYLINKER, LC_DATA_IN_CODE, and LC_FUNCTION_STARTS commands from being added to the binary. It appears that -function_starts and -version_load_command readds their respective commands to the binary, so -static only changes the default for commands.

-version_load_command adds LC_BUILD_VERSION or LC_VERSION_MIN_* when -static is used. It got added because it was easy to add as I was doing -static. I only learnt about -version_load_command from reading the Makefiles for the XNU kernel used in macOS. Maybe in the future, it can be extended to control which version command gets added, but that is far beyond what I intended to do.

[Link1J]

For some reason, I am ending up with diffs that use CRLF instead of LF.

[smeenai]

Thanks for the contribution :)

You should add tests for all of these changes. Our tests are in lld/test/MachO. If you haven't worked with LLVM's test system before, there's overviews of lit, FileCheck, and a general testing guide. check-lld-macho is the build target for our tests.

I'll let others take a look at the code changes in detail, but the high-level idea seems good to me.

[int3]

Neat, thanks for implementing all these! As @smeenai said, we definitely need tests :)

Also, could you break up the diff to make review easier? I think each flag merits its own diff

lld/MachO/Config.h

100

we haven't been super consistent about this, but it would be nice to keep the Configuration struct organized by field type. E.g. addLoadVersion could go here

lld/MachO/Writer.cpp

49

from what I understand, -image_base should control the address of the mach header, but setting addr here means that we're setting the start address of __PAGEZERO instead, which doesn't seem right

Also, I wonder what happens when -image_base points to an address within the __PAGEZERO segment...

316

no need for llvm::

[Link1J]

lld/MachO/Writer.cpp

49

From the testing I had done, I thought it was setting the start address for __PAGEZERO. I did more testing, and found it is not.

And if -image_base is inside the __PAGEZERO, it prints out the section list, says the last non __LINKEDIT section overlaps the __PAGEZERO, and doesn't output anything. I think we could do better, because ld64 error message doesn't even say error anywhere in it.

[Link1J]

In D118570#3283061, @int3 wrote:

Also, could you break up the diff to make review easier? I think each flag merits its own diff

As in submitting multiple revisions for review? Sorry if the question seems dumb, but this is the first time I have use Phabricator.

[thakis]

In D118570#3283956, @Link1J wrote:

In D118570#3283061, @int3 wrote:

Also, could you break up the diff to make review easier? I think each flag merits its own diff

As in submitting multiple revisions for review? Sorry if the question seems dumb, but this is the first time I have use Phabricator.

Right.

[MaskRay]

lld/MachO/Config.h

192

initialize to zero

lld/MachO/Writer.cpp

856

Prefer if (xxx) to if (!xxx) if both then and else branches are needed.

lld/include/lld/Common/Args.h

34

Default is a leftover when the variable naming switches to lowerCase. Perhaps defaultVal

[int3]

clearing queue

lld/Common/Args.cpp

int64_t lld::args::getInteger(opt::InputArgList &args, unsigned key,
   return ::getInteger(args, key, Default, 10);
 }
 
 int64_t lld::args::getHex(opt::InputArgList &args, unsigned key,
                           int64_t Default) {
   return ::getInteger(args, key, Default, 16);
 }
 
+uint64_t lld::args::getHexUnsigned(opt::InputArgList &args, unsigned key,
+                                   uint64_t Default) {
+  auto *a = args.getLastArg(key);
+  if (!a)
+    return Default;
+
+  uint64_t v;
+  StringRef s = a->getValue();
+  if (s.startswith("0x") || s.startswith("0X"))
+    s = s.drop_front(2);
+  if (to_integer(s, v, 16))
+    return v;
+
+  StringRef spelling = args.getArgString(a->getIndex());
+  error(spelling + ": number expected, but got '" + a->getValue() + "'");
+  return 0;
+}
+
 std::vector<StringRef> lld::args::getStrings(opt::InputArgList &args, int id) {
   std::vector<StringRef> v;
   for (auto *arg : args.filtered(id))
     v.push_back(arg->getValue());
   return v;
 }
 
 uint64_t lld::args::getZOptionValue(opt::InputArgList &args, int id,

lld/MachO/Arch/ARM.cpp

 
 ARM::ARM(uint32_t cpuSubtype) : TargetInfo(ILP32()) {
   cpuType = CPU_TYPE_ARM;
   this->cpuSubtype = cpuSubtype;
 
   stubSize = 0 /* FIXME */;
   stubHelperHeaderSize = 0 /* FIXME */;
   stubHelperEntrySize = 0 /* FIXME */;
+
+  threadCommandFlavor = ARM_THREAD_STATE;
 }
 
 TargetInfo *macho::createARMTargetInfo(uint32_t cpuSubtype) {
   static ARM t(cpuSubtype);
   return &t;
 }

lld/MachO/Arch/ARM64.cpp

ARM64::ARM64() : ARM64Common(LP64()) {
   // Branch immediate is two's complement 26 bits, which is implicitly
   // multiplied by 4 (since all functions are 4-aligned: The branch range
   // is -4*(2**(26-1))..4*(2**(26-1) - 1).
   backwardBranchRange = 128 * 1024 * 1024;
   forwardBranchRange = backwardBranchRange - 4;
 
   stubHelperHeaderSize = sizeof(stubHelperHeaderCode);
   stubHelperEntrySize = sizeof(stubHelperEntryCode);
+
+  threadCommandFlavor = ARM_THREAD_STATE64;
 }
 
 TargetInfo *macho::createARM64TargetInfo() {
   static ARM64 t;
   return &t;
 }

lld/MachO/Arch/X86_64.cpp

 
 X86_64::X86_64() : TargetInfo(LP64()) {
   cpuType = CPU_TYPE_X86_64;
   cpuSubtype = CPU_SUBTYPE_X86_64_ALL;
 
   stubSize = sizeof(stub);
   stubHelperHeaderSize = sizeof(stubHelperHeader);
   stubHelperEntrySize = sizeof(stubHelperEntry);
+
+  threadCommandFlavor = x86_THREAD_STATE64;
 }
 
 TargetInfo *macho::createX86_64TargetInfo() {
   static X86_64 t;
   return &t;
 }

lld/MachO/Config.h

public:
   void insert(llvm::StringRef symbolName);
   bool matchLiteral(llvm::StringRef symbolName) const;
   bool matchGlob(llvm::StringRef symbolName) const;
   bool match(llvm::StringRef symbolName) const;
 };
 
 struct Configuration {
   Symbol *entry = nullptr;
   bool hasReexports = false;
   bool allLoad = false;
   bool applicationExtension = false;
   bool archMultiple = false;
   bool exportDynamic = false;
   bool forceLoadObjC = false;
   bool forceLoadSwift = false;
   bool staticLink = false;
   bool implicitDylibs = false;
struct Configuration {
 
   SymbolPatterns exportedSymbols;
   SymbolPatterns unexportedSymbols;
 
   bool zeroModTime = false;
 
   llvm::StringRef osoPrefix;
 
+  llvm::Optional<uint64_t> pagezeroSize;
+  bool addLoadVersion = true;
+  uint64_t imageBase;
+
   llvm::MachO::Architecture arch() const { return platformInfo.target.Arch; }
 
   llvm::MachO::PlatformType platform() const {
     return platformInfo.target.Platform;
   }
 };
 
 // The symbol with the highest priority should be ordered first in the output

lld/MachO/Driver.cpp

 // Has the side-effect of setting Config::target.
 static TargetInfo *createTargetInfo(InputArgList &args) {
   StringRef archName = args.getLastArgValue(OPT_arch);
   if (archName.empty()) {
     error("must specify -arch");
     return nullptr;
   }
 
+  if (args.hasArg(OPT_pagezero_size))
+    config->pagezeroSize = args::getHex(args, OPT_pagezero_size, 0);
+
   PlatformType platform = parsePlatformVersion(args);
   config->platformInfo.target =
       MachO::Target(getArchitectureFromName(archName), platform);
 
   uint32_t cpuType;
   uint32_t cpuSubtype;
   std::tie(cpuType, cpuSubtype) = getCPUTypeFromArchitecture(config->arch());
 
bool macho::link(ArrayRef<const char *> argsArr, llvm::raw_ostream &stdoutOS,
   config->applicationExtension = args.hasFlag(
       OPT_application_extension, OPT_no_application_extension, false);
   config->exportDynamic = args.hasArg(OPT_export_dynamic);
   config->forceLoadObjC = args.hasArg(OPT_ObjC);
   config->forceLoadSwift = args.hasArg(OPT_force_load_swift_libs);
   config->deadStripDylibs = args.hasArg(OPT_dead_strip_dylibs);
   config->demangle = args.hasArg(OPT_demangle);
   config->implicitDylibs = !args.hasArg(OPT_no_implicit_dylibs);
-  config->emitFunctionStarts =
-      args.hasFlag(OPT_function_starts, OPT_no_function_starts, true);
   config->emitBitcodeBundle = args.hasArg(OPT_bitcode_bundle);
   config->emitDataInCodeInfo =
       args.hasFlag(OPT_data_in_code_info, OPT_no_data_in_code_info, true);
   config->icfLevel = getICFLevel(args);
   config->dedupLiterals =
       args.hasFlag(OPT_deduplicate_literals, OPT_icf_eq, false) ||
       config->icfLevel != ICFLevel::none;
   config->warnDylibInstallName = args.hasFlag(
if (config->outputType != MH_DYLIB)
       warn("-mark_dead_strippable_dylib: ignored, only has effect with -dylib");
     else
       config->markDeadStrippableDylib = true;
   }
 
   if (const Arg *arg = args.getLastArg(OPT_static, OPT_dynamic))
     config->staticLink = (arg->getOption().getID() == OPT_static);
 
+  config->addLoadVersion =
+      args.hasFlag(OPT_version_load_command, OPT_INVALID, !config->staticLink);
+  config->emitFunctionStarts = args.hasFlag(
+      OPT_function_starts, OPT_no_function_starts, !config->staticLink);
+  config->imageBase = args::getHexUnsigned(args, OPT_image_base, /*Default=*/0);
+
   if (const Arg *arg =
           args.getLastArg(OPT_flat_namespace, OPT_twolevel_namespace))
     config->namespaceKind = arg->getOption().getID() == OPT_twolevel_namespace
                                 ? NamespaceKind::twolevel
                                 : NamespaceKind::flat;
 
   config->undefinedSymbolTreatment = getUndefinedSymbolTreatment(args);
 

lld/MachO/Options.td

def dylinker : Flag<["-"], "dylinker">,
     HelpText<"Produce a dylinker only used when building dyld">,
     Flags<[HelpHidden]>,
     Group<grp_kind>;
 def dynamic : Flag<["-"], "dynamic">,
     HelpText<"Link dynamically (default)">,
     Group<grp_kind>;
 def static : Flag<["-"], "static">,
     HelpText<"Link statically">,
-    Flags<[HelpHidden]>,
     Group<grp_kind>;
 def preload : Flag<["-"], "preload">,
     HelpText<"Produce an unsegmented binary for embedded systems">,
     Flags<[HelpHidden]>,
     Group<grp_kind>;
 def arch : Separate<["-"], "arch">,
     MetaVarName<"<arch_name>">,
     HelpText<"The architecture (e.g. ppc, ppc64, i386, x86_64)">,
def no_order_inits : Flag<["-"], "no_order_inits">,
     Group<grp_opts>;
 def no_order_data : Flag<["-"], "no_order_data">,
     HelpText<"Disable default reordering of global data accessed at launch time">,
     Flags<[HelpHidden]>,
     Group<grp_opts>;
 def image_base : Separate<["-"], "image_base">,
     MetaVarName<"<address>">,
     HelpText<"Preferred hex load address for a dylib or bundle.">,
-    Flags<[HelpHidden]>,
     Group<grp_opts>;
 def seg1addr : Separate<["-"], "seg1addr">,
     MetaVarName<"<address>">,
     Alias<image_base>,
     HelpText<"Alias for -image_base">,
     Flags<[HelpHidden]>,
     Group<grp_opts>;
 def no_implicit_dylibs : Flag<["-"], "no_implicit_dylibs">,
def pie : Flag<["-"], "pie">,
     HelpText<"Build a position independent executable (default)">,
     Group<grp_main>;
 def no_pie : Flag<["-"], "no_pie">,
     HelpText<"Do not build a position independent executable">,
     Group<grp_main>;
 def pagezero_size : Separate<["-"], "pagezero_size">,
     MetaVarName<"<size>">,
     HelpText<"Size of unreadable segment at address zero is hex <size> (default is 4KB on 32-bit and 4GB on 64-bit)">,
-    Flags<[HelpHidden]>,
     Group<grp_main>;
 def stack_size : Separate<["-"], "stack_size">,
     MetaVarName<"<size>">,
     HelpText<"Maximum hex stack size for the main thread in a program. (default is 8MB)">,
     Flags<[HelpHidden]>,
     Group<grp_main>;
 def allow_stack_execute : Flag<["-"], "allow_stack_execute">,
     HelpText<"Mark stack segment as executable">,
def threaded_starts_section : Flag<["-"], "threaded_starts_section">,
     Flags<[HelpHidden]>,
     Group<grp_undocumented>;
 def verbose_optimization_hints : Flag<["-"], "verbose_optimization_hints">,
     HelpText<"This option is undocumented in ld64">,
     Flags<[HelpHidden]>,
     Group<grp_undocumented>;
 def version_load_command : Flag<["-"], "version_load_command">,
     HelpText<"This option is undocumented in ld64">,
-    Flags<[HelpHidden]>,
     Group<grp_undocumented>;
 
 def grp_ignored : OptionGroup<"ignored">, HelpText<"IGNORED">;
 
 def M : Flag<["-"], "M">,
     HelpText<"This option is ignored in ld64">,
     Flags<[HelpHidden]>,
     Group<grp_ignored>;

lld/MachO/SyntheticSections.h

 };
 
 // A hidden section that exists solely for the purpose of creating the
 // __PAGEZERO segment, which is used to catch null pointer dereferences.
 class PageZeroSection final : public SyntheticSection {
 public:
   PageZeroSection();
   bool isHidden() const override { return true; }
+  bool isNeeded() const override { return target->pageZeroSize != 0; }
   uint64_t getSize() const override { return target->pageZeroSize; }
   uint64_t getFileSize() const override { return 0; }
   void writeTo(uint8_t *buf) const override {}
 };
 
 // This is the base class for the GOT and TLVPointer sections, which are nearly
 // functionally identical -- they will both be populated by dyld with addresses
 // to non-lazily-loaded dylib symbols. The main difference is that the

lld/MachO/Target.h

 //===- Target.h -------------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_MACHO_TARGET_H
 #define LLD_MACHO_TARGET_H
 
+#include "Config.h"
 #include "MachOStructs.h"
 #include "Relocations.h"
 
 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 #include <cstddef>

 class InputSection;
 
 class TargetInfo {
 public:
   template <class LP> TargetInfo(LP) {
     // Having these values available in TargetInfo allows us to access them
     // without having to resort to templates.
     magic = LP::magic;
-    pageZeroSize = LP::pageZeroSize;
+    pageZeroSize = config->pagezeroSize.getValueOr(LP::pageZeroSize);
     headerSize = sizeof(typename LP::mach_header);
     wordSize = LP::wordSize;
   }
 
   virtual ~TargetInfo() = default;
 
   // Validate the relocation structure and get its addend.
   virtual int64_t
public:
   size_t stubHelperHeaderSize;
   size_t stubHelperEntrySize;
   size_t wordSize;
 
   size_t thunkSize = 0;
   uint64_t forwardBranchRange = 0;
   uint64_t backwardBranchRange = 0;
 
+  uint32_t threadCommandFlavor = 0;
+
   // We contrive this value as sufficiently far from any valid address that it
   // will always be out-of-range for any architecture. UINT64_MAX is not a
   // good choice because it is (a) only 1 away from wrapping to 0, and (b) the
   // tombstone value for DenseMap<> and caused weird assertions for me.
   static constexpr uint64_t outOfRangeVA = 0xfull << 60;
 };
 
 TargetInfo *createX86_64TargetInfo();

lld/MachO/Writer.cpp

 using namespace lld;
 using namespace lld::macho;
 
 namespace {
 class LCUuid;
 
 class Writer {
 public:
-  Writer() : buffer(errorHandler().outputBuffer) {}
+  Writer() : buffer(errorHandler().outputBuffer), addr(config->imageBase) {}
 
   void treatSpecialUndefineds();
   void scanRelocations();
   void scanSymbols();
   template <class LP> void createOutputSections();
   template <class LP> void createLoadCommands();
   void finalizeAddresses();
   void finalizeLinkEditSegment();
if (config->entry->isInStubs())
           in.stubs->fileOff + config->entry->stubsIndex * target->stubSize;
     else
       c->entryoff = config->entry->getVA() - in.header->addr;
 
     c->stacksize = 0;
   }
 };
 
+class LCUnixThread final : public LoadCommand {
+  uint32_t getFlavorSize() const {
+    switch (target->cpuType & ~CPU_ARCH_MASK) {
+    case CPU_TYPE_I386:
+      switch (target->threadCommandFlavor) {
+      case x86_THREAD_STATE32:
+        return sizeof(x86_thread_state32_t);
+      case x86_THREAD_STATE64:
+        return sizeof(x86_thread_state64_t);
+      }
+      break;
+    case CPU_TYPE_ARM:
+      switch (target->threadCommandFlavor) {
+      case ARM_THREAD_STATE:
+        return sizeof(arm_thread_state32_t);
+      case ARM_THREAD_STATE64:
+        return sizeof(arm_thread_state64_t);
+      }
+      break;
+    }
+
+    fatal("Unknown flavor " +
+          llvm::Twine::utohexstr(target->threadCommandFlavor));
+    return 0;
+  }
+
+  uint32_t getSize() const override {
+    return sizeof(thread_command) + sizeof(x86_state_hdr_t) + getFlavorSize();
+  }
+
+  template <class return_type>
+  return_type *get_thread_state(uint8_t *buf) const {
+    constexpr auto offset = sizeof(thread_command) + sizeof(x86_state_hdr_t);
+    auto *state = reinterpret_cast<return_type *>(buf + offset);
+    return state;
+  };
+
+  void writeTo(uint8_t *buf) const override {
+    auto *c = reinterpret_cast<thread_command *>(buf);
+    c->cmd = LC_UNIXTHREAD;
+    c->cmdsize = getSize();
+
+    auto *hdr =
+        reinterpret_cast<x86_state_hdr_t *>(buf + sizeof(thread_command));
+    hdr->flavor = target->threadCommandFlavor;
+
+    // Yes, this is what the macOS SDK does.
+    hdr->count = getFlavorSize() / sizeof(uint32_t);
+    memset(get_thread_state<uint8_t>(buf), 0, getFlavorSize());
+
+    switch (target->cpuType & ~CPU_ARCH_MASK) {
+    case CPU_TYPE_I386:
+      switch (target->threadCommandFlavor) {
+      case x86_THREAD_STATE32: {
+        auto *state = get_thread_state<x86_thread_state32_t>(buf);
+        state->eip = config->entry->getVA();
+        break;
+      }
+      case x86_THREAD_STATE64: {
+        auto *state = get_thread_state<x86_thread_state64_t>(buf);
+        state->rip = config->entry->getVA();
+        break;
+      }
+      }
+      break;
+    case CPU_TYPE_ARM:
+      switch (target->threadCommandFlavor) {
+      case ARM_THREAD_STATE: {
+        auto *state = get_thread_state<arm_thread_state32_t>(buf);
+        state->pc = config->entry->getVA();
+        break;
+      }
+      case ARM_THREAD_STATE64: {
+        auto *state = get_thread_state<arm_thread_state64_t>(buf);
+        state->pc = config->entry->getVA();
+        break;
+      }
+      }
+      break;
+    }
+  }
+};
+
 class LCSymtab final : public LoadCommand {
 public:
   LCSymtab(SymtabSection *symtabSection, StringTableSection *stringTableSection)
       : symtabSection(symtabSection), stringTableSection(stringTableSection) {}
 
   uint32_t getSize() const override { return sizeof(symtab_command); }
 
   void writeTo(uint8_t *buf) const override {
if (!config->umbrella.empty())
     in.header->addLoadCommand(make<LCSubFramework>(config->umbrella));
   if (config->emitEncryptionInfo)
     in.header->addLoadCommand(make<LCEncryptionInfo<LP>>());
   for (StringRef path : config->runtimePaths)
     in.header->addLoadCommand(make<LCRPath>(path));
 
   switch (config->outputType) {
   case MH_EXECUTE:
+    if (!config->staticLink)
       in.header->addLoadCommand(make<LCLoadDylinker>());
     break;
   case MH_DYLIB:
     in.header->addLoadCommand(make<LCDylib>(LC_ID_DYLIB, config->installName,
                                             config->dylibCompatibilityVersion,
                                             config->dylibCurrentVersion));
     break;
   case MH_BUNDLE:
     break;
   default:
     llvm_unreachable("unhandled output file type");
   }
 
   uuidCommand = make<LCUuid>();
   in.header->addLoadCommand(uuidCommand);
 
+  if (config->addLoadVersion) {
     if (useLCBuildVersion(config->platformInfo))
       in.header->addLoadCommand(make<LCBuildVersion>(config->platformInfo));
     else
       in.header->addLoadCommand(make<LCMinVersion>(config->platformInfo));
+  }
 
   // This is down here to match ld64's load command order.
-  if (config->outputType == MH_EXECUTE)
+  if (config->outputType == MH_EXECUTE) {
+    if (!config->staticLink)
       in.header->addLoadCommand(make<LCMain>());
+    else
+      in.header->addLoadCommand(make<LCUnixThread>());
+  }
 
   int64_t dylibOrdinal = 1;
   DenseMap<StringRef, int64_t> ordinalForInstallName;
   for (InputFile *file : inputFiles) {
     if (auto *dylibFile = dyn_cast<DylibFile>(file)) {
       if (dylibFile->isBundleLoader) {
         dylibFile->ordinal = BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE;
         // Shortcut since bundle-loader does not re-export the symbols.
if (auto *dylibFile = dyn_cast<DylibFile>(file)) {
       if (dylibFile->reexport)
         in.header->addLoadCommand(
             make<LCDylib>(LC_REEXPORT_DYLIB, dylibFile->installName));
     }
   }
 
   if (functionStartsSection)
     in.header->addLoadCommand(make<LCFunctionStarts>(functionStartsSection));
-  if (dataInCodeSection)
+  if (dataInCodeSection && !config->staticLink)
     in.header->addLoadCommand(make<LCDataInCode>(dataInCodeSection));
   if (codeSignatureSection)
     in.header->addLoadCommand(make<LCCodeSignature>(codeSignatureSection));
 
   const uint32_t MACOS_MAXPATHLEN = 1024;
   config->headerPad = std::max(
       config->headerPad, (config->headerPadMaxInstallNames
                               ? LCDylib::getInstanceCount() * MACOS_MAXPATHLEN

lld/include/lld/Common/Args.h

 
 llvm::CodeGenOpt::Level getCGOptLevel(int optLevelLTO);
 
 int64_t getInteger(llvm::opt::InputArgList &args, unsigned key,
                    int64_t Default);
 
 int64_t getHex(llvm::opt::InputArgList &args, unsigned key, int64_t Default);
 
+uint64_t getHexUnsigned(llvm::opt::InputArgList &args, unsigned key,
+                        uint64_t Default);
+
 std::vector<StringRef> getStrings(llvm::opt::InputArgList &args, int id);
 
 uint64_t getZOptionValue(llvm::opt::InputArgList &args, int id, StringRef key,
                          uint64_t Default);
 
 std::vector<StringRef> getLines(MemoryBufferRef mb);
 
 StringRef getFilenameWithoutExe(StringRef path);
 
 } // namespace args
 } // namespace lld
 
 #endif