[lld/mac] Add support for segment$start$ and segment$end$ symbols

[thakis]

Summary

These symbols are somewhat interesting in that they create non-existing
segments, which as far as I know is the only way to create segments
that don't contain any sections.

Final part of part of PR50760. Like D106629, but for segments instead
of sections. I'm not aware of anything that needs this in practice.

[int3]

Nice!

lld/test/MachO/start-end.s

189–198

maybe --implicit-check-not=segment$ would be terser?

399–409

nit: standardize whether we are using # or ##

[thakis]

lld/test/MachO/start-end.s

189–198

It tests a lot of output. With --implicit-check-not=segment$ it's not always clear where it's supposed to not match when there's a lot of output.

399–409

Done.

lld/MachO/OutputSegment.h

 //===- OutputSegment.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_SEGMENT_H
 #define LLD_MACHO_OUTPUT_SEGMENT_H
 
 #include "OutputSection.h"
+#include "Symbols.h"
 #include "lld/Common/LLVM.h"
+#include "llvm/ADT/TinyPtrVector.h"
 
 #include <limits>
 #include <vector>
 
 namespace lld {
 namespace macho {
 
 namespace segment_names {

 
 class OutputSection;
 class InputSection;
 
 class OutputSegment {
 public:
   void addOutputSection(OutputSection *os);
   void sortOutputSections();
+  void assignAddressesToStartEndSymbols();
 
   const std::vector<OutputSection *> &getSections() const { return sections; }
   size_t numNonHiddenSections() const;
 
   uint64_t fileOff = 0;
   uint64_t fileSize = 0;
   uint64_t addr = 0;
   uint64_t vmSize = 0;
   int inputOrder = UnspecifiedInputOrder;
   StringRef name;
   uint32_t maxProt = 0;
   uint32_t initProt = 0;
   uint8_t index;
 
+  llvm::TinyPtrVector<Defined *> segmentStartSymbols;
+  llvm::TinyPtrVector<Defined *> segmentEndSymbols;
+
 private:
   std::vector<OutputSection *> sections;
 };
 
 extern std::vector<OutputSegment *> outputSegments;
 
 void sortOutputSegments();
 
 OutputSegment *getOrCreateOutputSegment(StringRef name);
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/OutputSegment.cpp

 //===- OutputSegment.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 "OutputSegment.h"
 #include "ConcatOutputSection.h"
 #include "InputSection.h"
+#include "Symbols.h"
 #include "SyntheticSections.h"
 
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/BinaryFormat/MachO.h"
 
 using namespace llvm;

 }
 
 void OutputSegment::sortOutputSections() {
   // Must be stable_sort() to keep special sections such as
   // S_THREAD_LOCAL_REGULAR in input order.
   llvm::stable_sort(sections, compareByOrder<OutputSection *>(sectionOrder));
 }
 
+void OutputSegment::assignAddressesToStartEndSymbols() {
+  for (Defined *d : segmentStartSymbols)
+    d->value = addr;
+  for (Defined *d : segmentEndSymbols)
+    d->value = addr + vmSize;
+}
+
 void macho::sortOutputSegments() {
   llvm::stable_sort(outputSegments,
                     compareByOrder<OutputSegment *>(segmentOrder));
 }
 
 static DenseMap<StringRef, OutputSegment *> nameToOutputSegment;
 std::vector<OutputSegment *> macho::outputSegments;
 

lld/MachO/SymbolTable.cpp

Defined *SymbolTable::addSynthetic(StringRef name, InputSection *isec,
   return s;
 }
 
 enum class Boundary {
   Start,
   End,
 };
 
+static Defined *createBoundarySymbol(const Undefined &sym) {
+  return symtab->addSynthetic(
+      sym.getName(), /*isec=*/nullptr, /*value=*/-1, /*isPrivateExtern=*/true,
+      /*includeInSymtab=*/false, /*referencedDynamically=*/false);
+}
+
 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
if (!osec) {
     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);
+    osec->sectionStartSymbols.push_back(createBoundarySymbol(sym));
   else
-    osec->sectionEndSymbols.push_back(boundarySym);
+    osec->sectionEndSymbols.push_back(createBoundarySymbol(sym));
 }
 
 static void handleSegmentBoundarySymbol(const Undefined &sym, StringRef segName,
                                         Boundary which) {
-  // FIXME
-  error("segment$start$ and segment$end$ symbols are not yet implemented");
+  OutputSegment *seg = getOrCreateOutputSegment(segName);
+  if (which == Boundary::Start)
+    seg->segmentStartSymbols.push_back(createBoundarySymbol(sym));
+  else
+    seg->segmentEndSymbols.push_back(createBoundarySymbol(sym));
 }
 
 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$"))

lld/MachO/Writer.cpp

for (OutputSegment *seg : outputSegments) {
     // codesign / libstuff checks for segment ordering by verifying that
     // `fileOff + fileSize == next segment fileOff`. So we call alignTo() before
     // (instead of after) computing fileSize to ensure that the segments are
     // contiguous. We handle addr / vmSize similarly for the same reason.
     fileOff = alignTo(fileOff, pageSize);
     addr = alignTo(addr, pageSize);
     seg->vmSize = addr - seg->addr;
     seg->fileSize = fileOff - seg->fileOff;
+    seg->assignAddressesToStartEndSymbols();
   }
 }
 
 void Writer::finalizeLinkEditSegment() {
   TimeTraceScope timeScope("Finalize __LINKEDIT segment");
   // Fill __LINKEDIT contents.
   std::vector<LinkEditSection *> linkEditSections{
       in.rebase,

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: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/seg.s -o %t/seg.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'

 # 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]]
 
+###############################################################################
+## Test segment$start and segment$end.
+
+# RUN: %lld -lSystem %t/seg.o -o %t.seg.out \
+# RUN:    -rename_segment __FOO __BAZ \
+# RUN:    -rename_segment __WHAT __FOO \
+# RUN:    -u 'segment$start$__UFLAG_SEG' \
+# RUN:    -e 'segment$start$__TEXT'
+# RUN: llvm-objdump --macho --syms %t.seg.out > %t-seg-dump.txt
+## llvm-objdump can't dump segment names; use lld-otool for this.
+# RUN: llvm-otool -l %t.seg.out | grep -A6 LC_SEGMENT >> %t-seg-dump.txt
+# RUN: llvm-objdump --macho -d --no-symbolic-operands --no-show-raw-insn %t.seg.out >> %t-seg-dump.txt
+# RUN: llvm-objdump --macho --function-starts %t.out >> %t-seg-dump.txt
+# RUN: FileCheck %s --check-prefix=SEG < %t-seg-dump.txt
+
+# SEG-LABEL: SYMBOL TABLE:
+# SEG-NOT: segment$start$__TEXT
+# SEG-NOT: segment$end$__TEXT
+# SEG-NOT: segment$start$__FOO
+# SEG-NOT: segment$end$__FOO
+# SEG-NOT: segment$start$__BAZ
+# SEG-NOT: segment$end$__BAZ
+# SEG-NOT: segment$start$__WHAT
+# SEG-NOT: segment$end$__WHAT
+# SEG-NOT: segment$start$__UFLAG_SEG
+# SEG-NOT: segment$start$__UFLAG_SEG
+# SEG: segment$start$REGULAR
+# SEG: segment$end$REGULAR
+
+# SEG:           cmd LC_SEGMENT_64
+# SEG-NEXT:  cmdsize
+# SEG-NEXT:  segname __PAGEZERO
+
+# SEG:           cmd LC_SEGMENT_64
+# SEG-NEXT:  cmdsize
+# SEG-NEXT:  segname __TEXT
+# SEG-NEXT:   vmaddr 0x[[#%x, TEXTSTART:]]
+# SEG-NEXT:   vmsize 0x[[#%x, TEXTSIZE:]]
+
+# SEG:           cmd LC_SEGMENT_64
+# SEG-NEXT:  cmdsize
+# SEG-NEXT:  segname __BAZ
+# SEG-NEXT:   vmaddr 0x[[#%x, BAZSTART:]]
+# SEG-NEXT:   vmsize 0x[[#%x, BAZSIZE:]]
+
+# SEG:           cmd LC_SEGMENT_64
+# SEG-NEXT:  cmdsize
+# SEG-NEXT:  segname __FOO
+# SEG-NEXT:   vmaddr 0x[[#%x, FOOSTART:]]
+# SEG-NEXT:   vmsize 0x[[#%x, FOOSIZE:]]
+
+# SEG:           cmd LC_SEGMENT_64
+# SEG-NEXT:  cmdsize
+# SEG-NEXT:  segname __UFLAG_SEG
+# SEG-NEXT:   vmaddr 0x[[#%x, UFLAGSTART:]]
+# SEG-NEXT:   vmsize 0x0000000000000000
+
+# SEG:           cmd LC_SEGMENT_64
+# SEG-NEXT:  cmdsize
+# SEG-NEXT:  segname ASDF
+# SEG-NEXT:   vmaddr 0x[[#%x, ASDFSTART:]]
+# SEG-NEXT:   vmsize 0x0000000000000000
+
+# SEG: _main
+
+## segment$start$__TEXT / segment$end$__TEXT
+# SEG:      [[#%x, PC1:]]:
+# SEG-SAME: leaq [[#%d, TEXTSTART - PC1 - 7]](%rip), %rax
+# SEG-NEXT: [[#%x, PC2:]]:
+# SEG-SAME: leaq [[#%d, TEXTSTART + TEXTSIZE - PC2 - 7]](%rip), %rbx
+
+## segment$start$__FOO / segment$end$__FOO, which is renamed to __BAZ
+# SEG:      [[#%x, PC3:]]:
+# SEG-SAME: leaq [[#%d, BAZSTART - PC3 - 7]](%rip), %rax
+# SEG-NEXT: [[#%x, PC4:]]:
+# SEG-SAME: leaq [[#%d, BAZSTART + BAZSIZE - PC4 - 7]](%rip), %rbx
+
+## segment$start$__BAZ / segment$end$__BAZ
+# SEG:      [[#%x, PC5:]]:
+# SEG-SAME: leaq [[#%d, BAZSTART - PC5 - 7]](%rip), %rax
+# SEG-NEXT: [[#%x, PC6:]]:
+# SEG-SAME: leaq [[#%d, BAZSTART + BAZSIZE - PC6 - 7]](%rip), %rbx
+
+## segment$start$__WHAT / segment$end$__WHAT, which is renamed to __FOO
+# SEG:      [[#%x, PC7:]]:
+# SEG-SAME: leaq [[#%d, FOOSTART - PC7 - 7]](%rip), %rax
+# SEG-NEXT: [[#%x, PC8:]]:
+# SEG-SAME: leaq [[#%d, FOOSTART + FOOSIZE - PC8 - 7]](%rip), %rbx
+
+## segment$start$ASDF / segment$end$ASDF
+# SEG:      [[#%x, PC9:]]:
+# SEG-SAME: leaq [[#%d, ASDFSTART - PC9 - 7]](%rip), %rax
+# SEG-NEXT: [[#%x, PC10:]]:
+# SEG-SAME: leaq [[#%d, ASDFSTART - PC10 - 7]](%rip), %rbx
+
 #--- order.txt
 _otherfun
 _main
 section$end$__TEXT$__text
 section$start$__TEXT$__text
 
 #--- main.s
 .zerofill __MYBSS,__mybss,_zero_foo,0x8000

 section$start$ACTUAL$symbol:
 .fill 1
 
 .globl section$end$ACTUAL$symbol
 section$end$ACTUAL$symbol:
 .fill 1
 
 .subsections_via_symbols
+
+#--- seg.s
+## Renamed to __BAZ,__bar by -rename_segment
+.section __FOO,__bar
+.space 1
+
+## Renamed to __FOO,__ever by -rename_segment
+.section __WHAT,__ever
+.space 1
+
+.text
+.globl segment$start$REGULAR
+segment$start$REGULAR:
+  retq
+
+.globl segment$end$REGULAR
+segment$end$REGULAR:
+  retq
+
+.globl _main
+_main:
+  movq segment$start$__TEXT@GOTPCREL(%rip), %rax
+  movq segment$end$__TEXT@GOTPCREL(%rip), %rbx
+
+  movq segment$start$__FOO@GOTPCREL(%rip), %rax
+  movq segment$end$__FOO@GOTPCREL(%rip), %rbx
+
+  movq segment$start$__BAZ@GOTPCREL(%rip), %rax
+  movq segment$end$__BAZ@GOTPCREL(%rip), %rbx
+
+  # (These two lines make ld64 crash linking the .o file.
+  # The rest of the test works with ld64 too.)
+  movq segment$start$__WHAT@GOTPCREL(%rip), %rax
+  movq segment$end$__WHAT@GOTPCREL(%rip), %rbx
+
+  # References to non-existing segments create that segment,
+  # without any sections in it.
+  movq segment$start$ASDF@GOTPCREL(%rip), %rax
+  movq segment$end$ASDF@GOTPCREL(%rip), %rbx
+
+  ## Non-undefined symbols don't create segments.
+  callq segment$start$REGULAR
+  callq segment$end$REGULAR
+
+  ret
+
+.section __TEXT,__fill
+.space 578
+
+.subsections_via_symbols