1 //===- ARM64Common.h --------------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #ifndef LLD_MACHO_ARCH_ARM64COMMON_H
10 #define LLD_MACHO_ARCH_ARM64COMMON_H
11
12 #include "InputFiles.h"
13 #include "Symbols.h"
14 #include "SyntheticSections.h"
15 #include "Target.h"
16
17 #include "llvm/BinaryFormat/MachO.h"
18
19 namespace lld::macho {
20
21 struct ARM64Common : TargetInfo {
ARM64CommonARM64Common22 template <class LP> ARM64Common(LP lp) : TargetInfo(lp) {}
23
24 int64_t getEmbeddedAddend(MemoryBufferRef, uint64_t offset,
25 const llvm::MachO::relocation_info) const override;
26 void relocateOne(uint8_t *loc, const Reloc &, uint64_t va,
27 uint64_t pc) const override;
28
29 void relaxGotLoad(uint8_t *loc, uint8_t type) const override;
getPageSizeARM64Common30 uint64_t getPageSize() const override { return 16 * 1024; }
31
32 void handleDtraceReloc(const Symbol *sym, const Reloc &r,
33 uint8_t *loc) const override;
34 };
35
bitField(uint64_t value,int right,int width,int left)36 inline uint64_t bitField(uint64_t value, int right, int width, int left) {
37 return ((value >> right) & ((1 << width) - 1)) << left;
38 }
39
40 // 25 0
41 // +-----------+---------------------------------------------------+
42 // | | imm26 |
43 // +-----------+---------------------------------------------------+
44
encodeBranch26(uint32_t * loc,const Reloc & r,uint32_t base,uint64_t va)45 inline void encodeBranch26(uint32_t *loc, const Reloc &r, uint32_t base,
46 uint64_t va) {
47 checkInt(loc, r, va, 28);
48 // Since branch destinations are 4-byte aligned, the 2 least-
49 // significant bits are 0. They are right shifted off the end.
50 llvm::support::endian::write32le(loc, base | bitField(va, 2, 26, 0));
51 }
52
encodeBranch26(uint32_t * loc,SymbolDiagnostic d,uint32_t base,uint64_t va)53 inline void encodeBranch26(uint32_t *loc, SymbolDiagnostic d, uint32_t base,
54 uint64_t va) {
55 checkInt(loc, d, va, 28);
56 llvm::support::endian::write32le(loc, base | bitField(va, 2, 26, 0));
57 }
58
59 // 30 29 23 5
60 // +-+---+---------+-------------------------------------+---------+
61 // | |ilo| | immhi | |
62 // +-+---+---------+-------------------------------------+---------+
63
encodePage21(uint32_t * loc,const Reloc & r,uint32_t base,uint64_t va)64 inline void encodePage21(uint32_t *loc, const Reloc &r, uint32_t base,
65 uint64_t va) {
66 checkInt(loc, r, va, 35);
67 llvm::support::endian::write32le(loc, base | bitField(va, 12, 2, 29) |
68 bitField(va, 14, 19, 5));
69 }
70
encodePage21(uint32_t * loc,SymbolDiagnostic d,uint32_t base,uint64_t va)71 inline void encodePage21(uint32_t *loc, SymbolDiagnostic d, uint32_t base,
72 uint64_t va) {
73 checkInt(loc, d, va, 35);
74 llvm::support::endian::write32le(loc, base | bitField(va, 12, 2, 29) |
75 bitField(va, 14, 19, 5));
76 }
77
78 void reportUnalignedLdrStr(void *loc, const Reloc &, uint64_t va, int align);
79 void reportUnalignedLdrStr(void *loc, SymbolDiagnostic, uint64_t va, int align);
80
81 // 21 10
82 // +-------------------+-----------------------+-------------------+
83 // | | imm12 | |
84 // +-------------------+-----------------------+-------------------+
85
86 template <typename Target>
encodePageOff12(uint32_t * loc,Target t,uint32_t base,uint64_t va)87 inline void encodePageOff12(uint32_t *loc, Target t, uint32_t base,
88 uint64_t va) {
89 int scale = 0;
90 if ((base & 0x3b00'0000) == 0x3900'0000) { // load/store
91 scale = base >> 30;
92 if (scale == 0 && (base & 0x0480'0000) == 0x0480'0000) // 128-bit variant
93 scale = 4;
94 }
95 const int size = 1 << scale;
96 if ((va & (size - 1)) != 0)
97 reportUnalignedLdrStr(loc, t, va, size);
98
99 // TODO(gkm): extract embedded addend and warn if != 0
100 // uint64_t addend = ((base & 0x003FFC00) >> 10);
101 llvm::support::endian::write32le(loc,
102 base | bitField(va, scale, 12 - scale, 10));
103 }
104
pageBits(uint64_t address)105 inline uint64_t pageBits(uint64_t address) {
106 const uint64_t pageMask = ~0xfffull;
107 return address & pageMask;
108 }
109
writeStub(uint8_t * buf8,const uint32_t stubCode[3],const macho::Symbol & sym,uint64_t pointerVA)110 inline void writeStub(uint8_t *buf8, const uint32_t stubCode[3],
111 const macho::Symbol &sym, uint64_t pointerVA) {
112 auto *buf32 = reinterpret_cast<uint32_t *>(buf8);
113 constexpr size_t stubCodeSize = 3 * sizeof(uint32_t);
114 SymbolDiagnostic d = {&sym, "stub"};
115 uint64_t pcPageBits =
116 pageBits(in.stubs->addr + sym.stubsIndex * stubCodeSize);
117 encodePage21(&buf32[0], d, stubCode[0], pageBits(pointerVA) - pcPageBits);
118 encodePageOff12(&buf32[1], d, stubCode[1], pointerVA);
119 buf32[2] = stubCode[2];
120 }
121
122 template <class LP>
writeStubHelperHeader(uint8_t * buf8,const uint32_t stubHelperHeaderCode[6])123 inline void writeStubHelperHeader(uint8_t *buf8,
124 const uint32_t stubHelperHeaderCode[6]) {
125 auto *buf32 = reinterpret_cast<uint32_t *>(buf8);
126 auto pcPageBits = [](int i) {
127 return pageBits(in.stubHelper->addr + i * sizeof(uint32_t));
128 };
129 uint64_t loaderVA = in.imageLoaderCache->getVA();
130 SymbolDiagnostic d = {nullptr, "stub header helper"};
131 encodePage21(&buf32[0], d, stubHelperHeaderCode[0],
132 pageBits(loaderVA) - pcPageBits(0));
133 encodePageOff12(&buf32[1], d, stubHelperHeaderCode[1], loaderVA);
134 buf32[2] = stubHelperHeaderCode[2];
135 uint64_t binderVA =
136 in.got->addr + in.stubHelper->stubBinder->gotIndex * LP::wordSize;
137 encodePage21(&buf32[3], d, stubHelperHeaderCode[3],
138 pageBits(binderVA) - pcPageBits(3));
139 encodePageOff12(&buf32[4], d, stubHelperHeaderCode[4], binderVA);
140 buf32[5] = stubHelperHeaderCode[5];
141 }
142
writeStubHelperEntry(uint8_t * buf8,const uint32_t stubHelperEntryCode[3],const Symbol & sym,uint64_t entryVA)143 inline void writeStubHelperEntry(uint8_t *buf8,
144 const uint32_t stubHelperEntryCode[3],
145 const Symbol &sym, uint64_t entryVA) {
146 auto *buf32 = reinterpret_cast<uint32_t *>(buf8);
147 auto pcVA = [entryVA](int i) { return entryVA + i * sizeof(uint32_t); };
148 uint64_t stubHelperHeaderVA = in.stubHelper->addr;
149 buf32[0] = stubHelperEntryCode[0];
150 encodeBranch26(&buf32[1], {&sym, "stub helper"}, stubHelperEntryCode[1],
151 stubHelperHeaderVA - pcVA(1));
152 buf32[2] = sym.lazyBindOffset;
153 }
154
155 template <class LP>
writeObjCMsgSendFastStub(uint8_t * buf,const uint32_t objcStubsFastCode[8],Symbol * sym,uint64_t stubsAddr,uint64_t stubOffset,uint64_t selrefVA,uint64_t gotAddr,uint64_t msgSendIndex)156 inline void writeObjCMsgSendFastStub(uint8_t *buf,
157 const uint32_t objcStubsFastCode[8],
158 Symbol *sym, uint64_t stubsAddr,
159 uint64_t stubOffset, uint64_t selrefVA,
160 uint64_t gotAddr, uint64_t msgSendIndex) {
161 SymbolDiagnostic d = {sym, sym->getName()};
162 auto *buf32 = reinterpret_cast<uint32_t *>(buf);
163
164 auto pcPageBits = [stubsAddr, stubOffset](int i) {
165 return pageBits(stubsAddr + stubOffset + i * sizeof(uint32_t));
166 };
167
168 encodePage21(&buf32[0], d, objcStubsFastCode[0],
169 pageBits(selrefVA) - pcPageBits(0));
170 encodePageOff12(&buf32[1], d, objcStubsFastCode[1], selrefVA);
171 uint64_t gotOffset = msgSendIndex * LP::wordSize;
172 encodePage21(&buf32[2], d, objcStubsFastCode[2],
173 pageBits(gotAddr + gotOffset) - pcPageBits(2));
174 encodePageOff12(&buf32[3], d, objcStubsFastCode[3], gotAddr + gotOffset);
175 buf32[4] = objcStubsFastCode[4];
176 buf32[5] = objcStubsFastCode[5];
177 buf32[6] = objcStubsFastCode[6];
178 buf32[7] = objcStubsFastCode[7];
179 }
180
181 template <class LP>
182 inline void
writeObjCMsgSendSmallStub(uint8_t * buf,const uint32_t objcStubsSmallCode[3],Symbol * sym,uint64_t stubsAddr,uint64_t stubOffset,uint64_t selrefVA,uint64_t msgSendAddr,uint64_t msgSendIndex)183 writeObjCMsgSendSmallStub(uint8_t *buf, const uint32_t objcStubsSmallCode[3],
184 Symbol *sym, uint64_t stubsAddr, uint64_t stubOffset,
185 uint64_t selrefVA, uint64_t msgSendAddr,
186 uint64_t msgSendIndex) {
187 SymbolDiagnostic d = {sym, sym->getName()};
188 auto *buf32 = reinterpret_cast<uint32_t *>(buf);
189
190 auto pcPageBits = [stubsAddr, stubOffset](int i) {
191 return pageBits(stubsAddr + stubOffset + i * sizeof(uint32_t));
192 };
193
194 encodePage21(&buf32[0], d, objcStubsSmallCode[0],
195 pageBits(selrefVA) - pcPageBits(0));
196 encodePageOff12(&buf32[1], d, objcStubsSmallCode[1], selrefVA);
197 uint64_t msgSendStubVA = msgSendAddr + msgSendIndex * target->stubSize;
198 uint64_t pcVA = stubsAddr + stubOffset + 2 * sizeof(uint32_t);
199 encodeBranch26(&buf32[2], {nullptr, "objc_msgSend stub"},
200 objcStubsSmallCode[2], msgSendStubVA - pcVA);
201 }
202
203 } // namespace lld::macho
204
205 #endif
206