[lld-macho] Don't use arrays as template parameters

[int3]

Summary

MSVC from VSCode 2017 appears unhappy with it (causes an
internal compiler error.)

This also means that we need to avoid doing sizeof(stubCode) as
sizeof(int[N]) on function array parameters decays into sizeof(int *).

[gkm]

⛸ 🍨 🍦 🍧

lld/MachO/Arch/ARM64.cpp

 
 static constexpr uint32_t stubCode[] = {
     0x90000010, // 00: adrp  x16, __la_symbol_ptr@page
     0xf9400210, // 04: ldr   x16, [x16, __la_symbol_ptr@pageoff]
     0xd61f0200, // 08: br    x16
 };
 
 void ARM64::writeStub(uint8_t *buf8, const Symbol &sym) const {
-  ::writeStub<LP64, stubCode>(buf8, sym);
+  ::writeStub<LP64>(buf8, stubCode, sym);
 }
 
 static constexpr uint32_t stubHelperHeaderCode[] = {
     0x90000011, // 00: adrp  x17, _dyld_private@page
     0x91000231, // 04: add   x17, x17, _dyld_private@pageoff
     0xa9bf47f0, // 08: stp   x16/x17, [sp, #-16]!
     0x90000010, // 0c: adrp  x16, dyld_stub_binder@page
     0xf9400210, // 10: ldr   x16, [x16, dyld_stub_binder@pageoff]
     0xd61f0200, // 14: br    x16
 };
 
 void ARM64::writeStubHelperHeader(uint8_t *buf8) const {
-  ::writeStubHelperHeader<LP64, stubHelperHeaderCode>(buf8);
+  ::writeStubHelperHeader<LP64>(buf8, stubHelperHeaderCode);
 }
 
 static constexpr uint32_t stubHelperEntryCode[] = {
     0x18000050, // 00: ldr  w16, l0
     0x14000000, // 04: b    stubHelperHeader
     0x00000000, // 08: l0: .long 0
 };
 
 void ARM64::writeStubHelperEntry(uint8_t *buf8, const DylibSymbol &sym,
                                  uint64_t entryVA) const {
-  ::writeStubHelperEntry<stubHelperEntryCode>(buf8, sym, entryVA);
+  ::writeStubHelperEntry(buf8, stubHelperEntryCode, sym, entryVA);
 }
 
 ARM64::ARM64() : ARM64Common(LP64()) {
   cpuType = CPU_TYPE_ARM64;
   cpuSubtype = CPU_SUBTYPE_ARM64_ALL;
 
   stubSize = sizeof(stubCode);
   stubHelperHeaderSize = sizeof(stubHelperHeaderCode);
   stubHelperEntrySize = sizeof(stubHelperEntryCode);
 }
 
 TargetInfo *macho::createARM64TargetInfo() {
   static ARM64 t;
   return &t;
 }

lld/MachO/Arch/ARM64Common.h

inline uint64_t encodePageOff12(uint32_t base, uint64_t va) {
   return (base | bitField(va, scale, 12 - scale, 10));
 }
 
 inline uint64_t pageBits(uint64_t address) {
   const uint64_t pageMask = ~0xfffull;
   return address & pageMask;
 }
 
-template <class LP, const uint32_t stubCode[3]>
-inline void writeStub(uint8_t *buf8, const macho::Symbol &sym) {
+template <class LP>
+inline void writeStub(uint8_t *buf8, const uint32_t stubCode[3],
+                      const macho::Symbol &sym) {
   auto *buf32 = reinterpret_cast<uint32_t *>(buf8);
+  constexpr size_t stubCodeSize = 3 * sizeof(uint32_t);
   uint64_t pcPageBits =
-      pageBits(in.stubs->addr + sym.stubsIndex * sizeof(stubCode));
+      pageBits(in.stubs->addr + sym.stubsIndex * stubCodeSize);
   uint64_t lazyPointerVA =
       in.lazyPointers->addr + sym.stubsIndex * LP::wordSize;
   buf32[0] = encodePage21({&sym, "stub"}, stubCode[0],
                           pageBits(lazyPointerVA) - pcPageBits);
   buf32[1] = encodePageOff12(stubCode[1], lazyPointerVA);
   buf32[2] = stubCode[2];
 }
 
-template <class LP, const uint32_t stubHelperHeaderCode[6]>
-inline void writeStubHelperHeader(uint8_t *buf8) {
+template <class LP>
+inline void writeStubHelperHeader(uint8_t *buf8,
+                                  const uint32_t stubHelperHeaderCode[6]) {
   auto *buf32 = reinterpret_cast<uint32_t *>(buf8);
   auto pcPageBits = [](int i) {
     return pageBits(in.stubHelper->addr + i * sizeof(uint32_t));
   };
   uint64_t loaderVA = in.imageLoaderCache->getVA();
   SymbolDiagnostic d = {nullptr, "stub header helper"};
   buf32[0] = encodePage21(d, stubHelperHeaderCode[0],
                           pageBits(loaderVA) - pcPageBits(0));
   buf32[1] = encodePageOff12(stubHelperHeaderCode[1], loaderVA);
   buf32[2] = stubHelperHeaderCode[2];
   uint64_t binderVA =
       in.got->addr + in.stubHelper->stubBinder->gotIndex * LP::wordSize;
   buf32[3] = encodePage21(d, stubHelperHeaderCode[3],
                           pageBits(binderVA) - pcPageBits(3));
   buf32[4] = encodePageOff12(stubHelperHeaderCode[4], binderVA);
   buf32[5] = stubHelperHeaderCode[5];
 }
 
-template <const uint32_t stubHelperEntryCode[3]>
-void writeStubHelperEntry(uint8_t *buf8, const DylibSymbol &sym,
-                          uint64_t entryVA) {
+inline void writeStubHelperEntry(uint8_t *buf8,
+                                 const uint32_t stubHelperEntryCode[3],
+                                 const DylibSymbol &sym, uint64_t entryVA) {
   auto *buf32 = reinterpret_cast<uint32_t *>(buf8);
   auto pcVA = [entryVA](int i) { return entryVA + i * sizeof(uint32_t); };
   uint64_t stubHelperHeaderVA = in.stubHelper->addr;
   buf32[0] = stubHelperEntryCode[0];
   buf32[1] = encodeBranch26({&sym, "stub helper"}, stubHelperEntryCode[1],
                             stubHelperHeaderVA - pcVA(1));
   buf32[2] = sym.lazyBindOffset;
 }
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/Arch/ARM64_32.cpp

 
 static constexpr uint32_t stubCode[] = {
     0x90000010, // 00: adrp  x16, __la_symbol_ptr@page
     0xb9400210, // 04: ldr   w16, [x16, __la_symbol_ptr@pageoff]
     0xd61f0200, // 08: br    x16
 };
 
 void ARM64_32::writeStub(uint8_t *buf8, const Symbol &sym) const {
-  ::writeStub<ILP32, stubCode>(buf8, sym);
+  ::writeStub<ILP32>(buf8, stubCode, sym);
 }
 
 static constexpr uint32_t stubHelperHeaderCode[] = {
     0x90000011, // 00: adrp  x17, _dyld_private@page
     0x91000231, // 04: add   x17, x17, _dyld_private@pageoff
     0xa9bf47f0, // 08: stp   x16/x17, [sp, #-16]!
     0x90000010, // 0c: adrp  x16, dyld_stub_binder@page
     0xb9400210, // 10: ldr   w16, [x16, dyld_stub_binder@pageoff]
     0xd61f0200, // 14: br    x16
 };
 
 void ARM64_32::writeStubHelperHeader(uint8_t *buf8) const {
-  ::writeStubHelperHeader<ILP32, stubHelperHeaderCode>(buf8);
+  ::writeStubHelperHeader<ILP32>(buf8, stubHelperHeaderCode);
 }
 
 static constexpr uint32_t stubHelperEntryCode[] = {
     0x18000050, // 00: ldr  w16, l0
     0x14000000, // 04: b    stubHelperHeader
     0x00000000, // 08: l0: .long 0
 };
 
 void ARM64_32::writeStubHelperEntry(uint8_t *buf8, const DylibSymbol &sym,
                                     uint64_t entryVA) const {
-  ::writeStubHelperEntry<stubHelperEntryCode>(buf8, sym, entryVA);
+  ::writeStubHelperEntry(buf8, stubHelperEntryCode, sym, entryVA);
 }
 
 ARM64_32::ARM64_32() : ARM64Common(ILP32()) {
   cpuType = CPU_TYPE_ARM64_32;
   cpuSubtype = CPU_SUBTYPE_ARM64_V8;
 
   stubSize = sizeof(stubCode);
   stubHelperHeaderSize = sizeof(stubHelperHeaderCode);
   stubHelperEntrySize = sizeof(stubHelperEntryCode);
 }
 
 TargetInfo *macho::createARM64_32TargetInfo() {
   static ARM64_32 t;
   return &t;
 }