[lld-macho] Ensure segments are laid out contiguously

[int3]

Summary

codesign/libstuff checks that the __LLVM segment is directly
before __LINKEDIT by checking that `fileOff + fileSize == next segment
fileOff`. Previously, there would be gaps between the segments due to
the fact that their fileOffs are page-aligned but their fileSizes
aren't. In order to satisfy codesign, we page-align fileOff *before*
calculating fileSize. (I don't think codesign checks for the relative
ordering of other segments, so in theory we could do this just for
__LLVM, but ld64 seems to do it for all segments.)

Note that we *don't* round up the fileSize of the __LINKEDIT segment.
Since it's the last segment, it doesn't need to worry about contiguity;
in addition, codesign checks that the last (hidden) section in
__LINKEDIT covers the last byte of the segment, so if we rounded up
__LINKEDIT's size we would have to do the same for its last section,
which is a bother.

While at it, I also addressed a FIXME in the linkedit-contiguity.s test
to cover more __LINKEDIT sections.

lld/MachO/OutputSegment.h

void sortOutputSections(
     llvm::stable_sort(sections, comparator);
   }
 
   const std::vector<OutputSection *> &getSections() const { return sections; }
   size_t numNonHiddenSections() const;
 
   uint64_t fileOff = 0;
   uint64_t fileSize = 0;
+  uint64_t vmSize = 0;
   StringRef name;
   uint32_t maxProt = 0;
   uint32_t initProt = 0;
   uint8_t index;
 
 private:
   std::vector<OutputSection *> sections;
 };

lld/MachO/Writer.cpp

void writeTo(uint8_t *buf) const override {
     c->fileoff = seg->fileOff;
     c->maxprot = seg->maxProt;
     c->initprot = seg->initProt;
 
     if (seg->getSections().empty())
       return;
 
     c->vmaddr = seg->firstSection()->addr;
-    c->vmsize =
-        seg->lastSection()->addr + seg->lastSection()->getSize() - c->vmaddr;
+    c->vmsize = seg->vmSize;
+    c->filesize = seg->fileSize;
     c->nsects = seg->numNonHiddenSections();
 
     for (const OutputSection *osec : seg->getSections()) {
-      if (!isZeroFill(osec->flags)) {
-        assert(osec->fileOff >= seg->fileOff);
-        c->filesize = std::max<uint64_t>(
-            c->filesize, osec->fileOff + osec->getFileSize() - seg->fileOff);
-      }
-
       if (osec->isHidden())
         continue;
 
       auto *sectHdr = reinterpret_cast<Section *>(buf);
       buf += sizeof(Section);
 
       memcpy(sectHdr->sectname, osec->name.data(), osec->name.size());
       memcpy(sectHdr->segname, name.data(), name.size());

 }
 
 static int segmentOrder(OutputSegment *seg) {
   return StringSwitch<int>(seg->name)
       .Case(segment_names::pageZero, -4)
       .Case(segment_names::text, -3)
       .Case(segment_names::dataConst, -2)
       .Case(segment_names::data, -1)
+      .Case(segment_names::llvm, std::numeric_limits<int>::max() - 1)
       // Make sure __LINKEDIT is the last segment (i.e. all its hidden
       // sections must be ordered after other sections).
       .Case(segment_names::linkEdit, std::numeric_limits<int>::max())
       .Default(0);
 }
 
 static int sectionOrder(OutputSection *osec) {
   StringRef segname = osec->parent->name;
template <class LP> void Writer::createOutputSections() {
   }
 
   // dyld requires __LINKEDIT segment to always exist (even if empty).
   linkEditSegment = getOrCreateOutputSegment(segment_names::linkEdit);
 }
 
 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.
   //
   // Note that at this point, __LINKEDIT sections are empty, but we need to
   // determine addresses of other segments/sections before generating its
   // contents.
-  for (OutputSegment *seg : outputSegments)
-    if (seg != linkEditSegment)
-      assignAddresses(seg);
+  for (OutputSegment *seg : outputSegments) {
+    if (seg == linkEditSegment)
+      continue;
+    // 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->firstSection()->addr;
+    seg->fileSize = fileOff - seg->fileOff;
+  }
 
   // FIXME(gkm): create branch-extension thunks here, then adjust addresses
 }
 
 void Writer::finalizeLinkEditSegment() {
   TimeTraceScope timeScope("Finalize __LINKEDIT segment");
   // Fill __LINKEDIT contents.
   std::vector<LinkEditSection *> linkEditSections{
       in.rebase,  in.binding,    in.weakBinding,        in.lazyBinding,
       in.exports, symtabSection, indirectSymtabSection, functionStartsSection,
   };
   parallelForEach(linkEditSections, [](LinkEditSection *osec) {
     if (osec)
       osec->finalizeContents();
   });
 
   // Now that __LINKEDIT is filled out, do a proper calculation of its
   // addresses and offsets.
   assignAddresses(linkEditSegment);
+  // No need to page-align fileOff / addr here since this is the last segment.
+  linkEditSegment->vmSize = addr - linkEditSegment->firstSection()->addr;
+  linkEditSegment->fileSize = fileOff - linkEditSegment->fileOff;
 }
 
 void Writer::assignAddresses(OutputSegment *seg) {
-  uint64_t pageSize = target->getPageSize();
-  addr = alignTo(addr, pageSize);
-  fileOff = alignTo(fileOff, pageSize);
   seg->fileOff = fileOff;
 
   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();
 
     addr += osec->getSize();
     fileOff += osec->getFileSize();
   }
-  seg->fileSize = fileOff - seg->fileOff;
 }
 
 void Writer::openFile() {
   Expected<std::unique_ptr<FileOutputBuffer>> bufferOrErr =
       FileOutputBuffer::create(config->outputFile, fileOff,
                                FileOutputBuffer::F_executable);
 
   if (!bufferOrErr)

lld/test/MachO/bitcode-bundle.ll

 ; REQUIRES: x86, xar
 ; RUN: rm -rf %t; split-file %s %t
 ; RUN: opt -module-summary %t/test.ll -o %t/test.o
 ; RUN: opt -module-summary %t/foo.ll -o %t/foo.o
 ; RUN: %lld -lSystem -bitcode_bundle %t/test.o %t/foo.o -o %t/test
 ; RUN: llvm-objdump --macho --section=__LLVM,__bundle %t/test | FileCheck %s
+; RUN: llvm-readobj --macho-segment %t/test | FileCheck %s --check-prefix=SEGMENT
 
 ; CHECK:      Contents of (__LLVM,__bundle) section
 ; CHECK-NEXT: For (__LLVM,__bundle) section: xar header
 ; CHECK-NEXT:                   magic XAR_HEADER_MAGIC
 ; CHECK-NEXT:                    size 28
 ; CHECK-NEXT:                 version 1
 ; CHECK-NEXT:   toc_length_compressed
 ; CHECK-NEXT: toc_length_uncompressed
 ; CHECK-NEXT:               cksum_alg XAR_CKSUM_SHA1
 ; CHECK-NEXT: For (__LLVM,__bundle) section: xar table of contents:
 ; CHECK-NEXT: <?xml version="1.0" encoding="UTF-8"?>
 ; CHECK-NEXT: <xar>
 ; CHECK-NEXT:  <toc>
 ; CHECK-NEXT:   <checksum style="sha1">
 ; CHECK-NEXT:    <size>20</size>
 ; CHECK-NEXT:    <offset>0</offset>
 ; CHECK-NEXT:   </checksum>
 ; CHECK-NEXT:   <creation-time>{{.*}}</creation-time>
 ; CHECK-NEXT:  </toc>
 ; CHECK-NEXT: </xar>
 
+;; __LLVM must directly precede __LINKEDIT.
+; SEGMENT:        Name: __LLVM
+; SEGMENT-NEXT:   Size: 152
+; SEGMENT-NEXT:   vmaddr: 0x[[#%X,LLVM_ADDR:]]
+; SEGMENT-NEXT:   vmsize: 0x[[#%X,LLVM_VMSIZE:]]
+; SEGMENT-NEXT:   fileoff: [[#LLVM_OFF:]]
+; SEGMENT-NEXT:   filesize: [[#LLVM_FILESIZE:]]
+; SEGMENT-NEXT:   maxprot: rw-
+; SEGMENT-NEXT:   initprot: rw-
+; SEGMENT-NEXT:   nsects: 1
+; SEGMENT-NEXT:   flags: 0x0
+; SEGMENT-NEXT: }
+; SEGMENT-NEXT: Segment {
+; SEGMENT-NEXT:   Cmd: LC_SEGMENT_64
+; SEGMENT-NEXT:   Name: __LINKEDIT
+; SEGMENT-NEXT:   Size: 72
+; SEGMENT-NEXT:   vmaddr: 0x[[#LLVM_ADDR + LLVM_VMSIZE]]
+; SEGMENT-NEXT:   vmsize:
+; SEGMENT-NEXT:   fileoff: [[#LLVM_OFF + LLVM_FILESIZE]]
+; SEGMENT-NEXT:   filesize:
+; SEGMENT-NEXT:   maxprot: r--
+; SEGMENT-NEXT:   initprot: r--
+; SEGMENT-NEXT:   nsects: 0
+; SEGMENT-NEXT:   flags: 0x0
+; SEGMENT-NEXT: }
+
 ;--- foo.ll
 target triple = "x86_64-apple-darwin"
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @foo() {
   ret void
 }
 
 ;--- test.ll
 target triple = "x86_64-apple-darwin"
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @main() {
   ret void
 }

lld/test/MachO/bss.s

 # CHECK-NEXT:   Reserved1: 0x0
 # CHECK-NEXT:   Reserved2: 0x0
 # CHECK-NEXT:   Reserved3: 0x0
 
 # CHECK:        Index: 3
 # CHECK-NEXT:   Name: __bss
 # CHECK-NEXT:   Segment: __DATA
 # CHECK-NEXT:   Address:
-# CHECK-NEXT:   Size: 0x8
+# CHECK-NEXT:   Size: 0x10000
 # CHECK-NEXT:   Offset: 0
 # CHECK-NEXT:   Alignment: 0
 # CHECK-NEXT:   RelocationOffset: 0x0
 # CHECK-NEXT:   RelocationCount: 0
 # CHECK-NEXT:   Type: ZeroFill (0x1)
 # CHECK-NEXT:   Attributes [ (0x0)
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Reserved1: 0x0

 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Reserved1: 0x0
 # CHECK-NEXT:   Reserved2: 0x0
 # CHECK-NEXT:   Reserved3: 0x0
 
 # CHECK:      Name: __DATA
 # CHECK-NEXT: Size:
 # CHECK-NEXT: vmaddr:
-# CHECK-NEXT: vmsize: 0x14
+# CHECK-NEXT: vmsize: 0x11000
 # CHECK-NEXT: fileoff:
-# CHECK-NEXT: filesize: 8
+# CHECK-NEXT: filesize: 4096
 
 # CHECK:      Name: FOO
 # CHECK-NEXT: Size:
 # CHECK-NEXT: vmaddr:
-# CHECK-NEXT: vmsize: 0x10
+# CHECK-NEXT: vmsize: 0x9000
 # CHECK-NEXT: fileoff:
-# CHECK-NEXT: filesize: 8
+# CHECK-NEXT: filesize: 4096
 
 .globl _main
 
 .text
 _main:
   movq $0, %rax
   retq
 
 .bss
-.zero 4
+.zero 0x8000
 
 .tbss _foo, 4
-.zero 4
+.zero 0x8000
 
 .data
 .quad 0x1234
 
-.zerofill FOO,bss,_zero_foo,0x8
+.zerofill FOO,bss,_zero_foo,0x8000
 
 .section FOO,foo
 .quad 123

lld/test/MachO/linkedit-contiguity.s

 # REQUIRES: x86
-# RUN: mkdir -p %t
+# RUN: rm -rf %t; split-file %s %t
 
 ## codesign requires that each setion in __LINKEDIT ends where the next one
 ## starts. This test enforces that invariant.
-## TODO: Test other __LINKEDIT sections here as support for them gets added.
-## Examples of such sections include the data for LC_CODE_SIGNATURE and
-## LC_DATA_IN_CODE.
-
-# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %p/Inputs/libhello.s \
-# RUN:   -o %t/libhello.o
-# RUN: %lld -dylib \
-# RUN:   -install_name @executable_path/libhello.dylib %t/libhello.o \
-# RUN:   -o %t/libhello.dylib
-
-# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t/test.o
-# RUN: %lld -o %t/test \
-# RUN:   -L%t -lhello %t/test.o -lSystem
+## It also checks that the last section in __LINKEDIT covers the last byte of
+## the segment.
+
+## FIXME: Include LC_DATA_IN_CODE in this test when we add support for it.
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/foo.s -o %t/foo.o
+# RUN: %lld %t/foo.o -dylib -o %t/libfoo.dylib
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/test.s -o %t/test.o
+# RUN: %lld -lSystem -pie -adhoc_codesign -o %t/test %t/libfoo.dylib %t/test.o
 
 # RUN: llvm-objdump --macho --all-headers %t/test | FileCheck %s
 
+# CHECK:      segname __LINKEDIT
+# CHECK-NEXT: vmaddr
+# CHECK-NEXT: vmsize
+# CHECK-NEXT: fileoff [[#LINKEDIT_OFF:]]
+# CHECK-NEXT: filesize [[#LINKEDIT_SIZE:]]
+
 # CHECK:      cmd LC_DYLD_INFO_ONLY
 # CHECK-NEXT: cmdsize 48
-# CHECK-NEXT: rebase_off 0
-# CHECK-NEXT: rebase_size 0
-# CHECK-NEXT: bind_off [[#BIND_OFF:]]
+# CHECK-NEXT: rebase_off [[#REBASE_OFF:]]
+# CHECK-NEXT: rebase_size [[#REBASE_SIZE:]]
+# CHECK-NEXT: bind_off [[#BIND_OFF: REBASE_OFF + REBASE_SIZE]]
 # CHECK-NEXT: bind_size [[#BIND_SIZE:]]
-# CHECK-NEXT: weak_bind_off 0
-# CHECK-NEXT: weak_bind_size 0
-# CHECK-NEXT: lazy_bind_off [[#LAZY_OFF: BIND_OFF + BIND_SIZE]]
+# CHECK-NEXT: weak_bind_off [[#WEAK_OFF: BIND_OFF + BIND_SIZE]]
+# CHECK-NEXT: weak_bind_size [[#WEAK_SIZE:]]
+# CHECK-NEXT: lazy_bind_off [[#LAZY_OFF: WEAK_OFF + WEAK_SIZE]]
 # CHECK-NEXT: lazy_bind_size [[#LAZY_SIZE:]]
 # CHECK-NEXT: export_off [[#EXPORT_OFF: LAZY_OFF + LAZY_SIZE]]
 # CHECK-NEXT: export_size [[#EXPORT_SIZE:]]
 
 # CHECK:      cmd LC_FUNCTION_STARTS
 # CHECK-NEXT: cmdsize
 # CHECK-NEXT: dataoff [[#FUNCSTARTS_OFF: EXPORT_OFF + EXPORT_SIZE]]
 
-.text
+# CHECK:      cmd LC_CODE_SIGNATURE
+# CHECK-NEXT: cmdsize 16
+# CHECK-NEXT: dataoff [[#SIG_OFF:]]
+# CHECK-NEXT: datasize [[#SIG_SIZE: LINKEDIT_OFF + LINKEDIT_SIZE - SIG_OFF]]
+
+#--- foo.s
+.globl _foo, _weak_foo
+.weak_definition _weak_foo
+_foo:
+_weak_foo:
+
+#--- test.s
 .globl _main
 _main:
-  sub $8, %rsp # 16-byte-align the stack; dyld checks for this
-  callq _print_hello
-  add $8, %rsp
+  callq _foo
+  callq _weak_foo
   ret

lld/test/MachO/section-headers.s

 # CHECK-NOT:  }
 # CHECK:      Type: CStringLiterals (0x2)
 # CHECK-NEXT: Attributes [ (0x0)
 # CHECK-NEXT: ]
 
 # CHECK:      Name: maxlen_16ch_name
 # CHECK-NEXT: Segment: __TEXT
 # CHECK-NEXT: Address:
-# CHECK-NEXT: Size: [[#%x, LAST_SEC_SIZE:]]
-# CHECK-NEXT: Offset: [[#%u, LAST_SEC_OFF:]]
+# CHECK-NEXT: Size:
+# CHECK-NEXT: Offset:
 # CHECK-NEXT: Alignment: 3
 # CHECK-NOT:  }
 # CHECK:      Type: Regular (0x0)
 
 # CHECK-LABEL: Segment {
 # CHECK:       Name: __TEXT
 # CHECK-NEXT:  Size:
 # CHECK-NEXT:  vmaddr:
 # CHECK-NEXT:  vmsize:
 # CHECK-NEXT:  fileoff: 0
-# CHECK-NEXT:  filesize: [[#%u, LAST_SEC_SIZE + LAST_SEC_OFF]]
+# CHECK-NEXT:  filesize: 4096
 
 .text
 .align 1
 .global _main
 _main:
   mov $0, %rax
   ret
 
 .section __TEXT,__cstring
 .align 2
 str:
   .asciz "Hello world!\n"
 
 .section __TEXT,maxlen_16ch_name
 .align 3

lld/test/MachO/segments.s

 # REQUIRES: x86, aarch64
 # RUN: rm -rf %t; mkdir -p %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t/x86_64.o
 # RUN: llvm-mc -filetype=obj -triple=arm64_32-apple-watchos %s -o %t/arm64-32.o
 # RUN: %lld -o %t/x86_64 %t/x86_64.o
 # RUN: %lld-watchos -o %t/arm64_32 %t/arm64-32.o
 
 # RUN: llvm-readobj --macho-segment %t/x86_64 > %t/x86_64.out
 # RUN: echo "Total file size" >> %t/x86_64.out
 # RUN: wc -c %t/x86_64 >> %t/x86_64.out
 # RUN: FileCheck %s -DSUFFIX=_64 -DPAGEZERO_SIZE=0x100000000 -DTEXT_ADDR=0x100000000 < %t/x86_64.out
 
 # RUN: llvm-readobj --macho-segment %t/arm64_32 > %t/arm64-32.out
 # RUN: echo "Total file size" >> %t/arm64-32.out
 # RUN: wc -c %t/arm64_32 >> %t/arm64-32.out
-# RUN: FileCheck %s -DSUFFIX= -DPAGEZERO_SIZE=0x1000 -DTEXT_ADDR=0x4000 < %t/arm64-32.out
+# RUN: FileCheck %s -DSUFFIX= -DPAGEZERO_SIZE=0x4000 -DTEXT_ADDR=0x4000 < %t/arm64-32.out
 
 ## These two segments must always be present at the start of an executable.
 # CHECK-NOT:  Segment {
 # CHECK:      Segment {
 # CHECK-NEXT:   Cmd: LC_SEGMENT[[SUFFIX]]{{$}}
 # CHECK-NEXT:   Name: __PAGEZERO
 # CHECK-NEXT:   Size:
 # CHECK-NEXT:   vmaddr: 0x0