1//===- lib/ReaderWriter/MachO/StubsPass.cpp ---------------------*- 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// This linker pass updates call-sites which have references to shared library
10// atoms to instead have a reference to a stub (PLT entry) for the specified
11// symbol.  Each file format defines a subclass of StubsPass which implements
12// the abstract methods for creating the file format specific StubAtoms.
13//
14//===----------------------------------------------------------------------===//
15
16#include "ArchHandler.h"
17#include "File.h"
18#include "MachOPasses.h"
19#include "lld/Common/LLVM.h"
20#include "lld/Core/DefinedAtom.h"
21#include "lld/Core/File.h"
22#include "lld/Core/Reference.h"
23#include "lld/Core/Simple.h"
24#include "lld/ReaderWriter/MachOLinkingContext.h"
25#include "llvm/ADT/DenseMap.h"
26#include "llvm/ADT/SmallVector.h"
27
28namespace lld {
29namespace mach_o {
30
31//
32//  Lazy Pointer Atom created by the stubs pass.
33//
34class LazyPointerAtom : public SimpleDefinedAtom {
35public:
36  LazyPointerAtom(const File &file, bool is64)
37    : SimpleDefinedAtom(file), _is64(is64) { }
38
39  ~LazyPointerAtom() override = default;
40
41  ContentType contentType() const override {
42    return DefinedAtom::typeLazyPointer;
43  }
44
45  Alignment alignment() const override {
46    return _is64 ? 8 : 4;
47  }
48
49  uint64_t size() const override {
50    return _is64 ? 8 : 4;
51  }
52
53  ContentPermissions permissions() const override {
54    return DefinedAtom::permRW_;
55  }
56
57  ArrayRef<uint8_t> rawContent() const override {
58    static const uint8_t zeros[] =
59        { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
60    return llvm::makeArrayRef(zeros, size());
61  }
62
63private:
64  const bool _is64;
65};
66
67//
68//  NonLazyPointer (GOT) Atom created by the stubs pass.
69//
70class NonLazyPointerAtom : public SimpleDefinedAtom {
71public:
72  NonLazyPointerAtom(const File &file, bool is64, ContentType contentType)
73    : SimpleDefinedAtom(file), _is64(is64), _contentType(contentType) { }
74
75  ~NonLazyPointerAtom() override = default;
76
77  ContentType contentType() const override {
78    return _contentType;
79  }
80
81  Alignment alignment() const override {
82    return _is64 ? 8 : 4;
83  }
84
85  uint64_t size() const override {
86    return _is64 ? 8 : 4;
87  }
88
89  ContentPermissions permissions() const override {
90    return DefinedAtom::permRW_;
91  }
92
93  ArrayRef<uint8_t> rawContent() const override {
94    static const uint8_t zeros[] =
95        { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
96    return llvm::makeArrayRef(zeros, size());
97  }
98
99private:
100  const bool _is64;
101  const ContentType _contentType;
102};
103
104//
105// Stub Atom created by the stubs pass.
106//
107class StubAtom : public SimpleDefinedAtom {
108public:
109  StubAtom(const File &file, const ArchHandler::StubInfo &stubInfo)
110      : SimpleDefinedAtom(file), _stubInfo(stubInfo){ }
111
112  ~StubAtom() override = default;
113
114  ContentType contentType() const override {
115    return DefinedAtom::typeStub;
116  }
117
118  Alignment alignment() const override {
119    return 1 << _stubInfo.codeAlignment;
120  }
121
122  uint64_t size() const override {
123    return _stubInfo.stubSize;
124  }
125
126  ContentPermissions permissions() const override {
127    return DefinedAtom::permR_X;
128  }
129
130  ArrayRef<uint8_t> rawContent() const override {
131    return llvm::makeArrayRef(_stubInfo.stubBytes, _stubInfo.stubSize);
132  }
133
134private:
135  const ArchHandler::StubInfo   &_stubInfo;
136};
137
138//
139// Stub Helper Atom created by the stubs pass.
140//
141class StubHelperAtom : public SimpleDefinedAtom {
142public:
143  StubHelperAtom(const File &file, const ArchHandler::StubInfo &stubInfo)
144      : SimpleDefinedAtom(file), _stubInfo(stubInfo) { }
145
146  ~StubHelperAtom() override = default;
147
148  ContentType contentType() const override {
149    return DefinedAtom::typeStubHelper;
150  }
151
152  Alignment alignment() const override {
153    return 1 << _stubInfo.codeAlignment;
154  }
155
156  uint64_t size() const override {
157    return _stubInfo.stubHelperSize;
158  }
159
160  ContentPermissions permissions() const override {
161    return DefinedAtom::permR_X;
162  }
163
164  ArrayRef<uint8_t> rawContent() const override {
165    return llvm::makeArrayRef(_stubInfo.stubHelperBytes,
166                              _stubInfo.stubHelperSize);
167  }
168
169private:
170  const ArchHandler::StubInfo   &_stubInfo;
171};
172
173//
174// Stub Helper Common Atom created by the stubs pass.
175//
176class StubHelperCommonAtom : public SimpleDefinedAtom {
177public:
178  StubHelperCommonAtom(const File &file, const ArchHandler::StubInfo &stubInfo)
179      : SimpleDefinedAtom(file), _stubInfo(stubInfo) { }
180
181  ~StubHelperCommonAtom() override = default;
182
183  ContentType contentType() const override {
184    return DefinedAtom::typeStubHelper;
185  }
186
187  Alignment alignment() const override {
188    return 1 << _stubInfo.stubHelperCommonAlignment;
189  }
190
191  uint64_t size() const override {
192    return _stubInfo.stubHelperCommonSize;
193  }
194
195  ContentPermissions permissions() const override {
196    return DefinedAtom::permR_X;
197  }
198
199  ArrayRef<uint8_t> rawContent() const override {
200    return llvm::makeArrayRef(_stubInfo.stubHelperCommonBytes,
201                        _stubInfo.stubHelperCommonSize);
202  }
203
204private:
205  const ArchHandler::StubInfo   &_stubInfo;
206};
207
208class StubsPass : public Pass {
209public:
210  StubsPass(const MachOLinkingContext &context)
211      : _ctx(context), _archHandler(_ctx.archHandler()),
212        _stubInfo(_archHandler.stubInfo()),
213        _file(*_ctx.make_file<MachOFile>("<mach-o Stubs pass>")) {
214    _file.setOrdinal(_ctx.getNextOrdinalAndIncrement());
215  }
216
217  llvm::Error perform(SimpleFile &mergedFile) override {
218    // Skip this pass if output format uses text relocations instead of stubs.
219    if (!this->noTextRelocs())
220      return llvm::Error::success();
221
222    // Scan all references in all atoms.
223    for (const DefinedAtom *atom : mergedFile.defined()) {
224      for (const Reference *ref : *atom) {
225        // Look at call-sites.
226        if (!this->isCallSite(*ref))
227          continue;
228        const Atom *target = ref->target();
229        assert(target != nullptr);
230        if (isa<SharedLibraryAtom>(target)) {
231          // Calls to shared libraries go through stubs.
232          _targetToUses[target].push_back(ref);
233          continue;
234        }
235        const DefinedAtom *defTarget = dyn_cast<DefinedAtom>(target);
236        if (defTarget && defTarget->interposable() != DefinedAtom::interposeNo){
237          // Calls to interposable functions in same linkage unit must also go
238          // through a stub.
239          assert(defTarget->scope() != DefinedAtom::scopeTranslationUnit);
240          _targetToUses[target].push_back(ref);
241        }
242      }
243    }
244
245    // Exit early if no stubs needed.
246    if (_targetToUses.empty())
247      return llvm::Error::success();
248
249    // First add help-common and GOT slots used by lazy binding.
250    SimpleDefinedAtom *helperCommonAtom =
251        new (_file.allocator()) StubHelperCommonAtom(_file, _stubInfo);
252    SimpleDefinedAtom *helperCacheNLPAtom =
253        new (_file.allocator()) NonLazyPointerAtom(_file, _ctx.is64Bit(),
254                                    _stubInfo.stubHelperImageCacheContentType);
255    SimpleDefinedAtom *helperBinderNLPAtom =
256        new (_file.allocator()) NonLazyPointerAtom(_file, _ctx.is64Bit(),
257                                    _stubInfo.stubHelperImageCacheContentType);
258    addReference(helperCommonAtom, _stubInfo.stubHelperCommonReferenceToCache,
259                 helperCacheNLPAtom);
260    addOptReference(
261        helperCommonAtom, _stubInfo.stubHelperCommonReferenceToCache,
262        _stubInfo.optStubHelperCommonReferenceToCache, helperCacheNLPAtom);
263    addReference(helperCommonAtom, _stubInfo.stubHelperCommonReferenceToBinder,
264                 helperBinderNLPAtom);
265    addOptReference(
266        helperCommonAtom, _stubInfo.stubHelperCommonReferenceToBinder,
267        _stubInfo.optStubHelperCommonReferenceToBinder, helperBinderNLPAtom);
268    mergedFile.addAtom(*helperCommonAtom);
269    mergedFile.addAtom(*helperBinderNLPAtom);
270    mergedFile.addAtom(*helperCacheNLPAtom);
271
272    // Add reference to dyld_stub_binder in libSystem.dylib
273    auto I = llvm::find_if(
274        mergedFile.sharedLibrary(), [&](const SharedLibraryAtom *atom) {
275          return atom->name().equals(_stubInfo.binderSymbolName);
276        });
277    assert(I != mergedFile.sharedLibrary().end() &&
278           "dyld_stub_binder not found");
279    addReference(helperBinderNLPAtom, _stubInfo.nonLazyPointerReferenceToBinder, *I);
280
281    // Sort targets by name, so stubs and lazy pointers are consistent
282    std::vector<const Atom *> targetsNeedingStubs;
283    for (auto it : _targetToUses)
284      targetsNeedingStubs.push_back(it.first);
285    std::sort(targetsNeedingStubs.begin(), targetsNeedingStubs.end(),
286              [](const Atom * left, const Atom * right) {
287      return (left->name().compare(right->name()) < 0);
288    });
289
290    // Make and append stubs, lazy pointers, and helpers in alphabetical order.
291    unsigned lazyOffset = 0;
292    for (const Atom *target : targetsNeedingStubs) {
293      auto *stub = new (_file.allocator()) StubAtom(_file, _stubInfo);
294      auto *lp =
295          new (_file.allocator()) LazyPointerAtom(_file, _ctx.is64Bit());
296      auto *helper = new (_file.allocator()) StubHelperAtom(_file, _stubInfo);
297
298      addReference(stub, _stubInfo.stubReferenceToLP, lp);
299      addOptReference(stub, _stubInfo.stubReferenceToLP,
300                      _stubInfo.optStubReferenceToLP, lp);
301      addReference(lp, _stubInfo.lazyPointerReferenceToHelper, helper);
302      addReference(lp, _stubInfo.lazyPointerReferenceToFinal, target);
303      addReference(helper, _stubInfo.stubHelperReferenceToImm, helper);
304      addReferenceAddend(helper, _stubInfo.stubHelperReferenceToImm, helper,
305                         lazyOffset);
306      addReference(helper, _stubInfo.stubHelperReferenceToHelperCommon,
307                   helperCommonAtom);
308
309      mergedFile.addAtom(*stub);
310      mergedFile.addAtom(*lp);
311      mergedFile.addAtom(*helper);
312
313      // Update each reference to use stub.
314      for (const Reference *ref : _targetToUses[target]) {
315        assert(ref->target() == target);
316        // Switch call site to reference stub atom instead.
317        const_cast<Reference *>(ref)->setTarget(stub);
318      }
319
320      // Calculate new offset
321      lazyOffset += target->name().size() + 12;
322    }
323
324    return llvm::Error::success();
325  }
326
327private:
328  bool noTextRelocs() {
329    return true;
330  }
331
332  bool isCallSite(const Reference &ref) {
333    return _archHandler.isCallSite(ref);
334  }
335
336  void addReference(SimpleDefinedAtom* atom,
337                    const ArchHandler::ReferenceInfo &refInfo,
338                    const lld::Atom* target) {
339    atom->addReference(Reference::KindNamespace::mach_o,
340                      refInfo.arch, refInfo.kind, refInfo.offset,
341                      target, refInfo.addend);
342  }
343
344  void addReferenceAddend(SimpleDefinedAtom *atom,
345                          const ArchHandler::ReferenceInfo &refInfo,
346                          const lld::Atom *target, uint64_t addend) {
347    atom->addReference(Reference::KindNamespace::mach_o, refInfo.arch,
348                       refInfo.kind, refInfo.offset, target, addend);
349  }
350
351   void addOptReference(SimpleDefinedAtom* atom,
352                    const ArchHandler::ReferenceInfo &refInfo,
353                    const ArchHandler::OptionalRefInfo &optRef,
354                    const lld::Atom* target) {
355      if (!optRef.used)
356        return;
357    atom->addReference(Reference::KindNamespace::mach_o,
358                      refInfo.arch, optRef.kind, optRef.offset,
359                      target, optRef.addend);
360  }
361
362  typedef llvm::DenseMap<const Atom*,
363                         llvm::SmallVector<const Reference *, 8>> TargetToUses;
364
365  const MachOLinkingContext &_ctx;
366  mach_o::ArchHandler                            &_archHandler;
367  const ArchHandler::StubInfo                    &_stubInfo;
368  MachOFile                                      &_file;
369  TargetToUses                                    _targetToUses;
370};
371
372void addStubsPass(PassManager &pm, const MachOLinkingContext &ctx) {
373  pm.add(std::unique_ptr<Pass>(new StubsPass(ctx)));
374}
375
376} // end namespace mach_o
377} // end namespace lld
378