[lld-macho][nfc] Remove `MachO::` prefix where possible

[int3]

Summary

Previously, SyntheticSections.cpp did not have a top-level `using namespace
llvm::MachO` because it caused a naming conflict: llvm::MachO::Symbol would
collide with lld::macho::Symbol.

MachO::Symbol represents the symbols defined in InterfaceFiles (TBDs). By
moving the inclusion of InterfaceFile.h into our .cpp files, we can avoid this
name collision in other files where we are only dealing with LLD's own symbols.

Along the way, I removed all unnecessary "MachO::" prefixes in our code.

Cons of this approach: If TextAPI/MachO/Symbol.h gets included via some other
header file in the future, we could run into this collision again.

Alternative 1: Have either TextAPI/MachO or BinaryFormat/MachO.h use a different
namespace. Most of the benefit of using namespace llvm::MachO comes from being
able to use things in BinaryFormat/MachO.h conveniently; if TextAPI was under a
different (and fully-qualified) namespace like llvm::tapi that would solve our
problems. Cons: lots of files across llvm-project will need to be updated, and
folks who own the TextAPI code need to agree to the name change.

Alternative 2: Rename our Symbol to something like LldSymbol. I think this is
ugly.

Personally I think alternative #1 is ideal, but I'm not sure the effort to do it is
worthwhile, this diff's halfway solution seems good enough to me. Thoughts?

[oontvoo]

+1 for the removal of MachO:: prefix where possible.

W.R.T Symbol conflict, IMO, that's what namespaces are for. /shrug. (Agreed that it's probably not worth renaming the tapi Symbol, given the current tooling in llvm- that is to say, there's none :\ )

lld/MachO/InputFiles.cpp

115

lint suggestion: const auto * hdr ?

[int3]

lld/MachO/InputFiles.cpp

115

I think this lint rule needs to be smarter here, repeating const on the same line is silly. But updated to squelch the lint noise.

[int3]

const

[oontvoo]

not sure if you were waiting for someone else to chime in, but this LGTM

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())
     fatal("must specify -arch");
   PlatformKind platform = parsePlatformVersion(args);
 
-  config->target =
-      MachO::Target(MachO::getArchitectureFromName(archName), platform);
+  config->target = Target(getArchitectureFromName(archName), platform);
 
-  switch (MachO::getCPUTypeFromArchitecture(config->target.Arch).first) {
-  case MachO::CPU_TYPE_X86_64:
+  switch (getCPUTypeFromArchitecture(config->target.Arch).first) {
+  case CPU_TYPE_X86_64:
     return createX86_64TargetInfo();
-  case MachO::CPU_TYPE_ARM64:
+  case CPU_TYPE_ARM64:
     return createARM64TargetInfo();
   default:
     fatal("missing or unsupported -arch " + archName);
   }
 }
 
 static UndefinedSymbolTreatment
 getUndefinedSymbolTreatment(const ArgList &args) {

lld/MachO/DriverUtils.cpp

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Path.h"
+#include "llvm/TextAPI/MachO/InterfaceFile.h"
 #include "llvm/TextAPI/MachO/TextAPIReader.h"
 
 using namespace llvm;
 using namespace llvm::MachO;
 using namespace llvm::opt;
 using namespace llvm::sys;
 using namespace lld;
 using namespace lld::macho;

lld/MachO/InputFiles.h

 #include "lld/Common/LLVM.h"
 #include "lld/Common/Memory.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Support/MemoryBuffer.h"
-#include "llvm/TextAPI/MachO/InterfaceFile.h"
 #include "llvm/TextAPI/MachO/TextAPIReader.h"
 
 #include <map>
 #include <vector>
 
 namespace llvm {
 namespace lto {
 class InputFile;
 } // namespace lto
+namespace MachO {
+class InterfaceFile;
+} // namespace MachO
 class TarWriter;
 } // namespace llvm
 
 namespace lld {
 namespace macho {
 
 class InputSection;
 class Symbol;
public:
   // If not empty, this stores the name of the archive containing this file.
   // We use this string for creating error messages.
   std::string archiveName;
 
 protected:
   InputFile(Kind kind, MemoryBufferRef mb)
       : mb(mb), id(idCount++), fileKind(kind), name(mb.getBufferIdentifier()) {}
 
-  InputFile(Kind kind, const llvm::MachO::InterfaceFile &interface)
-      : id(idCount++), fileKind(kind), name(saver.save(interface.getPath())) {}
+  InputFile(Kind, const llvm::MachO::InterfaceFile &);
 
 private:
   const Kind fileKind;
   const StringRef name;
 
   static int idCount;
 };
 

lld/MachO/InputFiles.cpp

 #include "llvm/ADT/iterator.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/LTO/LTO.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TarWriter.h"
 #include "llvm/TextAPI/MachO/Architecture.h"
+#include "llvm/TextAPI/MachO/InterfaceFile.h"
 
 using namespace llvm;
 using namespace llvm::MachO;
 using namespace llvm::support::endian;
 using namespace llvm::sys;
 using namespace lld;
 using namespace lld::macho;
 
Optional<MemoryBufferRef> macho::readFile(StringRef path) {
   }
 
   std::unique_ptr<MemoryBuffer> &mb = *mbOrErr;
   MemoryBufferRef mbref = mb->getMemBufferRef();
   make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take mb ownership
 
   // If this is a regular non-fat file, return it.
   const char *buf = mbref.getBufferStart();
-  auto *hdr = reinterpret_cast<const MachO::fat_header *>(buf);
+  const auto *hdr = reinterpret_cast<const fat_header *>(buf);
   if (mbref.getBufferSize() < sizeof(uint32_t) ||
-      read32be(&hdr->magic) != MachO::FAT_MAGIC) {
+      read32be(&hdr->magic) != FAT_MAGIC) {
     if (tar)
       tar->append(relativeToRoot(path), mbref.getBuffer());
     return mbref;
   }
 
   // Object files and archive files may be fat files, which contains
   // multiple real files for different CPU ISAs. Here, we search for a
   // file that matches with the current link target and returns it as
   // a MemoryBufferRef.
-  auto *arch = reinterpret_cast<const MachO::fat_arch *>(buf + sizeof(*hdr));
+  const auto *arch = reinterpret_cast<const fat_arch *>(buf + sizeof(*hdr));
 
   for (uint32_t i = 0, n = read32be(&hdr->nfat_arch); i < n; ++i) {
     if (reinterpret_cast<const char *>(arch + i + 1) >
         buf + mbref.getBufferSize()) {
       error(path + ": fat_arch struct extends beyond end of file");
       return None;
     }
 
if (tar)
       tar->append(relativeToRoot(path), mbref.getBuffer());
     return MemoryBufferRef(StringRef(buf + offset, size), path.copy(bAlloc));
   }
 
   error("unable to find matching architecture in " + path);
   return None;
 }
 
+InputFile::InputFile(Kind kind, const InterfaceFile &interface)
+    : id(idCount++), fileKind(kind), name(saver.save(interface.getPath())) {}
+
 void ObjFile::parseSections(ArrayRef<section_64> sections) {
   subsections.reserve(sections.size());
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
 
   for (const section_64 &sec : sections) {
     InputSection *isec = make<InputSection>();
     isec->file = this;
     isec->name =

 
 ObjFile::ObjFile(MemoryBufferRef mb, uint32_t modTime, StringRef archiveName)
     : InputFile(ObjKind, mb), modTime(modTime) {
   this->archiveName = std::string(archiveName);
 
   auto *buf = reinterpret_cast<const uint8_t *>(mb.getBufferStart());
   auto *hdr = reinterpret_cast<const mach_header_64 *>(mb.getBufferStart());
 
-  MachO::Architecture arch =
-      MachO::getArchitectureFromCpuType(hdr->cputype, hdr->cpusubtype);
+  Architecture arch = getArchitectureFromCpuType(hdr->cputype, hdr->cpusubtype);
   if (arch != config->target.Arch) {
     error(toString(this) + " has architecture " + getArchitectureName(arch) +
           " which is incompatible with target architecture " +
           getArchitectureName(config->target.Arch));
     return;
   }
 
   if (const auto *cmd =

lld/MachO/InputSection.cpp

for (size_t i = 0; i < relocs.size(); i++) {
     } else if (auto *referentIsec = r.referent.dyn_cast<InputSection *>()) {
       referentVA = referentIsec->getVA();
     }
     target->relocateOne(loc, r, referentVA, getVA() + r.offset);
   }
 }
 
 bool macho::isCodeSection(InputSection *isec) {
-  uint32_t type = isec->flags & MachO::SECTION_TYPE;
+  uint32_t type = isec->flags & SECTION_TYPE;
   if (type != S_REGULAR && type != S_COALESCED)
     return false;
 
-  uint32_t attr = isec->flags & MachO::SECTION_ATTRIBUTES_USR;
+  uint32_t attr = isec->flags & SECTION_ATTRIBUTES_USR;
   if (attr == S_ATTR_PURE_INSTRUCTIONS)
     return true;
 
   if (isec->segname == segment_names::text)
     return StringSwitch<bool>(isec->name)
         .Cases("__textcoal_nt", "__StaticInit", true)
         .Default(false);
 
   return false;
 }
 
 std::string lld::toString(const InputSection *isec) {
   return (toString(isec->file) + ":(" + isec->name + ")").str();
 }

lld/MachO/MergedOutputSection.cpp

for (InputSection *isec : inputs) {
     isec->writeTo(buf + isec->outSecFileOff);
   }
 }
 
 // TODO: this is most likely wrong; reconsider how section flags
 // are actually merged. The logic presented here was written without
 // any form of informed research.
 void MergedOutputSection::mergeFlags(uint32_t inputFlags) {
-  uint8_t sectionFlag = MachO::SECTION_TYPE & inputFlags;
-  if (sectionFlag != (MachO::SECTION_TYPE & flags))
+  uint8_t sectionFlag = SECTION_TYPE & inputFlags;
+  if (sectionFlag != (SECTION_TYPE & flags))
     error("Cannot add merge section; inconsistent type flags " +
           Twine(sectionFlag));
 
-  uint32_t inconsistentFlags =
-      MachO::S_ATTR_DEBUG | MachO::S_ATTR_STRIP_STATIC_SYMS |
-      MachO::S_ATTR_NO_DEAD_STRIP | MachO::S_ATTR_LIVE_SUPPORT;
+  uint32_t inconsistentFlags = S_ATTR_DEBUG | S_ATTR_STRIP_STATIC_SYMS |
+                               S_ATTR_NO_DEAD_STRIP | S_ATTR_LIVE_SUPPORT;
   if ((inputFlags ^ flags) & inconsistentFlags)
     error("Cannot add merge section; cannot merge inconsistent flags");
 
   // Negate pure instruction presence if any section isn't pure.
-  uint32_t pureMask = ~MachO::S_ATTR_PURE_INSTRUCTIONS | (inputFlags & flags);
+  uint32_t pureMask = ~S_ATTR_PURE_INSTRUCTIONS | (inputFlags & flags);
 
   // Merge the rest
   flags |= inputFlags;
   flags &= pureMask;
 }

lld/MachO/SyntheticSections.cpp

 #include "llvm/Support/Path.h"
 #include "llvm/Support/SHA256.h"
 
 #if defined(__APPLE__)
 #include <sys/mman.h>
 #endif
 
 using namespace llvm;
+using namespace llvm::MachO;
 using namespace llvm::support;
 using namespace llvm::support::endian;
 using namespace lld;
 using namespace lld::macho;
 
 InStruct macho::in;
 std::vector<SyntheticSection *> macho::syntheticSections;
 
 SyntheticSection::SyntheticSection(const char *segname, const char *name)
     : OutputSection(SyntheticKind, name), segname(segname) {
   syntheticSections.push_back(this);
 }
 
 // dyld3's MachOLoaded::getSlide() assumes that the __TEXT segment starts
 // from the beginning of the file (i.e. the header).
 MachHeaderSection::MachHeaderSection()
     : SyntheticSection(segment_names::text, section_names::header) {}
 
 void MachHeaderSection::addLoadCommand(LoadCommand *lc) {
   loadCommands.push_back(lc);
   sizeOfCmds += lc->getSize();
 }
 
 uint64_t MachHeaderSection::getSize() const {
-  return sizeof(MachO::mach_header_64) + sizeOfCmds + config->headerPad;
+  return sizeof(mach_header_64) + sizeOfCmds + config->headerPad;
 }
 
 static uint32_t cpuSubtype() {
   uint32_t subtype = target->cpuSubtype;
 
-  if (config->outputType == MachO::MH_EXECUTE && !config->staticLink &&
-      target->cpuSubtype == MachO::CPU_SUBTYPE_X86_64_ALL &&
-      config->target.Platform == MachO::PlatformKind::macOS &&
+  if (config->outputType == MH_EXECUTE && !config->staticLink &&
+      target->cpuSubtype == CPU_SUBTYPE_X86_64_ALL &&
+      config->target.Platform == PlatformKind::macOS &&
       config->platformInfo.minimum >= VersionTuple(10, 5))
-    subtype |= MachO::CPU_SUBTYPE_LIB64;
+    subtype |= CPU_SUBTYPE_LIB64;
 
   return subtype;
 }
 
 void MachHeaderSection::writeTo(uint8_t *buf) const {
-  auto *hdr = reinterpret_cast<MachO::mach_header_64 *>(buf);
-  hdr->magic = MachO::MH_MAGIC_64;
+  auto *hdr = reinterpret_cast<mach_header_64 *>(buf);
+  hdr->magic = MH_MAGIC_64;
   hdr->cputype = target->cpuType;
   hdr->cpusubtype = cpuSubtype();
   hdr->filetype = config->outputType;
   hdr->ncmds = loadCommands.size();
   hdr->sizeofcmds = sizeOfCmds;
-  hdr->flags = MachO::MH_DYLDLINK;
+  hdr->flags = MH_DYLDLINK;
 
   if (config->namespaceKind == NamespaceKind::twolevel)
-    hdr->flags |= MachO::MH_NOUNDEFS | MachO::MH_TWOLEVEL;
+    hdr->flags |= MH_NOUNDEFS | MH_TWOLEVEL;
 
-  if (config->outputType == MachO::MH_DYLIB && !config->hasReexports)
-    hdr->flags |= MachO::MH_NO_REEXPORTED_DYLIBS;
+  if (config->outputType == MH_DYLIB && !config->hasReexports)
+    hdr->flags |= MH_NO_REEXPORTED_DYLIBS;
 
   if (config->markDeadStrippableDylib)
-    hdr->flags |= MachO::MH_DEAD_STRIPPABLE_DYLIB;
+    hdr->flags |= MH_DEAD_STRIPPABLE_DYLIB;
 
-  if (config->outputType == MachO::MH_EXECUTE && config->isPic)
-    hdr->flags |= MachO::MH_PIE;
+  if (config->outputType == MH_EXECUTE && config->isPic)
+    hdr->flags |= MH_PIE;
 
   if (in.exports->hasWeakSymbol || in.weakBinding->hasNonWeakDefinition())
-    hdr->flags |= MachO::MH_WEAK_DEFINES;
+    hdr->flags |= MH_WEAK_DEFINES;
 
   if (in.exports->hasWeakSymbol || in.weakBinding->hasEntry())
-    hdr->flags |= MachO::MH_BINDS_TO_WEAK;
+    hdr->flags |= MH_BINDS_TO_WEAK;
 
   for (const OutputSegment *seg : outputSegments) {
     for (const OutputSection *osec : seg->getSections()) {
       if (isThreadLocalVariables(osec->flags)) {
-        hdr->flags |= MachO::MH_HAS_TLV_DESCRIPTORS;
+        hdr->flags |= MH_HAS_TLV_DESCRIPTORS;
         break;
       }
     }
   }
 
   uint8_t *p = reinterpret_cast<uint8_t *>(hdr + 1);
   for (const LoadCommand *lc : loadCommands) {
     lc->writeTo(p);
struct Rebase {
   uint64_t consecutiveCount = 0;
 };
 } // namespace
 
 // Rebase opcodes allow us to describe a contiguous sequence of rebase location
 // using a single DO_REBASE opcode. To take advantage of it, we delay emitting
 // `DO_REBASE` until we have reached the end of a contiguous sequence.
 static void encodeDoRebase(Rebase &rebase, raw_svector_ostream &os) {
-  using namespace llvm::MachO;
   assert(rebase.consecutiveCount != 0);
   if (rebase.consecutiveCount <= REBASE_IMMEDIATE_MASK) {
     os << static_cast<uint8_t>(REBASE_OPCODE_DO_REBASE_IMM_TIMES |
                                rebase.consecutiveCount);
   } else {
     os << static_cast<uint8_t>(REBASE_OPCODE_DO_REBASE_ULEB_TIMES);
     encodeULEB128(rebase.consecutiveCount, os);
   }
   rebase.consecutiveCount = 0;
 }
 
 static void encodeRebase(const OutputSection *osec, uint64_t outSecOff,
                          Rebase &lastRebase, raw_svector_ostream &os) {
-  using namespace llvm::MachO;
   OutputSegment *seg = osec->parent;
   uint64_t offset = osec->getSegmentOffset() + outSecOff;
   if (lastRebase.segment != seg || lastRebase.offset != offset) {
     if (lastRebase.consecutiveCount != 0)
       encodeDoRebase(lastRebase, os);
 
     if (lastRebase.segment != seg) {
       os << static_cast<uint8_t>(REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB |
if (lastRebase.segment != seg || lastRebase.offset != offset) {
     }
   }
   ++lastRebase.consecutiveCount;
   // DO_REBASE causes dyld to both perform the binding and increment the offset
   lastRebase.offset += WordSize;
 }
 
 void RebaseSection::finalizeContents() {
-  using namespace llvm::MachO;
   if (locations.empty())
     return;
 
   raw_svector_ostream os{contents};
   Rebase lastRebase;
 
   os << static_cast<uint8_t>(REBASE_OPCODE_SET_TYPE_IMM | REBASE_TYPE_POINTER);
 

 void RebaseSection::writeTo(uint8_t *buf) const {
   memcpy(buf, contents.data(), contents.size());
 }
 
 NonLazyPointerSectionBase::NonLazyPointerSectionBase(const char *segname,
                                                      const char *name)
     : SyntheticSection(segname, name) {
   align = WordSize;
-  flags = MachO::S_NON_LAZY_SYMBOL_POINTERS;
+  flags = S_NON_LAZY_SYMBOL_POINTERS;
 }
 
 void NonLazyPointerSectionBase::addEntry(Symbol *sym) {
   if (entries.insert(sym)) {
     assert(!sym->isInGot());
     sym->gotIndex = entries.size() - 1;
 
     addNonLazyBindingEntries(sym, this, sym->gotIndex * WordSize);

 //
 // The bind opcode "interpreter" remembers the values of each binding field, so
 // we only need to encode the differences between bindings. Hence the use of
 // lastBinding.
 static void encodeBinding(const Symbol *sym, const OutputSection *osec,
                           uint64_t outSecOff, int64_t addend,
                           bool isWeakBinding, Binding &lastBinding,
                           raw_svector_ostream &os) {
-  using namespace llvm::MachO;
   OutputSegment *seg = osec->parent;
   uint64_t offset = osec->getSegmentOffset() + outSecOff;
   if (lastBinding.segment != seg) {
     os << static_cast<uint8_t>(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB |
                                seg->index);
     encodeULEB128(offset, os);
     lastBinding.segment = seg;
     lastBinding.offset = offset;
os << flags << sym->getName() << '\0'
      << static_cast<uint8_t>(BIND_OPCODE_DO_BIND);
   // DO_BIND causes dyld to both perform the binding and increment the offset
   lastBinding.offset += WordSize;
 }
 
 // Non-weak bindings need to have their dylib ordinal encoded as well.
 static int16_t ordinalForDylibSymbol(const DylibSymbol &dysym) {
   return config->namespaceKind == NamespaceKind::flat || dysym.isDynamicLookup()
-             ? (int16_t)MachO::BIND_SPECIAL_DYLIB_FLAT_LOOKUP
+             ? static_cast<int16_t>(BIND_SPECIAL_DYLIB_FLAT_LOOKUP)
              : dysym.getFile()->ordinal;
 }
 
 static void encodeDylibOrdinal(int16_t ordinal, raw_svector_ostream &os) {
-  using namespace llvm::MachO;
   if (ordinal <= 0) {
     os << static_cast<uint8_t>(BIND_OPCODE_SET_DYLIB_SPECIAL_IMM |
                                (ordinal & BIND_IMMEDIATE_MASK));
   } else if (ordinal <= BIND_IMMEDIATE_MASK) {
     os << static_cast<uint8_t>(BIND_OPCODE_SET_DYLIB_ORDINAL_IMM | ordinal);
   } else {
     os << static_cast<uint8_t>(BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB);
     encodeULEB128(ordinal, os);
   }
 }
 
 static void encodeWeakOverride(const Defined *defined,
                                raw_svector_ostream &os) {
-  using namespace llvm::MachO;
   os << static_cast<uint8_t>(BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM |
                              BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION)
      << defined->getName() << '\0';
 }
 
 // Emit bind opcodes, which are a stream of byte-sized opcodes that dyld
 // interprets to update a record with the following fields:
 //  * segment index (of the segment to write the symbol addresses to, typically
if (auto *isec = b.target.section.dyn_cast<const InputSection *>()) {
                     b.addend, /*isWeakBinding=*/false, lastBinding, os);
     } else {
       auto *osec = b.target.section.get<const OutputSection *>();
       encodeBinding(b.dysym, osec, b.target.offset, b.addend,
                     /*isWeakBinding=*/false, lastBinding, os);
     }
   }
   if (!bindings.empty())
-    os << static_cast<uint8_t>(MachO::BIND_OPCODE_DONE);
+    os << static_cast<uint8_t>(BIND_OPCODE_DONE);
 }
 
 void BindingSection::writeTo(uint8_t *buf) const {
   memcpy(buf, contents.data(), contents.size());
 }
 
 WeakBindingSection::WeakBindingSection()
     : LinkEditSection(segment_names::linkEdit, section_names::weakBinding) {}
if (const auto *isec = b.target.section.dyn_cast<const InputSection *>()) {
                     b.addend, /*isWeakBinding=*/true, lastBinding, os);
     } else {
       const auto *osec = b.target.section.get<const OutputSection *>();
       encodeBinding(b.symbol, osec, b.target.offset, b.addend,
                     /*isWeakBinding=*/true, lastBinding, os);
     }
   }
   if (!bindings.empty() || !definitions.empty())
-    os << static_cast<uint8_t>(MachO::BIND_OPCODE_DONE);
+    os << static_cast<uint8_t>(BIND_OPCODE_DONE);
 }
 
 void WeakBindingSection::writeTo(uint8_t *buf) const {
   memcpy(buf, contents.data(), contents.size());
 }
 
 bool macho::needsBinding(const Symbol *sym) {
   if (isa<DylibSymbol>(sym))
if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
     llvm_unreachable("cannot bind to an undefined symbol");
   }
   // TODO: understand the DSOHandle case better.
   // Is it bindable?  Add a new test?
 }
 
 StubsSection::StubsSection()
     : SyntheticSection(segment_names::text, "__stubs") {
-  flags = MachO::S_SYMBOL_STUBS | MachO::S_ATTR_SOME_INSTRUCTIONS |
-          MachO::S_ATTR_PURE_INSTRUCTIONS;
+  flags = S_SYMBOL_STUBS | S_ATTR_SOME_INSTRUCTIONS | S_ATTR_PURE_INSTRUCTIONS;
   // The stubs section comprises machine instructions, which are aligned to
   // 4 bytes on the archs we care about.
   align = 4;
   reserved2 = target->stubSize;
 }
 
 uint64_t StubsSection::getSize() const {
   return entries.size() * target->stubSize;
bool StubsSection::addEntry(Symbol *sym) {
   bool inserted = entries.insert(sym);
   if (inserted)
     sym->stubsIndex = entries.size() - 1;
   return inserted;
 }
 
 StubHelperSection::StubHelperSection()
     : SyntheticSection(segment_names::text, "__stub_helper") {
-  flags = MachO::S_ATTR_SOME_INSTRUCTIONS | MachO::S_ATTR_PURE_INSTRUCTIONS;
+  flags = S_ATTR_SOME_INSTRUCTIONS | S_ATTR_PURE_INSTRUCTIONS;
   align = 4; // This section comprises machine instructions
 }
 
 uint64_t StubHelperSection::getSize() const {
   return target->stubHelperHeaderSize +
          in.lazyBinding->getEntries().size() * target->stubHelperEntrySize;
 }
 
ImageLoaderCacheSection::ImageLoaderCacheSection() {
   memset(arr, 0, WordSize);
   data = {arr, WordSize};
   align = WordSize;
 }
 
 LazyPointerSection::LazyPointerSection()
     : SyntheticSection(segment_names::data, "__la_symbol_ptr") {
   align = WordSize;
-  flags = MachO::S_LAZY_SYMBOL_POINTERS;
+  flags = S_LAZY_SYMBOL_POINTERS;
 }
 
 uint64_t LazyPointerSection::getSize() const {
   return in.stubs->getEntries().size() * WordSize;
 }
 
 bool LazyPointerSection::isNeeded() const {
   return !in.stubs->getEntries().empty();

 // interpreted all at once. Rather, dyld will start interpreting opcodes at a
 // given offset, typically only binding a single symbol before it finds a
 // BIND_OPCODE_DONE terminator. As such, unlike in the non-lazy-binding case,
 // we cannot encode just the differences between symbols; we have to emit the
 // complete bind information for each symbol.
 uint32_t LazyBindingSection::encode(const DylibSymbol &sym) {
   uint32_t opstreamOffset = contents.size();
   OutputSegment *dataSeg = in.lazyPointers->parent;
-  os << static_cast<uint8_t>(MachO::BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB |
+  os << static_cast<uint8_t>(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB |
                              dataSeg->index);
   uint64_t offset = in.lazyPointers->addr - dataSeg->firstSection()->addr +
                     sym.stubsIndex * WordSize;
   encodeULEB128(offset, os);
   encodeDylibOrdinal(ordinalForDylibSymbol(sym), os);
 
-  uint8_t flags = MachO::BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM;
+  uint8_t flags = BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM;
   if (sym.isWeakRef())
-    flags |= MachO::BIND_SYMBOL_FLAGS_WEAK_IMPORT;
+    flags |= BIND_SYMBOL_FLAGS_WEAK_IMPORT;
 
   os << flags << sym.getName() << '\0'
-     << static_cast<uint8_t>(MachO::BIND_OPCODE_DO_BIND)
-     << static_cast<uint8_t>(MachO::BIND_OPCODE_DONE);
+     << static_cast<uint8_t>(BIND_OPCODE_DO_BIND)
+     << static_cast<uint8_t>(BIND_OPCODE_DONE);
   return opstreamOffset;
 }
 
 void macho::prepareBranchTarget(Symbol *sym) {
   if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
     if (in.stubs->addEntry(dysym)) {
       if (sym->isWeakDef()) {
         in.binding->addEntry(dysym, in.lazyPointers,
SymtabSection::SymtabSection(StringTableSection &stringTableSection)
     : LinkEditSection(segment_names::linkEdit, section_names::symbolTable),
       stringTableSection(stringTableSection) {}
 
 uint64_t SymtabSection::getRawSize() const {
   return getNumSymbols() * sizeof(structs::nlist_64);
 }
 
 void SymtabSection::emitBeginSourceStab(DWARFUnit *compileUnit) {
-  StabsEntry stab(MachO::N_SO);
+  StabsEntry stab(N_SO);
   SmallString<261> dir(compileUnit->getCompilationDir());
   StringRef sep = sys::path::get_separator();
   // We don't use `path::append` here because we want an empty `dir` to result
   // in an absolute path. `append` would give us a relative path for that case.
   if (!dir.endswith(sep))
     dir += sep;
   stab.strx = stringTableSection.addString(
       saver.save(dir + compileUnit->getUnitDIE().getShortName()));
   stabs.emplace_back(std::move(stab));
 }
 
 void SymtabSection::emitEndSourceStab() {
-  StabsEntry stab(MachO::N_SO);
+  StabsEntry stab(N_SO);
   stab.sect = 1;
   stabs.emplace_back(std::move(stab));
 }
 
 void SymtabSection::emitObjectFileStab(ObjFile *file) {
-  StabsEntry stab(MachO::N_OSO);
+  StabsEntry stab(N_OSO);
   stab.sect = target->cpuSubtype;
   SmallString<261> path(!file->archiveName.empty() ? file->archiveName
                                                    : file->getName());
   std::error_code ec = sys::fs::make_absolute(path);
   if (ec)
     fatal("failed to get absolute path for " + path);
 
   if (!file->archiveName.empty())
     path.append({"(", file->getName(), ")"});
 
   stab.strx = stringTableSection.addString(saver.save(path.str()));
   stab.desc = 1;
   stab.value = file->modTime;
   stabs.emplace_back(std::move(stab));
 }
 
 void SymtabSection::emitEndFunStab(Defined *defined) {
-  StabsEntry stab(MachO::N_FUN);
+  StabsEntry stab(N_FUN);
   // FIXME this should be the size of the symbol. Using the section size in
   // lieu is only correct if .subsections_via_symbols is set.
   stab.value = defined->isec->getSize();
   stabs.emplace_back(std::move(stab));
 }
 
 void SymtabSection::emitStabs() {
   std::vector<Defined *> symbolsNeedingStabs;
for (Defined *defined : symbolsNeedingStabs) {
     }
 
     StabsEntry symStab;
     symStab.sect = defined->isec->parent->index;
     symStab.strx = stringTableSection.addString(defined->getName());
     symStab.value = defined->getVA();
 
     if (isCodeSection(isec)) {
-      symStab.type = MachO::N_FUN;
+      symStab.type = N_FUN;
       stabs.emplace_back(std::move(symStab));
       emitEndFunStab(defined);
     } else {
-      symStab.type = defined->isExternal() ? MachO::N_GSYM : MachO::N_STSYM;
+      symStab.type = defined->isExternal() ? N_GSYM : N_STSYM;
       stabs.emplace_back(std::move(symStab));
     }
   }
 
   if (!stabs.empty())
     emitEndSourceStab();
 }
 
for (const SymtabEntry &entry : concat<const SymtabEntry>(
     nList->n_strx = entry.strx;
     // TODO populate n_desc with more flags
     if (auto *defined = dyn_cast<Defined>(entry.sym)) {
       uint8_t scope = 0;
       if (defined->privateExtern) {
         // Private external -- dylib scoped symbol.
         // Promote to non-external at link time.
         assert(defined->isExternal() && "invalid input file");
-        scope = MachO::N_PEXT;
+        scope = N_PEXT;
       } else if (defined->isExternal()) {
         // Normal global symbol.
-        scope = MachO::N_EXT;
+        scope = N_EXT;
       } else {
         // TU-local symbol from localSymbols.
         scope = 0;
       }
 
       if (defined->isAbsolute()) {
-        nList->n_type = scope | MachO::N_ABS;
-        nList->n_sect = MachO::NO_SECT;
+        nList->n_type = scope | N_ABS;
+        nList->n_sect = NO_SECT;
         nList->n_value = defined->value;
       } else {
-        nList->n_type = scope | MachO::N_SECT;
+        nList->n_type = scope | N_SECT;
         nList->n_sect = defined->isec->parent->index;
         // For the N_SECT symbol type, n_value is the address of the symbol
         nList->n_value = defined->getVA();
       }
-      nList->n_desc |= defined->isExternalWeakDef() ? MachO::N_WEAK_DEF : 0;
+      nList->n_desc |= defined->isExternalWeakDef() ? N_WEAK_DEF : 0;
     } else if (auto *dysym = dyn_cast<DylibSymbol>(entry.sym)) {
       uint16_t n_desc = nList->n_desc;
       int16_t ordinal = ordinalForDylibSymbol(*dysym);
-      if (ordinal == MachO::BIND_SPECIAL_DYLIB_FLAT_LOOKUP)
-        MachO::SET_LIBRARY_ORDINAL(n_desc, MachO::DYNAMIC_LOOKUP_ORDINAL);
-      else if (ordinal == MachO::BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE)
-        MachO::SET_LIBRARY_ORDINAL(n_desc, MachO::EXECUTABLE_ORDINAL);
+      if (ordinal == BIND_SPECIAL_DYLIB_FLAT_LOOKUP)
+        SET_LIBRARY_ORDINAL(n_desc, DYNAMIC_LOOKUP_ORDINAL);
+      else if (ordinal == BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE)
+        SET_LIBRARY_ORDINAL(n_desc, EXECUTABLE_ORDINAL);
       else {
         assert(ordinal > 0);
-        MachO::SET_LIBRARY_ORDINAL(n_desc, static_cast<uint8_t>(ordinal));
+        SET_LIBRARY_ORDINAL(n_desc, static_cast<uint8_t>(ordinal));
       }
 
-      nList->n_type = MachO::N_EXT;
-      n_desc |= dysym->isWeakDef() ? MachO::N_WEAK_DEF : 0;
-      n_desc |= dysym->isWeakRef() ? MachO::N_WEAK_REF : 0;
+      nList->n_type = N_EXT;
+      n_desc |= dysym->isWeakDef() ? N_WEAK_DEF : 0;
+      n_desc |= dysym->isWeakRef() ? N_WEAK_REF : 0;
       nList->n_desc = n_desc;
     }
     ++nList;
   }
 }
 
 IndirectSymtabSection::IndirectSymtabSection()
     : LinkEditSection(segment_names::linkEdit,
void IndirectSymtabSection::finalizeContents() {
   off += in.tlvPointers->getEntries().size();
   // There is a 1:1 correspondence between stubs and LazyPointerSection
   // entries, so they can share the same sub-array in the table.
   in.stubs->reserved1 = in.lazyPointers->reserved1 = off;
 }
 
 static uint32_t indirectValue(const Symbol *sym) {
   return sym->symtabIndex != UINT32_MAX ? sym->symtabIndex
-                                        : MachO::INDIRECT_SYMBOL_LOCAL;
+                                        : INDIRECT_SYMBOL_LOCAL;
 }
 
 void IndirectSymtabSection::writeTo(uint8_t *buf) const {
   uint32_t off = 0;
   for (const Symbol *sym : in.got->getEntries()) {
     write32le(buf + off * sizeof(uint32_t), indirectValue(sym));
     ++off;
   }
#if defined(__APPLE__)
   // sign or the signature header+hashes.  The fix is to invalidate
   // all cached data associated with the output file, thus discarding
   // the bogus prematurely-cached signature.
   msync(buf, fileOff + getSize(), MS_INVALIDATE);
 #endif
 }
 
 void CodeSignatureSection::writeTo(uint8_t *buf) const {
-  using namespace llvm::MachO;
   uint32_t signatureSize = static_cast<uint32_t>(getSize());
   auto *superBlob = reinterpret_cast<CS_SuperBlob *>(buf);
   write32be(&superBlob->magic, CSMAGIC_EMBEDDED_SIGNATURE);
   write32be(&superBlob->length, signatureSize);
   write32be(&superBlob->count, 1);
   auto *blobIndex = reinterpret_cast<CS_BlobIndex *>(&superBlob[1]);
   write32be(&blobIndex->type, CSSLOT_CODEDIRECTORY);
   write32be(&blobIndex->offset, blobHeadersSize);

lld/MachO/Writer.cpp

void Writer::createLoadCommands() {
 
   in.header->addLoadCommand(
       make<LCBuildVersion>(config->target.Platform, config->platformInfo));
 
   int64_t dylibOrdinal = 1;
   for (InputFile *file : inputFiles) {
     if (auto *dylibFile = dyn_cast<DylibFile>(file)) {
       if (dylibFile->isBundleLoader) {
-        dylibFile->ordinal = MachO::BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE;
+        dylibFile->ordinal = BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE;
         // Shortcut since bundle-loader does not re-export the symbols.
 
         dylibFile->reexport = false;
         continue;
       }
 
       dylibFile->ordinal = dylibOrdinal++;
       LoadCommandType lcType =