[lld-macho][nfc] Add accessors for commonly-used PlatformInfo fields

[int3]

Summary

As discussed here: https://reviews.llvm.org/D100523#inline-951543

[thakis]

lg

[alexander-shaposhnikov]

thanks!

lld/MachO/Config.h

struct Configuration {
   std::vector<SegmentProtection> segmentProtections;
 
   llvm::DenseMap<llvm::StringRef, SymbolPriorityEntry> priorities;
   SectionRenameMap sectionRenameMap;
   SegmentRenameMap segmentRenameMap;
 
   SymbolPatterns exportedSymbols;
   SymbolPatterns unexportedSymbols;
+
+  llvm::MachO::Architecture arch() const { return platformInfo.target.Arch; }
+
+  llvm::MachO::PlatformKind platform() const {
+    return platformInfo.target.Platform;
+  }
 };
 
 // The symbol with the highest priority should be ordered first in the output
 // section (modulo input section contiguity constraints). Using priority
 // (highest first) instead of order (lowest first) has the convenient property
 // that the default-constructed zero priority -- for symbols/sections without a
 // user-defined order -- naturally ends up putting them at the end of the
 // output.

lld/MachO/Driver.cpp

static TargetInfo *createTargetInfo(InputArgList &args) {
   StringRef archName = args.getLastArgValue(OPT_arch);
   if (archName.empty())
     fatal("must specify -arch");
   PlatformKind platform = parsePlatformVersion(args);
 
   config->platformInfo.target =
       MachO::Target(getArchitectureFromName(archName), platform);
 
-  switch (getCPUTypeFromArchitecture(config->platformInfo.target.Arch).first) {
+  switch (getCPUTypeFromArchitecture(config->arch()).first) {
   case CPU_TYPE_X86_64:
     return createX86_64TargetInfo();
   case CPU_TYPE_ARM64:
     return createARM64TargetInfo();
   case CPU_TYPE_ARM64_32:
     return createARM64_32TargetInfo();
   default:
     fatal("missing or unsupported -arch " + archName);
static const char *getReproduceOption(InputArgList &args) {
   if (const Arg *arg = args.getLastArg(OPT_reproduce))
     return arg->getValue();
   return getenv("LLD_REPRODUCE");
 }
 
 static bool isPie(InputArgList &args) {
   if (config->outputType != MH_EXECUTE || args.hasArg(OPT_no_pie))
     return false;
-  if (config->platformInfo.target.Arch == AK_arm64 ||
-      config->platformInfo.target.Arch == AK_arm64e ||
-      config->platformInfo.target.Arch == AK_arm64_32)
+  if (config->arch() == AK_arm64 || config->arch() == AK_arm64e ||
+      config->arch() == AK_arm64_32)
     return true;
 
   // TODO: add logic here as we support more archs. E.g. i386 should default
   // to PIE from 10.7
-  assert(config->platformInfo.target.Arch == AK_x86_64 ||
-         config->platformInfo.target.Arch == AK_x86_64h ||
-         config->platformInfo.target.Arch == AK_arm64_32);
+  assert(config->arch() == AK_x86_64 || config->arch() == AK_x86_64h ||
+         config->arch() == AK_arm64_32);
 
   PlatformKind kind = config->platformInfo.target.Platform;
   if (kind == PlatformKind::macOS &&
       config->platformInfo.minimum >= VersionTuple(10, 6))
     return true;
 
   if (kind == PlatformKind::iOSSimulator || kind == PlatformKind::driverKit)
     return true;
bool macho::link(ArrayRef<const char *> argsArr, bool canExitEarly,
   config->forceLoadObjC = args.hasArg(OPT_ObjC);
   config->demangle = args.hasArg(OPT_demangle);
   config->implicitDylibs = !args.hasArg(OPT_no_implicit_dylibs);
   config->emitFunctionStarts = !args.hasArg(OPT_no_function_starts);
   config->emitBitcodeBundle = args.hasArg(OPT_bitcode_bundle);
 
   std::array<PlatformKind, 3> encryptablePlatforms{
       PlatformKind::iOS, PlatformKind::watchOS, PlatformKind::tvOS};
-  config->emitEncryptionInfo = args.hasFlag(
-      OPT_encryptable, OPT_no_encryption,
-      is_contained(encryptablePlatforms, config->platformInfo.target.Platform));
+  config->emitEncryptionInfo =
+      args.hasFlag(OPT_encryptable, OPT_no_encryption,
+                   is_contained(encryptablePlatforms, config->platform()));
 
 #ifndef HAVE_LIBXAR
   if (config->emitBitcodeBundle)
     error("-bitcode_bundle unsupported because LLD wasn't built with libxar");
 #endif
 
   if (const Arg *arg = args.getLastArg(OPT_install_name)) {
     if (config->outputType != MH_DYLIB)
for (const Arg *arg : args.filtered(OPT_rename_segment)) {
     config->segmentRenameMap[validName(arg->getValue(0))] =
         validName(arg->getValue(1));
   }
 
   for (const Arg *arg : args.filtered(OPT_segprot)) {
     StringRef segName = arg->getValue(0);
     uint32_t maxProt = parseProtection(arg->getValue(1));
     uint32_t initProt = parseProtection(arg->getValue(2));
-    if (maxProt != initProt && config->platformInfo.target.Arch != AK_i386)
+    if (maxProt != initProt && config->arch() != AK_i386)
       error("invalid argument '" + arg->getAsString(args) +
             "': max and init must be the same for non-i386 archs");
     if (segName == segment_names::linkEdit)
       error("-segprot cannot be used to change __LINKEDIT's protections");
     config->segmentProtections.push_back({segName, maxProt, initProt});
   }
 
   handleSymbolPatterns(args, config->exportedSymbols, OPT_exported_symbol,
                        OPT_exported_symbols_list);
   handleSymbolPatterns(args, config->unexportedSymbols, OPT_unexported_symbol,
                        OPT_unexported_symbols_list);
   if (!config->exportedSymbols.empty() && !config->unexportedSymbols.empty()) {
     error("cannot use both -exported_symbol* and -unexported_symbol* options\n"
           ">>> ignoring unexports");
     config->unexportedSymbols.clear();
   }
 
   config->saveTemps = args.hasArg(OPT_save_temps);
 
   config->adhocCodesign = args.hasFlag(
       OPT_adhoc_codesign, OPT_no_adhoc_codesign,
-      (config->platformInfo.target.Arch == AK_arm64 ||
-       config->platformInfo.target.Arch == AK_arm64e) &&
-          config->platformInfo.target.Platform == PlatformKind::macOS);
+      (config->arch() == AK_arm64 || config->arch() == AK_arm64e) &&
+          config->platform() == PlatformKind::macOS);
 
   if (args.hasArg(OPT_v)) {
     message(getLLDVersion());
     message(StringRef("Library search paths:") +
             (config->librarySearchPaths.empty()
                  ? ""
                  : "\n\t" + join(config->librarySearchPaths, "\n\t")));
     message(StringRef("Framework search paths:") +

lld/MachO/InputFiles.cpp

static Optional<PlatformInfo> getPlatformInfo(const InputFile *input) {
   return None;
 }
 
 template <class LP> static bool checkCompatibility(const InputFile *input) {
   Optional<PlatformInfo> platformInfo = getPlatformInfo<LP>(input);
   if (!platformInfo)
     return true;
   // TODO: Correctly detect simulator platforms or relax this check.
-  if (config->platformInfo.target.Platform != platformInfo->target.Platform) {
+  if (config->platform() != platformInfo->target.Platform) {
     error(toString(input) + " has platform " +
           getPlatformName(platformInfo->target.Platform) +
           Twine(", which is different from target platform ") +
-          getPlatformName(config->platformInfo.target.Platform));
+          getPlatformName(config->platform()));
     return false;
   }
   if (platformInfo->minimum >= config->platformInfo.minimum)
     return true;
   error(toString(input) + " has version " +
         platformInfo->minimum.getAsString() +
         ", which is incompatible with target version of " +
         config->platformInfo.minimum.getAsString());
template <class LP> void ObjFile::parse() {
   using SegmentCommand = typename LP::segment_command;
   using Section = typename LP::section;
   using NList = typename LP::nlist;
 
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
   auto *hdr = reinterpret_cast<const Header *>(mb.getBufferStart());
 
   Architecture arch = getArchitectureFromCpuType(hdr->cputype, hdr->cpusubtype);
-  if (arch != config->platformInfo.target.Arch) {
+  if (arch != config->arch()) {
     error(toString(this) + " has architecture " + getArchitectureName(arch) +
           " which is incompatible with target architecture " +
-          getArchitectureName(config->platformInfo.target.Arch));
+          getArchitectureName(config->arch()));
     return;
   }
 
   if (!checkCompatibility<LP>(this))
     return;
 
   if (const load_command *cmd = findCommand(hdr, LC_LINKER_OPTION)) {
     auto *c = reinterpret_cast<const linker_option_command *>(cmd);
DylibFile::DylibFile(const InterfaceFile &interface, DylibFile *umbrella,
   auto addSymbol = [&](const Twine &name) -> void {
     symbols.push_back(symtab->addDylib(saver.save(name), exportingFile,
                                        /*isWeakDef=*/false,
                                        /*isTlv=*/false));
   };
   // TODO(compnerd) filter out symbols based on the target platform
   // TODO: handle weak defs, thread locals
   for (const auto *symbol : interface.symbols()) {
-    if (!symbol->getArchitectures().has(config->platformInfo.target.Arch))
+    if (!symbol->getArchitectures().has(config->arch()))
       continue;
 
     switch (symbol->getKind()) {
     case SymbolKind::GlobalSymbol:
       addSymbol(symbol->getName());
       break;
     case SymbolKind::ObjectiveCClass:
       // XXX ld64 only creates these symbols when -ObjC is passed in. We may

lld/MachO/LTO.cpp

std::vector<ObjFile *> BitcodeCompiler::compile() {
   std::vector<ObjFile *> ret;
   for (unsigned i = 0; i != maxTasks; ++i) {
     if (buf[i].empty())
       continue;
     SmallString<261> filePath("/tmp/lto.tmp");
     uint32_t modTime = 0;
     if (!config->ltoObjPath.empty()) {
       filePath = config->ltoObjPath;
-      path::append(filePath,
-                   Twine(i) + "." +
-                       getArchitectureName(config->platformInfo.target.Arch) +
+      path::append(filePath, Twine(i) + "." +
+                                 getArchitectureName(config->arch()) +
                                  ".lto.o");
       saveBuffer(buf[i], filePath);
       modTime = getModTime(filePath);
     }
     ret.push_back(make<ObjFile>(
         MemoryBufferRef(buf[i], saver.save(filePath.str())), modTime, ""));
   }
 
   return ret;
 }

lld/MachO/MapFile.cpp

if (ec) {
     error("cannot open " + config->mapFile + ": " + ec.message());
     return;
   }
 
   // Dump output path.
   os << format("# Path: %s\n", config->outputFile.str().c_str());
 
   // Dump output architecture.
-  os << format(
-      "# Arch: %s\n",
-      getArchitectureName(config->platformInfo.target.Arch).str().c_str());
+  os << format("# Arch: %s\n",
+               getArchitectureName(config->arch()).str().c_str());
 
   // Dump table of object files.
   os << "# Object files:\n";
   os << format("[%3u] %s\n", 0, (const char *)"linker synthesized");
   uint32_t fileIndex = 1;
   DenseMap<lld::macho::InputFile *, uint32_t> readerToFileOrdinal;
   for (InputFile *file : inputFiles) {
     if (isa<ObjFile>(file)) {

lld/MachO/OutputSegment.cpp

static uint32_t initProt(StringRef name) {
   if (name == segment_names::pageZero)
     return 0;
   if (name == segment_names::linkEdit)
     return VM_PROT_READ;
   return VM_PROT_READ | VM_PROT_WRITE;
 }
 
 static uint32_t maxProt(StringRef name) {
-  assert(config->platformInfo.target.Arch != AK_i386 &&
+  assert(config->arch() != AK_i386 &&
          "TODO: i386 has different maxProt requirements");
   return initProt(name);
 }
 
 size_t OutputSegment::numNonHiddenSections() const {
   size_t count = 0;
   for (const OutputSection *osec : sections)
     count += (!osec->isHidden() ? 1 : 0);

lld/MachO/SyntheticSections.cpp

template <class LP> uint64_t MachHeaderSectionImpl<LP>::getSize() const {
   return size;
 }
 
 static uint32_t cpuSubtype() {
   uint32_t subtype = target->cpuSubtype;
 
   if (config->outputType == MH_EXECUTE && !config->staticLink &&
       target->cpuSubtype == CPU_SUBTYPE_X86_64_ALL &&
-      config->platformInfo.target.Platform == PlatformKind::macOS &&
+      config->platform() == PlatformKind::macOS &&
       config->platformInfo.minimum >= VersionTuple(10, 5))
     subtype |= CPU_SUBTYPE_LIB64;
 
   return subtype;
 }
 
 template <class LP>
 void MachHeaderSectionImpl<LP>::writeTo(uint8_t *buf) const {