[lld-macho] Emit load command LC_BUILD_VERSION

[gkm]

@int3, For tests cases, I did the simple fix of adjusting addresses to accommodate the expansion of the load-command section. Should I expend the effort to generalize via patterns in order to quietly absorb future load-command expansions?

[int3]

Should I expend the effort to generalize via patterns in order to quietly absorb future load-command expansions?

The reason those tests use hardcoded offsets instead of FileCheck's numeric substitutions is because of little-endianness. I'm not sure how they can be generalized while still checking for the things we care about. (Well, this is true for local-got.s at least. relocations.s just seems to be checking the little-endian encodings of the addresses, but doesn't check that it matches the big-endian form... this was an oversight)

lld/MachO/Writer.cpp

280

codebase convention is not to prefix member variables

lld/test/MachO/headerpad.s

14–15

nit: add spaces to align with column

[gkm]

add testcase & respond to review feedback

[gkm]

Remove spurious change to lld/MachO/CompactUnwind.cpp

[int3]

lgtm!

lld/MachO/Writer.cpp

254

nit: const ref

280

const ref

lld/test/MachO/lc-build-version.s

16

JFYI, [[#]] will also match any number: https://llvm.org/docs/CommandGuide/FileCheck.html#filecheck-numeric-substitution-blocks

[gkm]

Add const qualifier to reference arg

[gkm]

correct some omissions

[gkm]

Tighten testcase by imposing sequencing on expected lines

[smeenai]

lld/MachO/Writer.cpp

256

Nit: can this and platform be private?

[gkm]

rebase

[mehdi_amini]

lld/test/MachO/lc-build-version.s

13

This macro is a bit overly restrictive: our version of lld does not start with a leading 1 and fails this test.

I relaxed it in https://github.com/llvm/llvm-project/commit/22cbe40fa99795766f352c08a7c0748704c9d2d5 for now, if you would like a more specific checks I can propose this instead https://reviews.llvm.org/D86026 ?

lld/MachO/Writer.cpp

 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/BinaryFormat/MachO.h"
+#include "llvm/Config/llvm-config.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Path.h"
 
 using namespace llvm;
 using namespace llvm::MachO;
 using namespace lld;
 using namespace lld::macho;

 private:
   // Recent versions of Darwin won't run any binary that has dyld at a
   // different location.
   const StringRef path = "/usr/lib/dyld";
 };
 
 class LCRPath : public LoadCommand {
 public:
   LCRPath(StringRef path) : path(path) {}
 
   uint32_t getSize() const override {
     return alignTo(sizeof(rpath_command) + path.size() + 1, WordSize);
   }
 
   void writeTo(uint8_t *buf) const override {
     auto *c = reinterpret_cast<rpath_command *>(buf);
     buf += sizeof(rpath_command);
 
     c->cmd = LC_RPATH;
     c->cmdsize = getSize();
     c->path = sizeof(rpath_command);
 
     memcpy(buf, path.data(), path.size());
     buf[path.size()] = '\0';
   }
 
 private:
   StringRef path;
 };
+
+class LCBuildVersion : public LoadCommand {
+public:
+  LCBuildVersion(const PlatformInfo &platform) : platform(platform) {}
+
+  const int ntools = 1;
+
+  uint32_t getSize() const override {
+    return sizeof(build_version_command) + ntools * sizeof(build_tool_version);
+  }
+
+  void writeTo(uint8_t *buf) const override {
+    auto *c = reinterpret_cast<build_version_command *>(buf);
+    c->cmd = LC_BUILD_VERSION;
+    c->cmdsize = getSize();
+    c->platform = static_cast<uint32_t>(platform.kind);
+    c->minos = ((platform.minimum.getMajor() << 020) |
+                (platform.minimum.getMinor().getValueOr(0) << 010) |
+                platform.minimum.getSubminor().getValueOr(0));
+    c->sdk = ((platform.sdk.getMajor() << 020) |
+              (platform.sdk.getMinor().getValueOr(0) << 010) |
+              platform.sdk.getSubminor().getValueOr(0));
+    c->ntools = ntools;
+    auto *t = reinterpret_cast<build_tool_version *>(&c[1]);
+    t->tool = TOOL_LD;
+    t->version = (LLVM_VERSION_MAJOR << 020) | (LLVM_VERSION_MINOR << 010) |
+                 LLVM_VERSION_PATCH;
+  }
+
+  const PlatformInfo &platform;
+};
+
 } // namespace
 
 void Writer::scanRelocations() {
   for (InputSection *isec : inputSections) {
     for (Reloc &r : isec->relocs) {
       if (auto *s = r.target.dyn_cast<lld::macho::Symbol *>()) {
         if (isa<Undefined>(s))
           error("undefined symbol " + s->getName() + ", referenced from " +
case MH_EXECUTE:
     break;
   case MH_DYLIB:
     in.header->addLoadCommand(make<LCDylib>(LC_ID_DYLIB, config->installName));
     break;
   default:
     llvm_unreachable("unhandled output file type");
   }
 
+  in.header->addLoadCommand(make<LCBuildVersion>(config->platform));
+
   uint8_t segIndex = 0;
   for (OutputSegment *seg : outputSegments) {
     in.header->addLoadCommand(make<LCSegment>(seg->name, seg));
     seg->index = segIndex++;
   }
 
   uint64_t dylibOrdinal = 1;
   for (InputFile *file : inputFiles) {

lld/test/MachO/headerpad.s

 # REQUIRES: x86
 
 ## NOTE: Here we check that the first non-header section -- __text -- appears
 ## *exactly* `-headerpad` bytes from the end of the header. ld64 actually
 ## starts laying out the non-header sections in the __TEXT segment from the end
 ## of the (page-aligned) segment rather than the front, so its binaries
 ## typically have more than `-headerpad` bytes of actual padding. `-headerpad`
 ## just enforces a lower bound. We should consider implementing the same
 ## alignment behavior.
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
 # RUN: lld -flavor darwinnew -o %t %t.o -headerpad 0
 # RUN: llvm-objdump --macho --all-headers %t | FileCheck %s --check-prefix=PAD0
-# PAD0:      magic        cputype  cpusubtype  caps    filetype ncmds sizeofcmds
-# PAD0-NEXT: MH_MAGIC_64  X86_64   ALL         LIB64   EXECUTE  8     [[#%u, CMDSIZE:]] {{.*}}
+# PAD0:      magic        cputype  cpusubtype  caps    filetype ncmds sizeofcmds               flags
+# PAD0-NEXT: MH_MAGIC_64  X86_64   ALL         LIB64   EXECUTE  9     [[#%u, CMDSIZE:]] {{.*}}
 # PAD0:      sectname __text
 # PAD0-NEXT: segname __TEXT
 # PAD0-NEXT: addr
 # PAD0-NEXT: size
 # PAD0-NEXT: offset [[#%u, CMDSIZE + 32]]
 
 # RUN: lld -flavor darwinnew -o %t %t.o -headerpad 11
 # RUN: llvm-objdump --macho --all-headers %t | FileCheck %s --check-prefix=PAD11
-# PAD11:      magic        cputype  cpusubtype  caps    filetype ncmds sizeofcmds
-# PAD11-NEXT: MH_MAGIC_64  X86_64   ALL         LIB64   EXECUTE  8     [[#%u, CMDSIZE:]] {{.*}}
+# PAD11:      magic        cputype  cpusubtype  caps    filetype ncmds sizeofcmds               flags
+# PAD11-NEXT: MH_MAGIC_64  X86_64   ALL         LIB64   EXECUTE  9     [[#%u, CMDSIZE:]] {{.*}}
 # PAD11:      sectname __text
 # PAD11-NEXT: segname __TEXT
 # PAD11-NEXT: addr
 # PAD11-NEXT: size
 # PAD11-NEXT: offset [[#%u, CMDSIZE + 32 + 0x11]]
 
 .globl _main
 _main:
   ret

lld/test/MachO/lc-build-version.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
+# RUN: lld -flavor darwinnew -Z -platform_version macos 10.14.1 10.15 -o %t %t.o
+# RUN: llvm-objdump --macho --all-headers %t | FileCheck %s
+
+# CHECK: cmd LC_BUILD_VERSION
+# CHECK-NEXT: cmdsize 32
+# CHECK-NEXT: platform macos
+# CHECK-NEXT: sdk 10.15
+# CHECK-NEXT: minos 10.14.1
+# CHECK-NEXT: ntools 1
+# CHECK-NEXT: tool ld
+# CHECK-NEXT: version {{[1-9][0-9]\.[0-9]+}}
+# CHECK-NEXT: Load command [[#]]
+
+.text
+.global _main
+_main:
+  mov $0, %eax
+  ret

lld/test/MachO/local-got.s

 # REQUIRES: x86
 # RUN: mkdir -p %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %p/Inputs/libhello.s \
 # RUN:   -o %t/libhello.o
 # RUN: lld -flavor darwinnew -L%S/Inputs/MacOSX.sdk/usr/lib -lSystem -dylib -install_name \
 # RUN:   @executable_path/libhello.dylib %t/libhello.o -o %t/libhello.dylib
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t/test.o
 # RUN: lld -flavor darwinnew -L%S/Inputs/MacOSX.sdk/usr/lib -lSystem -o %t/test %t/test.o -L%t -lhello
 # RUN: llvm-objdump --full-contents --bind %t/test | FileCheck %s --match-full-lines
 
 ## Check that the GOT references the cstrings. --full-contents displays the
 ## address offset and the contents at that address very similarly, so am using
 ## --match-full-lines to make sure we match on the right thing.
 # CHECK:      Contents of section __cstring:
-# CHECK-NEXT: 1000003ec {{.*}}
+# CHECK-NEXT: 10000040c {{.*}}
 
 ## 1st 8 bytes refer to the start of __cstring + 0xe, 2nd 8 bytes refer to the
 ## start of __cstring
 # CHECK:      Contents of section __got:
-# CHECK-NEXT: [[#%X,ADDR:]]  fa030000 01000000 ec030000 01000000 {{.*}}
+# CHECK-NEXT: [[#%X,ADDR:]]  1a040000 01000000 0c040000 01000000 {{.*}}
 # CHECK-NEXT: [[#ADDR + 16]] 00000000 00000000 {{.*}}
 
 ## Check that a non-locally-defined symbol is still bound at the correct offset:
 # CHECK: Bind table:
 # CHECK-NEXT: segment      section  address         type     addend  dylib     symbol
 # CHECK-NEXT: __DATA_CONST __got    0x[[#ADDR+16]]  pointer  0       libhello  _hello_its_me
 
 .globl _main

lld/test/MachO/relocations.s

 # CHECK:       callq 0x[[#%x, F_ADDR]] <_f>
 ## Test extern (symbol) X86_64_RELOC_SIGNED
 # CHECK:       leaq [[#%u, STR_OFF:]](%rip), %rsi
 # CHECK-NEXT:  [[#%x, CSTRING_ADDR - STR_OFF]]
 ## Test non-extern (section) X86_64_RELOC_SIGNED
 # CHECK:       leaq [[#%u, LSTR_OFF:]](%rip), %rsi
 # CHECK-NEXT:  [[#%x, CSTRING_ADDR + 22 - LSTR_OFF]]
 
-# RUN: llvm-objdump --section=__const --full-contents -d %t | FileCheck %s --check-prefix=NONPCREL
+# RUN: llvm-objdump --section=__const --full-contents %t | FileCheck %s --check-prefix=NONPCREL
 # NONPCREL:      Contents of section __const:
-# NONPCREL-NEXT: 100001000 d0030000 01000000 d0030000 01000000
+# NONPCREL-NEXT: 100001000 f0030000 01000000 f0030000 01000000
 
 .section __TEXT,__text
 .globl _main, _f
 _main:
   callq _f # X86_64_RELOC_BRANCH
   mov $0, %rax
   ret