[not for review][lld-macho] Simple cstring literal implementation

[int3]

Summary

This is just an experiment to see if not creating heavyweight
InputSections for literals is worth it. The answer seems to be "yes".
This diff only creates the additional InputSections w/o deduplicating
them, and it's a 3.6% regression when linking chromium_framework. In
contrast, the StringPiece-based implementation in D102964 (which
includes deduplication) is only a 2.2% regression.

    N           Min           Max        Median           Avg        Stddev
x  20          3.98          4.09         4.025         4.032   0.035629674
+  20          4.14          4.22         4.175         4.177   0.019493589
Difference at 95.0% confidence
        0.145 +/- 0.018381
        3.59623% +/- 0.455877%
        (Student's t, pooled s = 0.0287182)

lld/MachO/InputFiles.cpp

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;
 
     // We populate subsecMap by repeatedly splitting the last (highest address)
     // subsection.
     SubsectionEntry subsecEntry = subsecMap.back();
+
+    if (sectionType(sectionHeaders[i].flags) == S_CSTRING_LITERALS) {
+      size_t off = 0;
+      StringRef s = toStringRef(subsecEntry.isec->data);
+      size_t nextSymIdxIdx = 0;
+      while (!s.empty()) {
+        InputSection *isec = subsecEntry.isec;
+        size_t end = s.find(0);
+        if (end == StringRef::npos)
+          fatal(toString(this) + ": string is not null terminated");
+        size_t size = end + 1;
+        isec->data = ArrayRef<uint8_t>(
+            reinterpret_cast<const uint8_t *>(s.substr(0, size).data()), size);
+        s = s.substr(size);
+
+        while (nextSymIdxIdx < symbolIndices.size()) {
+          uint32_t symIndex = symbolIndices[nextSymIdxIdx];
+          const NList &sym = nList[symIndex];
+          uint64_t subsecAddr = sectionAddr + off;
+          if (sym.n_value >= subsecAddr + size)
+            break;
+          nextSymIdxIdx++;
+          StringRef name = strtab + sym.n_strx;
+          uint64_t symbolOffset = sym.n_value - subsecAddr;
+          symbols[symIndex] =
+              createDefined(sym, name, isec, symbolOffset, size - symbolOffset);
+        }
+
+        if (s.empty())
+          break;
+
+        auto *nextIsec = make<InputSection>(*isec);
+        nextIsec->numRefs = 0;
+        nextIsec->wasCoalesced = false;
+        off += size;
+        subsecMap.push_back({off, nextIsec});
+        subsecEntry = subsecMap.back();
+      }
+      continue;
+    }
+
     for (size_t j = 0; j < symbolIndices.size(); ++j) {
       uint32_t symIndex = symbolIndices[j];
       const NList &sym = nList[symIndex];
       StringRef name = strtab + sym.n_strx;
       InputSection *isec = subsecEntry.isec;
 
       uint64_t subsecAddr = sectionAddr + subsecEntry.offset;
       uint64_t symbolOffset = sym.n_value - subsecAddr;