[not for review] Dump counts of literals/subsections

lld/MachO/InputFiles.cpp

macho::Symbol *ObjFile::parseNonSectionSymbol(const NList &sym,
   }
 }
 
 template <class LP>
 void ObjFile::parseSymbols(ArrayRef<typename LP::section> sectionHeaders,
                            ArrayRef<typename LP::nlist> nList,
                            const char *strtab, bool subsectionsViaSymbols) {
   using NList = typename LP::nlist;
+  size_t subsecCount = 0;
 
   // Groups indices of the symbols by the sections that contain them.
   std::vector<std::vector<uint32_t>> symbolsBySection(subsections.size());
   symbols.resize(nList.size());
   for (uint32_t i = 0; i < nList.size(); ++i) {
     const NList &sym = nList[i];
     StringRef name = strtab + sym.n_strx;
     if ((sym.n_type & N_TYPE) == N_SECT) {
       SubsectionMap &subsecMap = subsections[sym.n_sect - 1];
       // parseSections() may have chosen not to parse this section.
       if (subsecMap.empty())
         continue;
       symbolsBySection[sym.n_sect - 1].push_back(i);
     } else {
       symbols[i] = parseNonSectionSymbol(sym, name);
     }
   }
 
   // Calculate symbol sizes and create subsections by splitting the sections
   // along symbol boundaries.
   for (size_t i = 0; i < subsections.size(); ++i) {
     SubsectionMap &subsecMap = subsections[i];
     if (subsecMap.empty())
       continue;
+    subsecCount++;
 
     std::vector<uint32_t> &symbolIndices = symbolsBySection[i];
     llvm::sort(symbolIndices, [&](uint32_t lhs, uint32_t rhs) {
       return nList[lhs].n_value < nList[rhs].n_value;
     });
     uint64_t sectionAddr = sectionHeaders[i].addr;
     uint32_t sectionAlign = 1u << sectionHeaders[i].align;
 
for (size_t j = 0; j < symbolIndices.size(); ++j) {
       symbols[symIndex] =
           createDefined(sym, name, nextIsec, /*value=*/0, symbolSize);
       // TODO: ld64 appears to preserve the original alignment as well as each
       // subsection's offset from the last aligned address. We should consider
       // emulating that behavior.
       nextIsec->align = MinAlign(sectionAlign, sym.n_value);
       subsecMap.push_back({sym.n_value - sectionAddr, nextIsec});
       subsecEntry = subsecMap.back();
+      subsecCount++;
     }
   }
+  fprintf(stderr, "Created %zu subsections\n", subsecCount);
 }
 
 OpaqueFile::OpaqueFile(MemoryBufferRef mb, StringRef segName,
                        StringRef sectName)
     : InputFile(OpaqueKind, mb) {
   ConcatInputSection *isec =
       make<ConcatInputSection>(segName.take_front(16), sectName.take_front(16));
   isec->file = this;

lld/MachO/InputSection.cpp

while (!s.empty()) {
     size_t end = s.find(0);
     if (end == StringRef::npos)
       fatal(toString(this) + ": string is not null terminated");
     size_t size = end + 1;
     pieces.emplace_back(off, xxHash64(s.substr(0, size)));
     s = s.substr(size);
     off += size;
   }
+  fprintf(stderr, "Created %zu strings\n", pieces.size());
 }
 
 StringPiece &CStringInputSection::getStringPiece(uint64_t off) {
   if (off >= data.size())
     fatal(toString(this) + ": offset is outside the section");
 
   auto it =
       partition_point(pieces, [=](StringPiece p) { return p.inSecOff <= off; });

lld/MachO/SyntheticSections.cpp

 // synthetic and concat-type OutputSections. To work around this, I've given
 // our merged-literals section a different name.
 WordLiteralSection::WordLiteralSection()
     : SyntheticSection(segment_names::text, section_names::literals) {
   align = 16;
 }
 
 void WordLiteralSection::addInput(WordLiteralInputSection *isec) {
+  size_t litCount = 0;
   isec->parent = this;
   // We do all processing of the InputSection here, so it will be effectively
   // finalized.
   isec->isFinal = true;
   const uint8_t *buf = isec->data.data();
   switch (sectionType(isec->flags)) {
   case S_4BYTE_LITERALS: {
     for (size_t off = 0, e = isec->data.size(); off < e; off += 4) {
+      ++litCount;
       if (!isec->isLive(off))
         continue;
       uint32_t value = *reinterpret_cast<const uint32_t *>(buf + off);
       literal4Map.emplace(value, literal4Map.size());
     }
     break;
   }
   case S_8BYTE_LITERALS: {
     for (size_t off = 0, e = isec->data.size(); off < e; off += 8) {
+      ++litCount;
       if (!isec->isLive(off))
         continue;
       uint64_t value = *reinterpret_cast<const uint64_t *>(buf + off);
       literal8Map.emplace(value, literal8Map.size());
     }
     break;
   }
   case S_16BYTE_LITERALS: {
     for (size_t off = 0, e = isec->data.size(); off < e; off += 16) {
+      ++litCount;
       if (!isec->isLive(off))
         continue;
       UInt128 value = *reinterpret_cast<const UInt128 *>(buf + off);
       literal16Map.emplace(value, literal16Map.size());
     }
     break;
   }
   default:
     llvm_unreachable("invalid literal section type");
   }
+  fprintf(stderr, "litcount: %zu\n", litCount);
 }
 
 void WordLiteralSection::writeTo(uint8_t *buf) const {
   // Note that we don't attempt to do any endianness conversion in addInput(),
   // so we don't do it here either -- just write out the original value,
   // byte-for-byte.
   for (const auto &p : literal16Map)
     memcpy(buf + p.second * 16, &p.first, 16);