[lld/mac] Implement for section$start and section$ end symbols

[thakis]

Summary

With this, libclang_rt.profile_osx.a can be linked, that is coverage
and PGO-instrumented builds should now work with lld.

section$start and section$end symbols can create non-existing sections.
They're also undefined symbols that are only magic if there isn't a
regular symbol with their name, which means the need to be handled
in treatUndefined() instead of just looping over all existing
sections and adding start and end symbols like the ELF port does.

To represent the actual symbols, this uses absolute symbols that
get their value updated once an output section is layed out.

segment$start and segment$end are still missing for now, but they produce a
nicer error message after this patch.

Main part of PR50760.

[thakis]

Here's a coverage report of "check-lld" made with lld with this patch as host linker. (Built lld without coverage with this patch, then build everything again with coverage, and using the lld from the first build as linker): https://drive.google.com/file/d/1D8Zmd45neE-_S2I4Yu2veaZLhy6CPZv3/view?usp=sharing Decent test coverage!

[thakis]

In D106629#2898943, @thakis wrote:

Here's a coverage report of "check-lld" made with lld with this patch as host linker. (Built lld without coverage with this patch, then build everything again with coverage, and using the lld from the first build as linker): https://drive.google.com/file/d/1D8Zmd45neE-_S2I4Yu2veaZLhy6CPZv3/view?usp=sharing Decent test coverage!

For comparison, here's the same report with ld as host linker. Things look pretty similar, so that's good :) ld shows more lines in ELF CallGraphSort.cpp, lld more in COFF. Maybe those get partially ICF'd, or the runtime gets confused by these files containing functions with the same names (in unnamed namespaces each, so shouldn't be an ODR issue).

[int3]

lld/MachO/OutputSection.h

71–72

when will we have more than one symbol here?

also, if we're usually going to have just one element, since a TinyPtrVector better?

lld/MachO/SymbolTable.cpp

243

shouldn't we be passing in a non-null isec here?

lld/test/MachO/start-end.s

73–79

😂

[thakis]

tinyptrvector

lld/MachO/OutputSection.h

71–72

when will we have more than one symbol here?

e.g. if you have section$start$FOO$bar and section$start$BAZ$quux and sectrename FOO bar BAZ quux -- both symbols will refer to the same section.

also, if we're usually going to have just one element, since a TinyPtrVector better?

There are on the order of 10 OutputSections so I don't think we _really_ need to worry about its size. But sure, done, and TIL about TinyPtrVector :) (It means we have to include Symbols.h in the header, but /shruggie)

lld/MachO/SymbolTable.cpp

243

To me this semantically seems like an absolute symbol, and absolute symbols don't have isec. Defined::getVA() has an early exit for absolute symbols which is attractive since I don't want any isec-based adjustments for the address.

[oontvoo]

Nice! Thanks!

lld/MachO/SymbolTable.cpp

219

What about section$start$__DATA$__<....> ?

[thakis]

lld/MachO/SymbolTable.cpp

219

That's usually a ConcatInputSection. The "create new used" branch below works for those. (We could walk through the existing isecs and not alloc a new one if we find one with the right name, but that's more code and more chance or something to go wrong, with little benefit, so I didn't do that. An earlier version of this patch on the linked PR did that, but it's not necessary so I got rid of it.) __DATA is covered by the test below, too.

[int3]

lgtm, though I'm a bit confused about how the symbol liveness is working out

lld/MachO/SymbolTable.cpp

219

243

hmm, but the comment above says that "The replacing Defined gets its liveness from the underlying isec" -- how does that work if the isec isn't set here?

lld/test/MachO/start-end.s

142

261

would it be worthwhile to add a zerofill section to the test, to make sure the $end symbol occurs after the zeroes?

[oontvoo]

LGTM thanks!

[thakis]

Thanks!

lld/MachO/SymbolTable.cpp

243

That's an excellent question! I wrote the comment when there was still a backing isec. Absolute defineds get their liveness from the used bit on the superclass, so https://reviews.llvm.org/D106565 made that part work. We still need an explicitly-live isec to make sure that the OutputSection the new symbol is added to is emitted. I adjusted the comment.

lld/test/MachO/start-end.s

261

Sure, done. Seems to Just Work, but yes, that's a good thing to test.

[oontvoo]

lld/test/MachO/start-end.s

261

"Just Work", famous last words 🤔

[thakis]

This comment has been deleted.

lld/test/MachO/start-end.s

142

Whoops, missed this. Fixed in a follow-up.

261

I'm sure I managed to hide a bug or two somewhere :)

lld/MachO/OutputSection.h

 //===- OutputSection.h ------------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_MACHO_OUTPUT_SECTION_H
 #define LLD_MACHO_OUTPUT_SECTION_H
 
+#include "Symbols.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/TinyPtrVector.h"
 
 #include <limits>
 
 namespace lld {
 namespace macho {
 
+class Defined;
 class InputSection;
 class OutputSegment;
 
 // The default order value for OutputSections that are not constructed from
 // InputSections (i.e. SyntheticSections). We make it less than INT_MAX in order
 // not to conflict with the ordering of zerofill sections, which must always be
 // placed at the end of their segment.
 constexpr int UnspecifiedInputOrder = std::numeric_limits<int>::max() - 1024;
public:
 
   virtual void finalize() {
     // TODO investigate refactoring synthetic section finalization logic into
     // overrides of this function.
   }
 
   virtual void writeTo(uint8_t *buf) const = 0;
 
+  void assignAddressesToStartEndSymbols();
+
   StringRef name;
+  llvm::TinyPtrVector<Defined *> sectionStartSymbols;
+  llvm::TinyPtrVector<Defined *> sectionEndSymbols;
   OutputSegment *parent = nullptr;
   // For output sections that don't have explicit ordering requirements, their
   // output order should be based on the order of the input sections they
   // contain.
   int inputOrder = UnspecifiedInputOrder;
 
   uint32_t index = 0;
   uint64_t addr = 0;

lld/MachO/OutputSection.cpp

 
 using namespace llvm;
 using namespace lld;
 using namespace lld::macho;
 
 uint64_t OutputSection::getSegmentOffset() const {
   return addr - parent->addr;
 }
+
+void OutputSection::assignAddressesToStartEndSymbols() {
+  for (Defined *d : sectionStartSymbols)
+    d->value = addr;
+  for (Defined *d : sectionEndSymbols)
+    d->value = addr + getSize();
+}

lld/MachO/SymbolTable.cpp

 //===- SymbolTable.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 "SymbolTable.h"
+#include "ConcatOutputSection.h"
 #include "Config.h"
 #include "InputFiles.h"
 #include "Symbols.h"
+#include "SyntheticSections.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 
 using namespace llvm;
 using namespace lld;
 using namespace lld::macho;
 
 Symbol *SymbolTable::find(CachedHashStringRef cachedName) {
Defined *SymbolTable::addSynthetic(StringRef name, InputSection *isec,
   Defined *s = addDefined(name, nullptr, isec, value, /*size=*/0,
                           /*isWeakDef=*/false, isPrivateExtern,
                           /*isThumb=*/false, referencedDynamically,
                           /*noDeadStrip=*/false);
   s->includeInSymtab = includeInSymtab;
   return s;
 }
 
+enum class Boundary {
+  Start,
+  End,
+};
+
+static void handleSectionBoundarySymbol(const Undefined &sym, StringRef segSect,
+                                        Boundary which) {
+  StringRef segName, sectName;
+  std::tie(segName, sectName) = segSect.split('$');
+
+  // Attach the symbol to any InputSection that will end up in the right
+  // OutputSection -- it doesn't matter which one we pick.
+  // Don't bother looking through inputSections for a matching
+  // ConcatInputSection -- we need to create ConcatInputSection for
+  // non-existing sections anyways, and that codepath works even if we should
+  // already have a ConcatInputSection with the right name.
+
+  OutputSection *osec = nullptr;
+  // This looks for __TEXT,__cstring etc.
+  for (SyntheticSection *ssec : syntheticSections)
+    if (ssec->segname == segName && ssec->name == sectName) {
+      osec = ssec->isec->parent;
+      break;
+    }
+
+  if (!osec) {
+    ConcatInputSection *isec = make<ConcatInputSection>(segName, sectName);
+
+    // This runs after markLive() and is only called for Undefineds that are
+    // live. Marking the isec live ensures an OutputSection is created that the
+    // start/end symbol can refer to.
+    assert(sym.isLive());
+    isec->live = true;
+
+    // This runs after gatherInputSections(), so need to explicitly set parent
+    // and add to inputSections.
+    osec = isec->parent = ConcatOutputSection::getOrCreateForInput(isec);
+    inputSections.push_back(isec);
+  }
+
+  Defined *boundarySym = symtab->addSynthetic(
+      sym.getName(), /*isec=*/nullptr, /*value=*/-1, /*isPrivateExtern=*/true,
+      /*includeInSymtab=*/false, /*referencedDynamically=*/false);
+  if (which == Boundary::Start)
+    osec->sectionStartSymbols.push_back(boundarySym);
+  else
+    osec->sectionEndSymbols.push_back(boundarySym);
+}
+
+static void handleSegmentBoundarySymbol(const Undefined &sym, StringRef segName,
+                                        Boundary which) {
+  // FIXME
+  error("segment$start$ and segment$end$ symbols are not yet implemented");
+}
+
 void lld::macho::treatUndefinedSymbol(const Undefined &sym, StringRef source) {
+  // Handle start/end symbols.
+  StringRef name = sym.getName();
+  if (name.consume_front("section$start$"))
+    return handleSectionBoundarySymbol(sym, name, Boundary::Start);
+  if (name.consume_front("section$end$"))
+    return handleSectionBoundarySymbol(sym, name, Boundary::End);
+  if (name.consume_front("segment$start$"))
+    return handleSegmentBoundarySymbol(sym, name, Boundary::Start);
+  if (name.consume_front("segment$end$"))
+    return handleSegmentBoundarySymbol(sym, name, Boundary::End);
+
   // Handle -U.
   if (config->explicitDynamicLookups.count(sym.getName())) {
     symtab->addDynamicLookup(sym.getName());
     return;
   }
 
   // Handle -undefined.
   auto message = [source, &sym]() {

lld/MachO/Writer.cpp

if (relocAttrs.hasAttr(RelocAttrBits::BRANCH)) {
     // need of rebase opcodes.
     if (!(isThreadLocalVariables(isec->getFlags()) && isa<Defined>(sym)))
       addNonLazyBindingEntries(sym, isec, r.offset, r.addend);
   }
 }
 
 void Writer::scanRelocations() {
   TimeTraceScope timeScope("Scan relocations");
-  for (ConcatInputSection *isec : inputSections) {
+
+  // This can't use a for-each loop: It calls treatUndefinedSymbol(), which can
+  // add to inputSections, which invalidates inputSections's iterators.
+  for (size_t i = 0; i < inputSections.size(); ++i) {
+    ConcatInputSection *isec = inputSections[i];
+
     if (isec->shouldOmitFromOutput())
       continue;
 
     for (auto it = isec->relocs.begin(); it != isec->relocs.end(); ++it) {
       Reloc &r = *it;
       if (target->hasAttr(r.type, RelocAttrBits::SUBTRAHEND)) {
         // Skip over the following UNSIGNED relocation -- it's just there as the
         // minuend, and doesn't have the usual UNSIGNED semantics. We don't want
void Writer::assignAddresses(OutputSegment *seg) {
   for (OutputSection *osec : seg->getSections()) {
     if (!osec->isNeeded())
       continue;
     addr = alignTo(addr, osec->align);
     fileOff = alignTo(fileOff, osec->align);
     osec->addr = addr;
     osec->fileOff = isZeroFill(osec->flags) ? 0 : fileOff;
     osec->finalize();
+    osec->assignAddressesToStartEndSymbols();
 
     addr += osec->getSize();
     fileOff += osec->getFileSize();
   }
 }
 
 void Writer::openFile() {
   Expected<std::unique_ptr<FileOutputBuffer>> bufferOrErr =

lld/test/MachO/start-end.s

+# REQUIRES: x86
+
+## FIXME: Add tests for segment$start$foo, segment$end$foo once implemented.
+
+# RUN: rm -rf %t; split-file %s %t
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/main.s -o %t/main.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/foo.s -o %t/foo.o
+
+# RUN: %lld -lSystem %t/main.o %t/foo.o -o %t.out \
+# RUN:    -rename_section __FOO __bar __BAZ __quux \
+# RUN:    -rename_section __WHAT __ever __FOO __bar \
+# RUN:    -u 'section$start$__UFLAG_SEG$__uflag_sect' \
+# RUN:    -U 'section$start$__DYNAMIC$__lookup' \
+# RUN:    -U 'section$start$__DYNAMIC$__unref' \
+# RUN:    -e 'section$start$__TEXT$__text'
+# RUN: llvm-objdump --macho --syms --section-headers %t.out > %t-dump.txt
+# RUN: llvm-objdump --macho -d --no-symbolic-operands --no-show-raw-insn %t.out >> %t-dump.txt
+# RUN: llvm-objdump --macho --function-starts %t.out >> %t-dump.txt
+# RUN: FileCheck %s < %t-dump.txt
+
+## Setting the entry point to the start of the __text section should
+## set it to _main, since that's the first function in that section.
+# RUN: llvm-objdump --macho --syms --all-headers %t.out \
+# RUN:   | FileCheck --check-prefix=MAINENTRY %s
+# MAINENTRY:      [[#%x, MAINADDR:]] g     F __TEXT,__text _main
+# MAINENTRY:      LC_MAIN
+# MAINENTRY-NEXT: cmdsize
+# MAINENTRY-NEXT: entryoff [[#%d, MAINADDR - 0x100000000]]
+
+## Nothing should change if we reorder two functions in the text segment.
+## (Reorder some section$start/end symbols too for good measure.)
+# RUN: %lld -lSystem %t/main.o %t/foo.o -o %t.ordered.out \
+# RUN:    -order_file %t/order.txt \
+# RUN:    -rename_section __FOO __bar __BAZ __quux \
+# RUN:    -rename_section __WHAT __ever __FOO __bar \
+# RUN:    -u 'section$start$__UFLAG_SEG$__uflag_sect' \
+# RUN:    -U 'section$start$__DYNAMIC$__lookup' \
+# RUN:    -U 'section$start$__DYNAMIC$__unref' \
+# RUN:    -e 'section$start$__TEXT$__text'
+# RUN: llvm-objdump --macho --syms --section-headers %t.ordered.out > %t-ordered-dump.txt
+# RUN: llvm-objdump --macho -d --no-symbolic-operands --no-show-raw-insn %t.ordered.out >> %t-ordered-dump.txt
+# RUN: llvm-objdump --macho --function-starts %t.out >> %t-ordered-dump.txt
+# RUN: FileCheck %s < %t-ordered-dump.txt
+
+## `-undefined dynamic_lookup` also shouldn't change anything.
+# RUN: %lld -lSystem %t/main.o %t/foo.o -o %t.dl.out -undefined dynamic_lookup \
+# RUN:    -rename_section __FOO __bar __BAZ __quux \
+# RUN:    -rename_section __WHAT __ever __FOO __bar \
+# RUN:    -u 'section$start$__UFLAG_SEG$__uflag_sect' \
+# RUN:    -U 'section$start$__DYNAMIC$__lookup' \
+# RUN:    -U 'section$start$__DYNAMIC$__unref' \
+# RUN:    -e 'section$start$__TEXT$__text'
+# RUN: llvm-objdump --macho --syms --section-headers %t.dl.out > %t-dump.dl.txt
+# RUN: llvm-objdump --macho -d --no-symbolic-operands --no-show-raw-insn %t.dl.out >> %t-dump.dl.txt
+# RUN: llvm-objdump --macho --function-starts %t.out >> %t-dump.dl.txt
+# RUN: FileCheck %s < %t-dump.dl.txt
+
+## ...except that the entry point is now _otherfun instead of _main since
+## _otherfun is now at the start of the __text section.
+# RUN: llvm-objdump --macho --syms --all-headers %t.ordered.out \
+# RUN:   | FileCheck --check-prefix=OTHERENTRY %s
+# OTHERENTRY:      [[#%x, OTHERADDR:]] g     F __TEXT,__text _otherfun
+# OTHERENTRY:      LC_MAIN
+# OTHERENTRY-NEXT: cmdsize
+# OTHERENTRY-NEXT: entryoff [[#%d, OTHERADDR - 0x100000000]]
+
+
+## Test that the link succeeds with dead-stripping enabled too.
+# RUN: %lld -dead_strip -lSystem %t/main.o -o %t/stripped.out
+
+## (Fun fact: `-e 'section$start$__TEXT$__text -dead_strip` strips
+## everything in the text section because markLive runs well before
+## section$start symbols are replaced, so the entry point is just
+## an undefined symbol that keeps nothing alive, and then later it
+## sets the entry point to the start of the now-empty text section
+## and the output program crashes when running. This matches ld64's
+## behavior.)
+
+# CHECK-LABEL: Sections:
+# CHECK-NEXT:  Idx Name           Size     VMA              Type
+# CHECK:       0 __text           {{[0-9a-f]*}} [[#%x, TEXTSTART:]] TEXT
+# CHECK:       1 __aftertext      {{[0-9a-f]*}} [[#%x, TEXTEND:]]
+# CHECK:       2 __cstring        {{[0-9a-f]*}} [[#%x, CSTRINGSTART:]] DATA
+# CHECK:       3 __aftercstring   {{[0-9a-f]*}} [[#%x, CSTRINGEND:]]
+# CHECK:       4 __data           00000008      [[#%x, DATASTART:]] DATA
+# CHECK:       5 __llvm_orderfile 00000000      [[#%x, LLVMORDERFILESTART:]] DATA
+# CHECK:       6 __mybss          00008000      [[#%x, MYBSSSTART:]] BSS
+# CHECK:       7 __quux           0000002a      [[#%x, QUUXSTART:]]
+# CHECK:       8 __bar            00000059      [[#%x, BARSTART:]]
+# CHECK:       9 __uflag_sect     00000000
+# CHECK:       10 __lookup        00000000
+# CHECK-NOT:   symbol
+# CHECK-NOT:   __unref
+
+# CHECK-LABEL: SYMBOL TABLE:
+# CHECK-NOT: section$start$__TEXT$__text
+# CHECK-NOT: section$end$__TEXT$__text
+# CHECK-NOT: section$start$__TEXT$__cstring
+# CHECK-NOT: section$end$__TEXT$__cstring
+# CHECK-NOT: section$start$__DATA$__data
+# CHECK-NOT: section$end$__DATA$__data
+# CHECK-NOT: section$start$__DATA$__llvm_orderfile
+# CHECK-NOT: section$end$__DATA$__llvm_orderfile
+# CHECK-NOT: section$start$__DYNAMIC$__lookup
+# CHECK-NOT: section$start$__DYNAMIC$__unref
+# CHECK: section$end$ACTUAL$symbol
+# CHECK: section$start$ACTUAL$symbol
+
+# CHECK-LABEL: _main:
+
+## The CHECK-SAMEs work around FileCheck's
+## "error: numeric variable 'PC2' defined earlier in the same CHECK directive"
+## limitation.
+## The 7s are the length of a leaq instruction.
+## section$start$__TEXT$__text / section$end$__TEXT$__text
+
+# CHECK:      [[#%x, PC1:]]:
+# CHECK-SAME: leaq [[#%d, TEXTSTART - PC1 - 7]](%rip), %rax
+# CHECK-NEXT: [[#%x, PC2:]]:
+# CHECK-SAME: leaq [[#%d, TEXTEND - PC2 - 7]](%rip), %rbx
+
+## section$start$__TEXT$__cstring / section$end$__TEXT$__cstring
+# CHECK:      [[#%x, PC3:]]:
+# CHECK-SAME: leaq [[#%d, CSTRINGSTART - PC3 - 7]](%rip), %rax
+# CHECK-NEXT: [[#%x, PC4:]]:
+# CHECK-SAME: leaq [[#%d, CSTRINGEND - PC4 - 7]](%rip), %rbx
+
+## section$start$__DATA$__data / section$end$__DATA$__data
+# CHECK:      [[#%x, PC5:]]:
+# CHECK-SAME: leaq [[#%d, DATASTART - PC5 - 7]](%rip), %rax
+# CHECK-NEXT: [[#%x, PC6:]]:
+# CHECK-SAME: leaq [[#%d, DATASTART + 8 - PC6 - 7]](%rip), %rbx
+
+## section$start$__MYBSS$__mybss / section$end$__MYBSS$__mybss
+# CHECK:      [[#%x, PC7:]]:
+# CHECK-SAME: leaq [[#%d, MYBSSSTART - PC7 - 7]](%rip), %rax
+# CHECK-NEXT: [[#%x, PC8:]]:
+# CHECK-SAME: leaq [[#%d, MYBSSSTART + 0x8000 - PC8 - 7]](%rip), %rbx
+
+## section$start$__DATA$__llvm_orderfile / section$end$__DATA$__llvm_orderfile
+## This section has size 0.
+# CHECK:      [[#%x, PC9:]]:
+# CHECK-SAME: leaq [[#%d, LLVMORDERFILESTART - PC9 - 7]](%rip), %rax
+# CHECK-NEXT: [[#%x, PC10:]]:
+# CHECK-SAME: leaq [[#%d, LLVMORDERFILESTART - PC10 - 7]](%rip), %rbx
+
+## Secton-rename tests.
+## Input section __FOO/__bar is renamed to output section
+## __BAZ/__quux by a -rename_section flag.
+## section$start$__FOO$__bar ends up referring to the __BAZ/__quux section.
+# CHECK:      [[#%x, PC11:]]:
+# CHECK-SAME: leaq [[#%d, QUUXSTART - PC11 - 7]](%rip), %rax
+# CHECK-NEXT: [[#%x, PC12:]]:
+# CHECK-SAME: leaq [[#%d, QUUXSTART + 42 - PC12 - 7]](%rip), %rbx
+## section$start$__BAZ$__quux also refers to the __BAZ/__quux section.
+# CHECK:      [[#%x, PC13:]]:
+# CHECK-SAME: leaq [[#%d, QUUXSTART - PC13 - 7]](%rip), %rax
+# CHECK-NEXT: [[#%x, PC14:]]:
+# CHECK-SAME: leaq [[#%d, QUUXSTART + 42 - PC14 - 7]](%rip), %rbx
+## Input section __WHAT/__ever is renamed to output section
+## __FOO/__bar by a -rename_section flag.
+## section$start$__WHAT$__ever ends up referring to the __FOO/__bar section.
+# CHECK:      [[#%x, PC15:]]:
+# CHECK-SAME: leaq [[#%d, BARSTART - PC15 - 7]](%rip), %rax
+# CHECK-NEXT: [[#%x, PC16:]]:
+# CHECK-SAME: leaq [[#%d, BARSTART + 89 - PC16 - 7]](%rip), %rbx
+
+## The function_starts section should not have an entry for the
+## section$end$__TEXT$__text symbol.
+# CHECK: [[#%.16x, TEXTSTART]]
+# CHECK-NOT: [[#%.16x, TEXTEND]]
+
+#--- order.txt
+_otherfun
+_main
+section$end$__TEXT$__text
+section$start$__TEXT$__text
+
+#--- main.s
+.zerofill __MYBSS,__mybss,_zero_foo,0x8000
+
+.globl section$start$ACTUAL$symbol
+.globl section$end$ACTUAL$symbol
+
+## Renamed to __BAZ,__quux by -rename_section
+.section __FOO,__bar
+.space 42
+
+## Renamed to __FOO,__bar by -rename_section
+.section __WHAT,__ever
+.space 89
+
+.text
+.globl _main
+_main:
+  # Basics: start/end of existing, normal sections.
+
+  # For __TEXT/__text, these magic symbols shouldn't be
+  # included in __function_starts
+  movq section$start$__TEXT$__text@GOTPCREL(%rip), %rax
+  movq section$end$__TEXT$__text@GOTPCREL(%rip), %rbx
+
+  # __TEXT/__cstring are interesting because they're not ConcatInputSections.
+  movq section$start$__TEXT$__cstring@GOTPCREL(%rip), %rax
+  movq section$end$__TEXT$__cstring@GOTPCREL(%rip), %rbx
+
+  # Vanilla __DATA/__data
+  movq section$start$__DATA$__data@GOTPCREL(%rip), %rax
+  movq section$end$__DATA$__data@GOTPCREL(%rip), %rbx
+
+  # Vanilla zerofill.
+  movq section$start$__MYBSS$__mybss@GOTPCREL(%rip), %rax
+  movq section$end$__MYBSS$__mybss@GOTPCREL(%rip), %rbx
+
+  # Referring to a non-existent section wills it into existence.
+  # This is needed for e.g. __DATA/__llvm_orderfile in libclang_rt.profile.
+  # This means `-u` can be used as a janky `-sectcreate`.
+  movq section$start$__DATA$__llvm_orderfile@GOTPCREL(%rip), %rax
+  movq section$end$__DATA$__llvm_orderfile@GOTPCREL(%rip), %rbx
+
+  # Section-rename tests.
+  movq section$start$__FOO$__bar@GOTPCREL(%rip), %rax
+  movq section$end$__FOO$__bar@GOTPCREL(%rip), %rbx
+
+  movq section$start$__BAZ$__quux@GOTPCREL(%rip), %rax
+  movq section$end$__BAZ$__quux@GOTPCREL(%rip), %rbx
+
+  movq section$start$__WHAT$__ever@GOTPCREL(%rip), %rax
+  movq section$end$__WHAT$__ever@GOTPCREL(%rip), %rbx
+
+  # If there are actual symbols with the magic names, the magic
+  # names lose their magic and just refer to those symbols (and
+  # no section is implicitly created for them).
+  movq section$start$ACTUAL$symbol@GOTPCREL(%rip), %rax
+  movq section$end$ACTUAL$symbol@GOTPCREL(%rip), %rbx
+
+  # -U section$start is not exported as dynamic_lookup, it just
+  # creates a section like -u.
+  movq section$start$__DYNAMIC$__lookup@GOTPCREL(%rip), %rax
+  movq section$end$__DYNAMIC$__lookup@GOTPCREL(%rip), %rbx
+
+  ret
+
+.globl _otherfun
+_otherfun:
+  ret
+
+.section __TEXT,__aftertext
+.fill 1
+
+.cstring
+.asciz "foo"
+.asciz "barbaz"
+
+.section __TEXT,__aftercstring
+.fill 1
+
+.data
+.quad 0x1234
+
+.subsections_via_symbols
+
+#--- foo.s
+.text
+.globl section$start$ACTUAL$symbol
+section$start$ACTUAL$symbol:
+.fill 1
+
+.globl section$end$ACTUAL$symbol
+section$end$ACTUAL$symbol:
+.fill 1
+
+.subsections_via_symbols