* resolved some FIXMEs, updated others * integrated with new `-dead_strip` changes

[smeenai]

I assume this was meant to be an update to the ICF diff instead of its own diff?

lld/MachO/ConcatOutputSection.cpp

void ConcatOutputSection::mergeFlags(InputSection *input) {
 
   // Merge the rest
   flags |= input->flags;
   flags &= pureMask;
 }
 
 // ICF = Identical C(ode|OMDAT) Folding
 //
-// FIXME: implement address-significance tables for MachO object files
-// FIXME: exclude writable isecs
-// FIXME: exclude init/fini isecs
-// FIXME: fold vtables?
-// FIXME: implement keep-unique attributes?
+// init/fini functions should never be folded. This is already baked-into
+// MachO because the __mod_init_func & __mod_term_func sections belong to
+// __DATA(_CONST),__const, whereas only __TEXT,__text is eligible for ICF.
+//
+// Writeable sections should never be folded. Since only members of readonly
+// __TEXT,__text are foldable, anything in __DATA is excluded.
+//
+// FIXME(gkm): implement keep-unique attributes
+// FIXME(gkm) fold objects in __DATA_CONST,* __DATA,__const __TEXT,__const
+// FIXME(gkm): implement address-significance tables for MachO object files
 
 static unsigned icfPass = 0;
 static std::atomic<bool> icfRepeat{false};
 // enable expensive debug logs
 const bool enableLogUnequal = false;
 
 // Compare everything except the relocation referents
 static bool equalsConstant(const InputSection *ia, const InputSection *ib) {
return std::equal(
       ia->relocs.begin(), ia->relocs.end(), ib->relocs.begin(),
       [&](const Reloc &ra, const Reloc &rb) {
         std::string nStr = "[" + std::to_string(n++) + "] ";
         if (ra.referent == rb.referent)
           return true;
         if (ra.referent.is<Symbol *>()) {
           const auto *sa = ra.referent.get<Symbol *>();
           const auto *sb = rb.referent.get<Symbol *>();
-          if (const auto *da = dyn_cast<Defined>(sa))
-            if (const auto *db = dyn_cast<Defined>(sb))
-              return (!(da->isec->icfEquivalenceClass[icfPass % 2] !=
-                            db->isec->icfEquivalenceClass[icfPass % 2] &&
-                        logUnequal(nStr + "def hash")));
-          // FIXME: handle DylibSymbol
-          logUnequal(nStr + "!defined");
+          if (sa->kind() != sb->kind() && logUnequal(nStr + "sym kind"))
+            return false;
+          if (isa<Defined>(sa) && isa<Defined>(sb)) {
+            const auto *da = dyn_cast<Defined>(sa);
+            const auto *db = dyn_cast<Defined>(sb);
+            return !(da->isec->icfEquivalenceClass[icfPass % 2] !=
+                     logUnequal(nStr + "def hash"));
+          } else if (isa<DylibSymbol>(sa) && isa<DylibSymbol>(sb)) {
+            const auto *da = dyn_cast<DylibSymbol>(sa);
+            const auto *db = dyn_cast<DylibSymbol>(sb);
+            return !(da->stubsHelperIndex != db->stubsHelperIndex &&
+                     logUnequal(nStr + "stub index"));
+          } else {
+            llvm_unreachable("equalsVariable symbol kind");
+          }
           return false;
         }
         const auto *sa = ra.referent.get<InputSection *>();
         const auto *sb = rb.referent.get<InputSection *>();
         return (!(sa->icfEquivalenceClass[icfPass % 2] !=
                       sb->icfEquivalenceClass[icfPass % 2] &&
                   logUnequal(nStr + "sec hash")));
       });

 void ConcatOutputSection::foldIdenticalSections() {
   icfInputs.assign(inputs.begin(), inputs.end());
 
   // Into each origin-section hash, combine all reloc referent section hashes.
   for (icfPass = 0; icfPass < 2; ++icfPass) {
     parallelForEach(icfInputs, [&](InputSection *isec) {
       uint64_t hash = isec->icfEquivalenceClass[icfPass % 2];
       for (const Reloc &r : isec->relocs) {
-        if (auto *sym = r.referent.dyn_cast<Symbol *>())
+        if (auto *sym = r.referent.dyn_cast<Symbol *>()) {
           if (auto *defined = dyn_cast<Defined>(sym))
-            // FIXME: handle InputSection & DylibSymbol relocs
             hash += defined->isec->icfEquivalenceClass[icfPass % 2];
+          else if (auto *dylibSym = dyn_cast<DylibSymbol>(sym))
+            hash += static_cast<uint64_t>(dylibSym->stubsHelperIndex) << 32;
+          else
+            llvm_unreachable("foldIdenticalSections symbol kind");
+        }
       }
       // Set MSB to 1 to avoid collisions with non-hashed classes.
       isec->icfEquivalenceClass[(icfPass + 1) % 2] = hash | (1ull << 63);
     });
   }
 
   llvm::stable_sort(
       icfInputs, [](const InputSection *a, const InputSection *b) {

lld/MachO/InputSection.h

public:
   uint32_t align = 1;
   uint32_t flags = 0;
   uint32_t callSiteCount = 0;
   bool isFinal = false; // is address assigned?
 
   // How many symbols refer to this InputSection.
   uint32_t numRefs = 0;
 
-  bool isEligibleForICF() const;
+  bool isEligibleForICF(const OutputSection *textOutputSection) const;
   void hashForICF();
   void foldIdentical(InputSection *redundant);
 
   // Equivalence-class ID for ICF
   uint64_t icfEquivalenceClass[2] = {0, 0};
   // Track the defined symbol that references this - for ICF logs
   Defined *defined = nullptr;
 

lld/MachO/InputSection.cpp

if (relocAttrs.hasAttr(RelocAttrBits::BRANCH))
     return sym->resolveBranchVA();
   else if (relocAttrs.hasAttr(RelocAttrBits::GOT))
     return sym->resolveGotVA();
   else if (relocAttrs.hasAttr(RelocAttrBits::TLV))
     return sym->resolveTlvVA();
   return sym->getVA();
 }
 
-bool InputSection::isEligibleForICF() const {
-  switch (sectionType(flags)) {
-  case S_REGULAR:
-    if (shouldOmitFromOutput())
-      return false;
-    if (in.unwindInfo->funcHasPersonality(this))
-      return false;
-    // FIXME: too permissive?
-    return true;
+bool InputSection::isEligibleForICF(
+    const OutputSection *textOutputSection) const {
+  switch (sectionType(flags)) {
+  case S_REGULAR:
+    // FIXME(gkm): handle readonly sections outside __TEXT,__text
+    return parent == textOutputSection &&
+           !in.unwindInfo->funcHasPersonality(this);
   case S_CSTRING_LITERALS:
   case S_4BYTE_LITERALS:
   case S_8BYTE_LITERALS:
   case S_16BYTE_LITERALS:
   case S_LITERAL_POINTERS:
-    // FIXME: too restrictive?
-    return false;
+    return true;
   case S_ZEROFILL:
   case S_GB_ZEROFILL:
   case S_NON_LAZY_SYMBOL_POINTERS:
   case S_LAZY_SYMBOL_POINTERS:
   case S_SYMBOL_STUBS:
   case S_MOD_INIT_FUNC_POINTERS:
   case S_MOD_TERM_FUNC_POINTERS:
   case S_COALESCED:

 }
 
 void InputSection::foldIdentical(InputSection *copy) {
   StringRef thisName = defined ? defined->getName() : "???";
   StringRef thatName = copy->defined ? copy->defined->getName() : "???";
   log("ICF: " + thisName + " replaces " + thatName + ", saves " +
       to_string(getSize()));
   align = std::max(align, copy->align);
-  copy->canOmitFromOutput = true;
+  copy->wasCoalesced = true;
   if (copy->defined) {
     numRefs++;
     copy->defined->isec = this;
     copy->numRefs--;
   }
 }
 
 void InputSection::writeTo(uint8_t *buf) {

lld/MachO/Writer.cpp

 class LCUuid;
 
 class Writer {
 public:
   Writer() : buffer(errorHandler().outputBuffer) {}
 
   void scanRelocations();
   void scanSymbols();
-  template <class LP> ConcatOutputSection *createOutputSections();
+  template <class LP> void createOutputSections();
   template <class LP> void createLoadCommands();
-  void foldIdenticalSections(ConcatOutputSection *textSection);
+  void foldIdenticalSections();
   void finalizeAddresses();
   void finalizeLinkEditSegment();
   void assignAddresses(OutputSegment *);
 
   void openFile();
   void writeSections();
   void writeUuid();
   void writeCodeSignature();
   void writeOutputFile();
 
   template <class LP> void run();
 
   std::unique_ptr<FileOutputBuffer> &buffer;
   uint64_t addr = 0;
   uint64_t fileOff = 0;
   MachHeaderSection *header = nullptr;
   StringTableSection *stringTableSection = nullptr;
   SymtabSection *symtabSection = nullptr;
   IndirectSymtabSection *indirectSymtabSection = nullptr;
   CodeSignatureSection *codeSignatureSection = nullptr;
   FunctionStartsSection *functionStartsSection = nullptr;
 
   LCUuid *uuidCommand = nullptr;
   OutputSegment *linkEditSegment = nullptr;
+  ConcatOutputSection *textOutputSection = nullptr;
 };
 
 // LC_DYLD_INFO_ONLY stores the offsets of symbol import/export information.
 class LCDyldInfo : public LoadCommand {
 public:
   LCDyldInfo(RebaseSection *rebaseSection, BindingSection *bindingSection,
              WeakBindingSection *weakBindingSection,
              LazyBindingSection *lazyBindingSection,
static NamePair maybeRenameSection(NamePair key) {
   if (newNames != config->sectionRenameMap.end())
     return newNames->second;
   auto newName = config->segmentRenameMap.find(key.first);
   if (newName != config->segmentRenameMap.end())
     return std::make_pair(newName->second, key.second);
   return key;
 }
 
-template <class LP> ConcatOutputSection *Writer::createOutputSections() {
+template <class LP> void Writer::createOutputSections() {
   TimeTraceScope timeScope("Create output sections");
   // First, create hidden sections
   stringTableSection = make<StringTableSection>();
   symtabSection = makeSymtabSection<LP>(*stringTableSection);
   indirectSymtabSection = make<IndirectSymtabSection>();
   if (config->adhocCodesign)
     codeSignatureSection = make<CodeSignatureSection>();
   if (config->emitFunctionStarts)
if (it == concatOutputSections.end()) {
             " conflicts with synthetic section " + ssec->segname + "," +
             ssec->name);
     }
   }
 
   // dyld requires __LINKEDIT segment to always exist (even if empty).
   linkEditSegment = getOrCreateOutputSegment(segment_names::linkEdit);
 
-  return concatOutputSections.lookup(
+  textOutputSection = concatOutputSections.lookup(
       maybeRenameSection({segment_names::text, section_names::text}));
 }
 
-void Writer::foldIdenticalSections(ConcatOutputSection *textSection) {
+void Writer::foldIdenticalSections() {
+  if (config->icfLevel == ICFLevel::none || textOutputSection == nullptr)
+    return;
+
   TimeTraceScope timeScope("Fold Identical Code Sections");
   // The ICF equivalence-class segregation algorithm relies on pre-computed
   // hashes of InputSection::data for the ConcatOutputSection::inputs and all
   // sections referenced by their relocs. We could recursively traverse the
   // relocs to find every referenced InputSection, but that precludes easy
   // parallelization. Therefore, we hash every InputSection here where we have
   // them all accessible as a simple vector.
   std::vector<InputSection *> hashable;
   // If an InputSection is ineligible for ICF, we give it a unique
   // ID to force it into an unfoldable singleton equivalence class.
   uint64_t icfInvalidId = 0;
   for (InputSection *isec : inputSections) {
-    if (isec->parent == textSection && isec->isEligibleForICF())
+    if (isec->isEligibleForICF(textOutputSection))
       hashable.push_back(isec);
     else
       isec->icfEquivalenceClass[0] = ++icfInvalidId;
   }
   parallelForEach(hashable, [](InputSection *isec) { isec->hashForICF(); });
-  textSection->foldIdenticalSections();
+  textOutputSection->foldIdenticalSections();
 }
 
 void Writer::finalizeAddresses() {
   TimeTraceScope timeScope("Finalize addresses");
   uint64_t pageSize = target->getPageSize();
   // Ensure that segments (and the sections they contain) are allocated
   // addresses in ascending order, which dyld requires.
   //

 
 template <class LP> void Writer::run() {
   if (config->entry && !isa<Undefined>(config->entry))
     prepareBranchTarget(config->entry);
   scanRelocations();
   if (in.stubHelper->isNeeded())
     in.stubHelper->setup();
   scanSymbols();
-  ConcatOutputSection *textSection = createOutputSections<LP>();
-  if (config->icfLevel != ICFLevel::none && textSection)
-    foldIdenticalSections(textSection);
+  createOutputSections<LP>();
+  foldIdenticalSections();
   // After this point, we create no new segments; HOWEVER, we might
   // yet create branch-range extension thunks for architectures whose
   // hardware call instructions have limited range, e.g., ARM(64).
   // The thunks are created as InputSections interspersed among
   // the ordinary __TEXT,_text InputSections.
   sortSegmentsAndSections();
   createLoadCommands<LP>();
   finalizeAddresses();