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
19namespace lld::macho {
20
21struct ARM64Common : TargetInfo {
22 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 Relocation &, uint64_t va,
27 uint64_t pc) const override;
28
29 void relaxGotLoad(uint8_t *loc, uint8_t type) const override;
30 uint64_t getPageSize() const override { return 16 * 1024; }
31
32 void handleDtraceReloc(const Symbol *sym, const Relocation &r,
33 uint8_t *loc) const override;
34};
35
36inline 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
45inline void encodeBranch26(uint32_t *loc, const Relocation &r, uint32_t base,
46 uint64_t va) {
47 checkInt(loc, d: r, v: va, bits: 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(P: loc, V: base | bitField(value: va, right: 2, width: 26, left: 0));
51}
52
53inline void encodeBranch26(uint32_t *loc, SymbolDiagnostic d, uint32_t base,
54 uint64_t va) {
55 checkInt(loc, d, v: va, bits: 28);
56 llvm::support::endian::write32le(P: loc, V: base | bitField(value: va, right: 2, width: 26, left: 0));
57}
58
59// 30 29 23 5
60// +-+---+---------+-------------------------------------+---------+
61// | |ilo| | immhi | |
62// +-+---+---------+-------------------------------------+---------+
63
64inline void encodePage21(uint32_t *loc, const Relocation &r, uint32_t base,
65 uint64_t va) {
66 checkInt(loc, d: r, v: va, bits: 35);
67 llvm::support::endian::write32le(P: loc, V: base | bitField(value: va, right: 12, width: 2, left: 29) |
68 bitField(value: va, right: 14, width: 19, left: 5));
69}
70
71inline void encodePage21(uint32_t *loc, SymbolDiagnostic d, uint32_t base,
72 uint64_t va) {
73 checkInt(loc, d, v: va, bits: 35);
74 llvm::support::endian::write32le(P: loc, V: base | bitField(value: va, right: 12, width: 2, left: 29) |
75 bitField(value: va, right: 14, width: 19, left: 5));
76}
77
78void reportUnalignedLdrStr(void *loc, const Relocation &, uint64_t va,
79 int align);
80void reportUnalignedLdrStr(void *loc, SymbolDiagnostic, uint64_t va, int align);
81
82// 21 10
83// +-------------------+-----------------------+-------------------+
84// | | imm12 | |
85// +-------------------+-----------------------+-------------------+
86
87template <typename Target>
88inline void encodePageOff12(uint32_t *loc, Target t, uint32_t base,
89 uint64_t va) {
90 int scale = 0;
91 if ((base & 0x3b00'0000) == 0x3900'0000) { // load/store
92 scale = base >> 30;
93 if (scale == 0 && (base & 0x0480'0000) == 0x0480'0000) // 128-bit variant
94 scale = 4;
95 }
96 const int size = 1 << scale;
97 if ((va & (size - 1)) != 0)
98 reportUnalignedLdrStr(loc, t, va, size);
99
100 // TODO(gkm): extract embedded addend and warn if != 0
101 // uint64_t addend = ((base & 0x003FFC00) >> 10);
102 llvm::support::endian::write32le(P: loc,
103 V: base | bitField(value: va, right: scale, width: 12 - scale, left: 10));
104}
105
106inline uint64_t pageBits(uint64_t address) {
107 const uint64_t pageMask = ~0xfffull;
108 return address & pageMask;
109}
110
111inline void writeStub(uint8_t *buf8, const uint32_t stubCode[3],
112 const macho::Symbol &sym, uint64_t pointerVA) {
113 auto *buf32 = reinterpret_cast<uint32_t *>(buf8);
114 constexpr size_t stubCodeSize = 3 * sizeof(uint32_t);
115 SymbolDiagnostic d = {.symbol: &sym, .reason: "stub"};
116 uint64_t pcPageBits =
117 pageBits(address: in.stubs->addr + sym.stubsIndex * stubCodeSize);
118 encodePage21(loc: &buf32[0], d, base: stubCode[0], va: pageBits(address: pointerVA) - pcPageBits);
119 encodePageOff12(loc: &buf32[1], t: d, base: stubCode[1], va: pointerVA);
120 buf32[2] = stubCode[2];
121}
122
123template <class LP>
124inline void writeStubHelperHeader(uint8_t *buf8,
125 const uint32_t stubHelperHeaderCode[6]) {
126 auto *buf32 = reinterpret_cast<uint32_t *>(buf8);
127 auto pcPageBits = [](int i) {
128 return pageBits(address: in.stubHelper->addr + i * sizeof(uint32_t));
129 };
130 uint64_t loaderVA = in.imageLoaderCache->getVA();
131 SymbolDiagnostic d = {.symbol: nullptr, .reason: "stub header helper"};
132 encodePage21(&buf32[0], d, stubHelperHeaderCode[0],
133 pageBits(address: loaderVA) - pcPageBits(0));
134 encodePageOff12(loc: &buf32[1], t: d, base: stubHelperHeaderCode[1], va: loaderVA);
135 buf32[2] = stubHelperHeaderCode[2];
136 uint64_t binderVA =
137 in.got->addr + in.stubHelper->stubBinder->gotIndex * LP::wordSize;
138 encodePage21(&buf32[3], d, stubHelperHeaderCode[3],
139 pageBits(address: binderVA) - pcPageBits(3));
140 encodePageOff12(loc: &buf32[4], t: d, base: stubHelperHeaderCode[4], va: binderVA);
141 buf32[5] = stubHelperHeaderCode[5];
142}
143
144inline void writeStubHelperEntry(uint8_t *buf8,
145 const uint32_t stubHelperEntryCode[3],
146 const Symbol &sym, uint64_t entryVA) {
147 auto *buf32 = reinterpret_cast<uint32_t *>(buf8);
148 auto pcVA = [entryVA](int i) { return entryVA + i * sizeof(uint32_t); };
149 uint64_t stubHelperHeaderVA = in.stubHelper->addr;
150 buf32[0] = stubHelperEntryCode[0];
151 encodeBranch26(loc: &buf32[1], d: {.symbol: &sym, .reason: "stub helper"}, base: stubHelperEntryCode[1],
152 va: stubHelperHeaderVA - pcVA(1));
153 buf32[2] = sym.lazyBindOffset;
154}
155
156template <class LP>
157inline void writeObjCMsgSendFastStub(uint8_t *buf,
158 const uint32_t objcStubsFastCode[8],
159 Symbol *sym, uint64_t stubsAddr,
160 uint64_t stubOffset, uint64_t selrefVA,
161 uint64_t gotAddr, uint64_t msgSendIndex) {
162 SymbolDiagnostic d = {.symbol: sym, .reason: sym->getName()};
163 auto *buf32 = reinterpret_cast<uint32_t *>(buf);
164
165 auto pcPageBits = [stubsAddr, stubOffset](int i) {
166 return pageBits(address: stubsAddr + stubOffset + i * sizeof(uint32_t));
167 };
168
169 encodePage21(&buf32[0], d, objcStubsFastCode[0],
170 pageBits(address: selrefVA) - pcPageBits(0));
171 encodePageOff12(loc: &buf32[1], t: d, base: objcStubsFastCode[1], va: selrefVA);
172 uint64_t gotOffset = msgSendIndex * LP::wordSize;
173 encodePage21(&buf32[2], d, objcStubsFastCode[2],
174 pageBits(address: gotAddr + gotOffset) - pcPageBits(2));
175 encodePageOff12(loc: &buf32[3], t: d, base: objcStubsFastCode[3], va: gotAddr + gotOffset);
176 buf32[4] = objcStubsFastCode[4];
177 buf32[5] = objcStubsFastCode[5];
178 buf32[6] = objcStubsFastCode[6];
179 buf32[7] = objcStubsFastCode[7];
180}
181
182template <class LP>
183inline void
184writeObjCMsgSendSmallStub(uint8_t *buf, const uint32_t objcStubsSmallCode[3],
185 Symbol *sym, uint64_t stubsAddr, uint64_t stubOffset,
186 uint64_t selrefVA, uint64_t msgSendAddr,
187 uint64_t msgSendIndex) {
188 SymbolDiagnostic d = {.symbol: sym, .reason: sym->getName()};
189 auto *buf32 = reinterpret_cast<uint32_t *>(buf);
190
191 auto pcPageBits = [stubsAddr, stubOffset](int i) {
192 return pageBits(address: stubsAddr + stubOffset + i * sizeof(uint32_t));
193 };
194
195 encodePage21(&buf32[0], d, objcStubsSmallCode[0],
196 pageBits(address: selrefVA) - pcPageBits(0));
197 encodePageOff12(loc: &buf32[1], t: d, base: objcStubsSmallCode[1], va: selrefVA);
198 uint64_t msgSendStubVA = msgSendAddr + msgSendIndex * target->stubSize;
199 uint64_t pcVA = stubsAddr + stubOffset + 2 * sizeof(uint32_t);
200 encodeBranch26(loc: &buf32[2], d: {.symbol: nullptr, .reason: "objc_msgSend stub"},
201 base: objcStubsSmallCode[2], va: msgSendStubVA - pcVA);
202}
203
204} // namespace lld::macho
205
206#endif
207