[lld-macho][NFC] define more strings in section_names:: and segment_names::

[gkm]

Summary

As preparation for a subsequent diff that implements builtin section renaming, define more constexpr strings in namespaces lld::macho::segment_names and lld::macho::section_names, and use them to replace string literals.

[int3]

lld/MachO/MergedOutputSection.cpp

58–60

technically a change in an error message is a functional change :)

It seems like we are lacking a test for this; could you add it in this diff?

Also I think the flags would be more readable as hex values (there's to_hexString() in ScopedPrinter.h)

[gkm]

lld/MachO/MergedOutputSection.cpp

58–60

Oops. This change should migrate back into the builtin-section-renaming diff.

[gkm]

• migrate bugfix in MergedOutputSection::mergeFlags() out of this NFC diff

lld/MachO/Dwarf.cpp

std::unique_ptr<DwarfObject> DwarfObject::create(ObjFile *obj) {
   auto dObj = std::make_unique<DwarfObject>();
   bool hasDwarfInfo = false;
   // LLD only needs to extract the source file path from the debug info, so we
   // initialize DwarfObject with just the sections necessary to get that path.
   // The debugger will locate the debug info via the object file paths that we
   // emit in our STABS symbols, so we don't need to process & emit them
   // ourselves.
   for (const InputSection *isec : obj->debugSections) {
-    if (StringRef *s = StringSwitch<StringRef *>(isec->name)
-                           .Case("__debug_info", &dObj->infoSection.Data)
-                           .Case("__debug_abbrev", &dObj->abbrevSection)
-                           .Case("__debug_str", &dObj->strSection)
-                           .Default(nullptr)) {
+    if (StringRef *s =
+            StringSwitch<StringRef *>(isec->name)
+                .Case(section_names::debugInfo, &dObj->infoSection.Data)
+                .Case(section_names::debugAbbrev, &dObj->abbrevSection)
+                .Case(section_names::debugStr, &dObj->strSection)
       *s = toStringRef(isec->data);
       hasDwarfInfo = true;
     }
   }
 
   if (hasDwarfInfo)
     return dObj;
   return nullptr;
 }

lld/MachO/InputSection.h

 }
 
 bool isCodeSection(InputSection *);
 
 extern std::vector<InputSection *> inputSections;
 
 namespace section_names {
 
-constexpr const char pageZero[] = "__pagezero";
-constexpr const char common[] = "__common";
-constexpr const char header[] = "__mach_header";
-constexpr const char rebase[] = "__rebase";
+constexpr const char authGot[] = "__auth_got";
+constexpr const char authPtr[] = "__auth_ptr";
 constexpr const char binding[] = "__binding";
-constexpr const char weakBinding[] = "__weak_binding";
-constexpr const char lazyBinding[] = "__lazy_binding";
+constexpr const char bitcodeBundle[] = "__bundle";
+constexpr const char cfString[] = "__cfstring";
+constexpr const char codeSignature[] = "__code_signature";
+constexpr const char common[] = "__common";
+constexpr const char compactUnwind[] = "__compact_unwind";
+constexpr const char data[] = "__data";
+constexpr const char debugAbbrev[] = "__debug_abbrev";
+constexpr const char debugInfo[] = "__debug_info";
+constexpr const char debugStr[] = "__debug_str";
+constexpr const char ehFrame[] = "__eh_frame";
 constexpr const char export_[] = "__export";
 constexpr const char functionStarts[] = "__func_starts";
-constexpr const char symbolTable[] = "__symbol_table";
+constexpr const char got[] = "__got";
+constexpr const char header[] = "__mach_header";
 constexpr const char indirectSymbolTable[] = "__ind_sym_tab";
+constexpr const char const_[] = "__const";
+constexpr const char lazySymbolPtr[] = "__la_symbol_ptr";
+constexpr const char lazyBinding[] = "__lazy_binding";
+constexpr const char moduleInitFunc[] = "__mod_init_func";
+constexpr const char moduleTermFunc[] = "__mod_term_func";
+constexpr const char nonLazySymbolPtr[] = "__nl_symbol_ptr";
+constexpr const char objcCatList[] = "__objc_catlist";
+constexpr const char objcClassList[] = "__objc_classlist";
+constexpr const char objcConst[] = "__objc_const";
+constexpr const char objcImageInfo[] = "__objc_imageinfo";
+constexpr const char objcNonLazyCatList[] = "__objc_nlcatlist";
+constexpr const char objcNonLazyClassList[] = "__objc_nlclslist";
+constexpr const char objcProtoList[] = "__objc_protolist";
+constexpr const char pageZero[] = "__pagezero";
+constexpr const char pointers[] = "__pointers";
+constexpr const char rebase[] = "__rebase";
+constexpr const char staticInit[] = "__StaticInit";
 constexpr const char stringTable[] = "__string_table";
-constexpr const char codeSignature[] = "__code_signature";
-constexpr const char got[] = "__got";
+constexpr const char stubHelper[] = "__stub_helper";
+constexpr const char stubs[] = "__stubs";
+constexpr const char swift[] = "__swift";
+constexpr const char symbolTable[] = "__symbol_table";
+constexpr const char textCoalNt[] = "__textcoal_nt";
+constexpr const char text[] = "__text";
 constexpr const char threadPtrs[] = "__thread_ptrs";
+constexpr const char threadVars[] = "__thread_vars";
 constexpr const char unwindInfo[] = "__unwind_info";
-constexpr const char compactUnwind[] = "__compact_unwind";
-constexpr const char ehFrame[] = "__eh_frame";
-constexpr const char text[] = "__text";
-constexpr const char stubs[] = "__stubs";
-constexpr const char stubHelper[] = "__stub_helper";
-constexpr const char laSymbolPtr[] = "__la_symbol_ptr";
-constexpr const char data[] = "__data";
-constexpr const char bitcodeBundle[] = "__bundle";
+constexpr const char weakBinding[] = "__weak_binding";
+constexpr const char zeroFill[] = "__zerofill";
 
 } // namespace section_names
 
 } // namespace macho
 
 std::string toString(const macho::InputSection *);
 
 } // namespace lld
 
 #endif

lld/MachO/InputSection.cpp

if (type != S_REGULAR && type != S_COALESCED)
     return false;
 
   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)
+        .Cases(section_names::textCoalNt, section_names::staticInit, true)
         .Default(false);
 
   return false;
 }
 
 std::string lld::toString(const InputSection *isec) {
   return (toString(isec->file) + ":(" + isec->name + ")").str();
 }

lld/MachO/MergedOutputSection.cpp

 }
 
 // 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 = SECTION_TYPE & inputFlags;
   if (sectionFlag != (SECTION_TYPE & flags))
-    error("Cannot add merge section; inconsistent type flags " +
-          Twine(sectionFlag));
+    error("Cannot add merge section; inconsistent type: old=" +
+          std::to_string(SECTION_TYPE & flags) +
+          ", new=" + std::to_string(sectionFlag));
 
   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 = ~S_ATTR_PURE_INSTRUCTIONS | (inputFlags & flags);
 
   // Merge the rest
   flags |= inputFlags;
   flags &= pureMask;
 }

lld/MachO/ObjC.cpp

 //===- ObjC.cpp -----------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "ObjC.h"
 #include "InputFiles.h"
+#include "InputSection.h"
 #include "OutputSegment.h"
 #include "Target.h"
 
 #include "llvm/BinaryFormat/MachO.h"
 
 using namespace llvm;
 using namespace llvm::MachO;
 using namespace lld;
 using namespace lld::macho;
 
 template <class LP> static bool hasObjCSection(MemoryBufferRef mb) {
   using Section = typename LP::section;
 
   auto *hdr =
       reinterpret_cast<const typename LP::mach_header *>(mb.getBufferStart());
   if (const auto *c =
           findCommand<typename LP::segment_command>(hdr, LP::segmentLCType)) {
     auto sectionHeaders =
         ArrayRef<Section>{reinterpret_cast<const Section *>(c + 1), c->nsects};
     for (const Section &sec : sectionHeaders) {
       StringRef sectname(sec.sectname,
                          strnlen(sec.sectname, sizeof(sec.sectname)));
       StringRef segname(sec.segname, strnlen(sec.segname, sizeof(sec.segname)));
-      if ((segname == segment_names::data && sectname == "__objc_catlist") ||
-          (segname == segment_names::text && sectname == "__swift")) {
+      if ((segname == segment_names::data &&
+           sectname == section_names::objcCatList) ||
+          (segname == segment_names::text &&
+           sectname == section_names::swift)) {
         return true;
       }
     }
   }
   return false;
 }
 
 bool macho::hasObjCSection(MemoryBufferRef mb) {
   if (target->wordSize == 8)
     return ::hasObjCSection<LP64>(mb);
   else
     return ::hasObjCSection<ILP32>(mb);
 }

lld/MachO/OutputSegment.h

 #include "OutputSection.h"
 #include "lld/Common/LLVM.h"
 
 namespace lld {
 namespace macho {
 
 namespace segment_names {
 
-constexpr const char pageZero[] = "__PAGEZERO";
-constexpr const char text[] = "__TEXT";
-constexpr const char data[] = "__DATA";
-constexpr const char linkEdit[] = "__LINKEDIT";
 constexpr const char dataConst[] = "__DATA_CONST";
-constexpr const char ld[] = "__LD"; // output only with -r
+constexpr const char dataDirty[] = "__DATA_DIRTY";
+constexpr const char data[] = "__DATA";
 constexpr const char dwarf[] = "__DWARF";
+constexpr const char import[] = "__IMPORT";
+constexpr const char ld[] = "__LD"; // output only with -r
+constexpr const char linkEdit[] = "__LINKEDIT";
 constexpr const char llvm[] = "__LLVM";
+constexpr const char pageZero[] = "__PAGEZERO";
+constexpr const char textExec[] = "__TEXT_EXEC";
+constexpr const char text[] = "__TEXT";
 
 } // namespace segment_names
 
 class OutputSection;
 class InputSection;
 
 class OutputSegment {
 public:

lld/MachO/SyntheticSections.cpp

if (!bindings.empty() || !definitions.empty())
     os << static_cast<uint8_t>(BIND_OPCODE_DONE);
 }
 
 void WeakBindingSection::writeTo(uint8_t *buf) const {
   memcpy(buf, contents.data(), contents.size());
 }
 
 StubsSection::StubsSection()
-    : SyntheticSection(segment_names::text, "__stubs") {
+    : SyntheticSection(segment_names::text, section_names::stubs) {
   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 {

 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") {
+    : SyntheticSection(segment_names::text, section_names::stubHelper) {
   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;
 }
void StubHelperSection::setup() {
   dyldPrivate =
       make<Defined>("__dyld_private", nullptr, in.imageLoaderCache, 0, 0,
                     /*isWeakDef=*/false,
                     /*isExternal=*/false, /*isPrivateExtern=*/false);
 }
 
 ImageLoaderCacheSection::ImageLoaderCacheSection() {
   segname = segment_names::data;
-  name = "__data";
+  name = section_names::data;
   uint8_t *arr = bAlloc.Allocate<uint8_t>(target->wordSize);
   memset(arr, 0, target->wordSize);
   data = {arr, target->wordSize};
   align = target->wordSize;
 }
 
 LazyPointerSection::LazyPointerSection()
-    : SyntheticSection(segment_names::data, "__la_symbol_ptr") {
+    : SyntheticSection(segment_names::data, section_names::lazySymbolPtr) {
   align = target->wordSize;
   flags = S_LAZY_SYMBOL_POINTERS;
 }
 
 uint64_t LazyPointerSection::getSize() const {
   return in.stubs->getEntries().size() * target->wordSize;
 }
 

lld/MachO/Writer.cpp

if (segname == segment_names::text) {
     case S_THREAD_LOCAL_REGULAR:
       return std::numeric_limits<int>::max() - 2;
     case S_THREAD_LOCAL_ZEROFILL:
       return std::numeric_limits<int>::max() - 1;
     case S_ZEROFILL:
       return std::numeric_limits<int>::max();
     default:
       return StringSwitch<int>(osec->name)
-          .Case(section_names::laSymbolPtr, -2)
+          .Case(section_names::lazySymbolPtr, -2)
           .Case(section_names::data, -1)
           .Default(0);
     }
   } else if (segname == segment_names::linkEdit) {
     return StringSwitch<int>(osec->name)
         .Case(section_names::rebase, -9)
         .Case(section_names::binding, -8)
         .Case(section_names::weakBinding, -7)