Coverage Report

Created: 2019-01-18 03:29

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/lld/ELF/SyntheticSections.h
Line
Count
Source (jump to first uncovered line)
1
//===- SyntheticSection.h ---------------------------------------*- C++ -*-===//
2
//
3
//                             The LLVM Linker
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
//
10
// Synthetic sections represent chunks of linker-created data. If you
11
// need to create a chunk of data that to be included in some section
12
// in the result, you probably want to create that as a synthetic section.
13
//
14
// Synthetic sections are designed as input sections as opposed to
15
// output sections because we want to allow them to be manipulated
16
// using linker scripts just like other input sections from regular
17
// files.
18
//
19
//===----------------------------------------------------------------------===//
20
21
#ifndef LLD_ELF_SYNTHETIC_SECTION_H
22
#define LLD_ELF_SYNTHETIC_SECTION_H
23
24
#include "DWARF.h"
25
#include "EhFrame.h"
26
#include "InputSection.h"
27
#include "llvm/ADT/MapVector.h"
28
#include "llvm/MC/StringTableBuilder.h"
29
#include "llvm/Support/Endian.h"
30
#include <functional>
31
32
namespace lld {
33
namespace elf {
34
class Defined;
35
class SharedSymbol;
36
37
class SyntheticSection : public InputSection {
38
public:
39
  SyntheticSection(uint64_t Flags, uint32_t Type, uint32_t Alignment,
40
                   StringRef Name)
41
      : InputSection(nullptr, Flags, Type, Alignment, {}, Name,
42
50.5k
                     InputSectionBase::Synthetic) {
43
50.5k
    this->Live = true;
44
50.5k
  }
45
46
50.5k
  virtual ~SyntheticSection() = default;
47
  virtual void writeTo(uint8_t *Buf) = 0;
48
  virtual size_t getSize() const = 0;
49
6.28k
  virtual void finalizeContents() {}
50
  // If the section has the SHF_ALLOC flag and the size may be changed if
51
  // thunks are added, update the section size.
52
657
  virtual bool updateAllocSize() { return false; }
53
29.7k
  virtual bool empty() const { return false; }
54
55
5.77M
  static bool classof(const SectionBase *D) {
56
5.77M
    return D->kind() == InputSectionBase::Synthetic;
57
5.77M
  }
58
};
59
60
struct CieRecord {
61
  EhSectionPiece *Cie = nullptr;
62
  std::vector<EhSectionPiece *> Fdes;
63
};
64
65
// Section for .eh_frame.
66
class EhFrameSection final : public SyntheticSection {
67
public:
68
  EhFrameSection();
69
  void writeTo(uint8_t *Buf) override;
70
  void finalizeContents() override;
71
6.82k
  bool empty() const override { return Sections.empty(); }
72
199
  size_t getSize() const override { return Size; }
73
74
  template <class ELFT> void addSection(InputSectionBase *S);
75
76
  std::vector<EhInputSection *> Sections;
77
  size_t NumFdes = 0;
78
79
  struct FdeData {
80
    uint32_t PcRel;
81
    uint32_t FdeVARel;
82
  };
83
84
  std::vector<FdeData> getFdeData() const;
85
4
  ArrayRef<CieRecord *> getCieRecords() const { return CieRecords; }
86
87
private:
88
  // This is used only when parsing EhInputSection. We keep it here to avoid
89
  // allocating one for each EhInputSection.
90
  llvm::DenseMap<size_t, CieRecord *> OffsetToCie;
91
92
  uint64_t Size = 0;
93
94
  template <class ELFT, class RelTy>
95
  void addSectionAux(EhInputSection *S, llvm::ArrayRef<RelTy> Rels);
96
97
  template <class ELFT, class RelTy>
98
  CieRecord *addCie(EhSectionPiece &Piece, ArrayRef<RelTy> Rels);
99
100
  template <class ELFT, class RelTy>
101
  bool isFdeLive(EhSectionPiece &Piece, ArrayRef<RelTy> Rels);
102
103
  uint64_t getFdePc(uint8_t *Buf, size_t Off, uint8_t Enc) const;
104
105
  std::vector<CieRecord *> CieRecords;
106
107
  // CIE records are uniquified by their contents and personality functions.
108
  llvm::DenseMap<std::pair<ArrayRef<uint8_t>, Symbol *>, CieRecord *> CieMap;
109
};
110
111
class GotSection : public SyntheticSection {
112
public:
113
  GotSection();
114
770
  size_t getSize() const override { return Size; }
115
  void finalizeContents() override;
116
  bool empty() const override;
117
  void writeTo(uint8_t *Buf) override;
118
119
  void addEntry(Symbol &Sym);
120
  bool addDynTlsEntry(Symbol &Sym);
121
  bool addTlsIndex();
122
  uint64_t getGlobalDynAddr(const Symbol &B) const;
123
  uint64_t getGlobalDynOffset(const Symbol &B) const;
124
125
5
  uint64_t getTlsIndexVA() { return this->getVA() + TlsIndexOff; }
126
31
  uint32_t getTlsIndexOff() const { return TlsIndexOff; }
127
128
  // Flag to force GOT to be in output if we have relocations
129
  // that relies on its address.
130
  bool HasGotOffRel = false;
131
132
protected:
133
  size_t NumEntries = 0;
134
  uint32_t TlsIndexOff = -1;
135
  uint64_t Size = 0;
136
};
137
138
// .note.GNU-stack section.
139
class GnuStackSection : public SyntheticSection {
140
public:
141
  GnuStackSection()
142
75
      : SyntheticSection(0, llvm::ELF::SHT_PROGBITS, 1, ".note.GNU-stack") {}
143
75
  void writeTo(uint8_t *Buf) override {}
144
184
  size_t getSize() const override { return 0; }
145
};
146
147
// .note.gnu.build-id section.
148
class BuildIdSection : public SyntheticSection {
149
  // First 16 bytes are a header.
150
  static const unsigned HeaderSize = 16;
151
152
public:
153
  BuildIdSection();
154
  void writeTo(uint8_t *Buf) override;
155
34
  size_t getSize() const override { return HeaderSize + HashSize; }
156
  void writeBuildId(llvm::ArrayRef<uint8_t> Buf);
157
158
private:
159
  void computeHash(llvm::ArrayRef<uint8_t> Buf,
160
                   std::function<void(uint8_t *, ArrayRef<uint8_t>)> Hash);
161
162
  size_t HashSize;
163
  uint8_t *HashBuf;
164
};
165
166
// BssSection is used to reserve space for copy relocations and common symbols.
167
// We create three instances of this class for .bss, .bss.rel.ro and "COMMON",
168
// that are used for writable symbols, read-only symbols and common symbols,
169
// respectively.
170
class BssSection final : public SyntheticSection {
171
public:
172
  BssSection(StringRef Name, uint64_t Size, uint32_t Alignment);
173
0
  void writeTo(uint8_t *) override {
174
0
    llvm_unreachable("unexpected writeTo() call for SHT_NOBITS section");
175
0
  }
176
9.18k
  bool empty() const override { return getSize() == 0; }
177
9.57k
  size_t getSize() const override { return Size; }
178
179
197k
  static bool classof(const SectionBase *S) { return S->Bss; }
180
  uint64_t Size;
181
};
182
183
class MipsGotSection final : public SyntheticSection {
184
public:
185
  MipsGotSection();
186
  void writeTo(uint8_t *Buf) override;
187
700
  size_t getSize() const override { return Size; }
188
  bool updateAllocSize() override;
189
  void finalizeContents() override;
190
  bool empty() const override;
191
192
  // Join separate GOTs built for each input file to generate
193
  // primary and optional multiple secondary GOTs.
194
  template <class ELFT> void build();
195
196
  void addEntry(InputFile &File, Symbol &Sym, int64_t Addend, RelExpr Expr);
197
  void addDynTlsEntry(InputFile &File, Symbol &Sym);
198
  void addTlsIndex(InputFile &File);
199
200
  uint64_t getPageEntryOffset(const InputFile *F, const Symbol &S,
201
                              int64_t Addend) const;
202
  uint64_t getSymEntryOffset(const InputFile *F, const Symbol &S,
203
                             int64_t Addend) const;
204
  uint64_t getGlobalDynOffset(const InputFile *F, const Symbol &S) const;
205
  uint64_t getTlsIndexOffset(const InputFile *F) const;
206
207
  // Returns the symbol which corresponds to the first entry of the global part
208
  // of GOT on MIPS platform. It is required to fill up MIPS-specific dynamic
209
  // table properties.
210
  // Returns nullptr if the global part is empty.
211
  const Symbol *getFirstGlobalEntry() const;
212
213
  // Returns the number of entries in the local part of GOT including
214
  // the number of reserved entries.
215
  unsigned getLocalEntriesNum() const;
216
217
  // Return _gp value for primary GOT (nullptr) or particular input file.
218
  uint64_t getGp(const InputFile *F = nullptr) const;
219
220
private:
221
  // MIPS GOT consists of three parts: local, global and tls. Each part
222
  // contains different types of entries. Here is a layout of GOT:
223
  // - Header entries                |
224
  // - Page entries                  |   Local part
225
  // - Local entries (16-bit access) |
226
  // - Local entries (32-bit access) |
227
  // - Normal global entries         ||  Global part
228
  // - Reloc-only global entries     ||
229
  // - TLS entries                   ||| TLS part
230
  //
231
  // Header:
232
  //   Two entries hold predefined value 0x0 and 0x80000000.
233
  // Page entries:
234
  //   These entries created by R_MIPS_GOT_PAGE relocation and R_MIPS_GOT16
235
  //   relocation against local symbols. They are initialized by higher 16-bit
236
  //   of the corresponding symbol's value. So each 64kb of address space
237
  //   requires a single GOT entry.
238
  // Local entries (16-bit access):
239
  //   These entries created by GOT relocations against global non-preemptible
240
  //   symbols so dynamic linker is not necessary to resolve the symbol's
241
  //   values. "16-bit access" means that corresponding relocations address
242
  //   GOT using 16-bit index. Each unique Symbol-Addend pair has its own
243
  //   GOT entry.
244
  // Local entries (32-bit access):
245
  //   These entries are the same as above but created by relocations which
246
  //   address GOT using 32-bit index (R_MIPS_GOT_HI16/LO16 etc).
247
  // Normal global entries:
248
  //   These entries created by GOT relocations against preemptible global
249
  //   symbols. They need to be initialized by dynamic linker and they ordered
250
  //   exactly as the corresponding entries in the dynamic symbols table.
251
  // Reloc-only global entries:
252
  //   These entries created for symbols that are referenced by dynamic
253
  //   relocations R_MIPS_REL32. These entries are not accessed with gp-relative
254
  //   addressing, but MIPS ABI requires that these entries be present in GOT.
255
  // TLS entries:
256
  //   Entries created by TLS relocations.
257
  //
258
  // If the sum of local, global and tls entries is less than 64K only single
259
  // got is enough. Otherwise, multi-got is created. Series of primary and
260
  // multiple secondary GOTs have the following layout:
261
  // - Primary GOT
262
  //     Header
263
  //     Local entries
264
  //     Global entries
265
  //     Relocation only entries
266
  //     TLS entries
267
  //
268
  // - Secondary GOT
269
  //     Local entries
270
  //     Global entries
271
  //     TLS entries
272
  // ...
273
  //
274
  // All GOT entries required by relocations from a single input file entirely
275
  // belong to either primary or one of secondary GOTs. To reference GOT entries
276
  // each GOT has its own _gp value points to the "middle" of the GOT.
277
  // In the code this value loaded to the register which is used for GOT access.
278
  //
279
  // MIPS 32 function's prologue:
280
  //   lui     v0,0x0
281
  //   0: R_MIPS_HI16  _gp_disp
282
  //   addiu   v0,v0,0
283
  //   4: R_MIPS_LO16  _gp_disp
284
  //
285
  // MIPS 64:
286
  //   lui     at,0x0
287
  //   14: R_MIPS_GPREL16  main
288
  //
289
  // Dynamic linker does not know anything about secondary GOTs and cannot
290
  // use a regular MIPS mechanism for GOT entries initialization. So we have
291
  // to use an approach accepted by other architectures and create dynamic
292
  // relocations R_MIPS_REL32 to initialize global entries (and local in case
293
  // of PIC code) in secondary GOTs. But ironically MIPS dynamic linker
294
  // requires GOT entries and correspondingly ordered dynamic symbol table
295
  // entries to deal with dynamic relocations. To handle this problem
296
  // relocation-only section in the primary GOT contains entries for all
297
  // symbols referenced in global parts of secondary GOTs. Although the sum
298
  // of local and normal global entries of the primary got should be less
299
  // than 64K, the size of the primary got (including relocation-only entries
300
  // can be greater than 64K, because parts of the primary got that overflow
301
  // the 64K limit are used only by the dynamic linker at dynamic link-time
302
  // and not by 16-bit gp-relative addressing at run-time.
303
  //
304
  // For complete multi-GOT description see the following link
305
  // https://dmz-portal.mips.com/wiki/MIPS_Multi_GOT
306
307
  // Number of "Header" entries.
308
  static const unsigned HeaderEntriesNum = 2;
309
310
  uint64_t Size = 0;
311
312
  // Symbol and addend.
313
  typedef std::pair<Symbol *, int64_t> GotEntry;
314
315
  struct FileGot {
316
    InputFile *File = nullptr;
317
    size_t StartIndex = 0;
318
319
    struct PageBlock {
320
      size_t FirstIndex = 0;
321
      size_t Count = 0;
322
    };
323
324
    // Map output sections referenced by MIPS GOT relocations
325
    // to the description (index/count) "page" entries allocated
326
    // for this section.
327
    llvm::SmallMapVector<const OutputSection *, PageBlock, 16> PagesMap;
328
    // Maps from Symbol+Addend pair or just Symbol to the GOT entry index.
329
    llvm::MapVector<GotEntry, size_t> Local16;
330
    llvm::MapVector<GotEntry, size_t> Local32;
331
    llvm::MapVector<Symbol *, size_t> Global;
332
    llvm::MapVector<Symbol *, size_t> Relocs;
333
    llvm::MapVector<Symbol *, size_t> Tls;
334
    // Set of symbols referenced by dynamic TLS relocations.
335
    llvm::MapVector<Symbol *, size_t> DynTlsSymbols;
336
337
    // Total number of all entries.
338
    size_t getEntriesNum() const;
339
    // Number of "page" entries.
340
    size_t getPageEntriesNum() const;
341
    // Number of entries require 16-bit index to access.
342
    size_t getIndexedEntriesNum() const;
343
  };
344
345
  // Container of GOT created for each input file.
346
  // After building a final series of GOTs this container
347
  // holds primary and secondary GOT's.
348
  std::vector<FileGot> Gots;
349
350
  // Return (and create if necessary) `FileGot`.
351
  FileGot &getGot(InputFile &F);
352
353
  // Try to merge two GOTs. In case of success the `Dst` contains
354
  // result of merging and the function returns true. In case of
355
  // ovwerflow the `Dst` is unchanged and the function returns false.
356
  bool tryMergeGots(FileGot & Dst, FileGot & Src, bool IsPrimary);
357
};
358
359
class GotPltSection final : public SyntheticSection {
360
public:
361
  GotPltSection();
362
  void addEntry(Symbol &Sym);
363
  size_t getSize() const override;
364
  void writeTo(uint8_t *Buf) override;
365
  bool empty() const override;
366
367
private:
368
  std::vector<const Symbol *> Entries;
369
};
370
371
// The IgotPltSection is a Got associated with the PltSection for GNU Ifunc
372
// Symbols that will be relocated by Target->IRelativeRel.
373
// On most Targets the IgotPltSection will immediately follow the GotPltSection
374
// on ARM the IgotPltSection will immediately follow the GotSection.
375
class IgotPltSection final : public SyntheticSection {
376
public:
377
  IgotPltSection();
378
  void addEntry(Symbol &Sym);
379
  size_t getSize() const override;
380
  void writeTo(uint8_t *Buf) override;
381
4.59k
  bool empty() const override { return Entries.empty(); }
382
383
private:
384
  std::vector<const Symbol *> Entries;
385
};
386
387
class StringTableSection final : public SyntheticSection {
388
public:
389
  StringTableSection(StringRef Name, bool Dynamic);
390
  unsigned addString(StringRef S, bool HashIt = true);
391
  void writeTo(uint8_t *Buf) override;
392
15.9k
  size_t getSize() const override { return Size; }
393
10.8k
  bool isDynamic() const { return Dynamic; }
394
395
private:
396
  const bool Dynamic;
397
398
  uint64_t Size = 0;
399
400
  llvm::DenseMap<StringRef, unsigned> StringMap;
401
  std::vector<StringRef> Strings;
402
};
403
404
class DynamicReloc {
405
public:
406
  DynamicReloc(RelType Type, const InputSectionBase *InputSec,
407
               uint64_t OffsetInSec, bool UseSymVA, Symbol *Sym, int64_t Addend)
408
      : Type(Type), Sym(Sym), InputSec(InputSec), OffsetInSec(OffsetInSec),
409
924
        UseSymVA(UseSymVA), Addend(Addend), OutputSec(nullptr) {}
410
  // This constructor records dynamic relocation settings used by MIPS
411
  // multi-GOT implementation. It's to relocate addresses of 64kb pages
412
  // lie inside the output section.
413
  DynamicReloc(RelType Type, const InputSectionBase *InputSec,
414
               uint64_t OffsetInSec, const OutputSection *OutputSec,
415
               int64_t Addend)
416
      : Type(Type), Sym(nullptr), InputSec(InputSec), OffsetInSec(OffsetInSec),
417
6
        UseSymVA(false), Addend(Addend), OutputSec(OutputSec) {}
418
419
  uint64_t getOffset() const;
420
  uint32_t getSymIndex() const;
421
0
  const InputSectionBase *getInputSec() const { return InputSec; }
422
423
  // Computes the addend of the dynamic relocation. Note that this is not the
424
  // same as the Addend member variable as it also includes the symbol address
425
  // if UseSymVA is true.
426
  int64_t computeAddend() const;
427
428
  RelType Type;
429
430
private:
431
  Symbol *Sym;
432
  const InputSectionBase *InputSec = nullptr;
433
  uint64_t OffsetInSec;
434
  // If this member is true, the dynamic relocation will not be against the
435
  // symbol but will instead be a relative relocation that simply adds the
436
  // load address. This means we need to write the symbol virtual address
437
  // plus the original addend as the final relocation addend.
438
  bool UseSymVA;
439
  int64_t Addend;
440
  const OutputSection *OutputSec;
441
};
442
443
template <class ELFT> class DynamicSection final : public SyntheticSection {
444
  typedef typename ELFT::Dyn Elf_Dyn;
445
  typedef typename ELFT::Rel Elf_Rel;
446
  typedef typename ELFT::Rela Elf_Rela;
447
  typedef typename ELFT::Relr Elf_Relr;
448
  typedef typename ELFT::Shdr Elf_Shdr;
449
  typedef typename ELFT::Sym Elf_Sym;
450
451
  // finalizeContents() fills this vector with the section contents.
452
  std::vector<std::pair<int32_t, std::function<uint64_t()>>> Entries;
453
454
public:
455
  DynamicSection();
456
  void finalizeContents() override;
457
  void writeTo(uint8_t *Buf) override;
458
2.91k
  size_t getSize() const override { return Size; }
lld::elf::DynamicSection<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSize() const
Line
Count
Source
458
472
  size_t getSize() const override { return Size; }
lld::elf::DynamicSection<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSize() const
Line
Count
Source
458
280
  size_t getSize() const override { return Size; }
lld::elf::DynamicSection<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSize() const
Line
Count
Source
458
1.91k
  size_t getSize() const override { return Size; }
lld::elf::DynamicSection<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSize() const
Line
Count
Source
458
250
  size_t getSize() const override { return Size; }
459
460
private:
461
  void add(int32_t Tag, std::function<uint64_t()> Fn);
462
  void addInt(int32_t Tag, uint64_t Val);
463
  void addInSec(int32_t Tag, InputSection *Sec);
464
  void addInSecRelative(int32_t Tag, InputSection *Sec);
465
  void addOutSec(int32_t Tag, OutputSection *Sec);
466
  void addSize(int32_t Tag, OutputSection *Sec);
467
  void addSym(int32_t Tag, Symbol *Sym);
468
469
  uint64_t Size = 0;
470
};
471
472
class RelocationBaseSection : public SyntheticSection {
473
public:
474
  RelocationBaseSection(StringRef Name, uint32_t Type, int32_t DynamicTag,
475
                        int32_t SizeDynamicTag);
476
  void addReloc(RelType DynType, InputSectionBase *IS, uint64_t OffsetInSec,
477
                Symbol *Sym);
478
  // Add a dynamic relocation that might need an addend. This takes care of
479
  // writing the addend to the output section if needed.
480
  void addReloc(RelType DynType, InputSectionBase *InputSec,
481
                uint64_t OffsetInSec, Symbol *Sym, int64_t Addend, RelExpr Expr,
482
                RelType Type);
483
  void addReloc(const DynamicReloc &Reloc);
484
13.7k
  bool empty() const override { return Relocs.empty(); }
485
1.82k
  size_t getSize() const override { return Relocs.size() * this->Entsize; }
486
213
  size_t getRelativeRelocCount() const { return NumRelativeRelocs; }
487
  void finalizeContents() override;
488
  int32_t DynamicTag, SizeDynamicTag;
489
490
protected:
491
  std::vector<DynamicReloc> Relocs;
492
  size_t NumRelativeRelocs = 0;
493
};
494
495
template <class ELFT>
496
class RelocationSection final : public RelocationBaseSection {
497
  typedef typename ELFT::Rel Elf_Rel;
498
  typedef typename ELFT::Rela Elf_Rela;
499
500
public:
501
  RelocationSection(StringRef Name, bool Sort);
502
  unsigned getRelocOffset();
503
  void writeTo(uint8_t *Buf) override;
504
505
private:
506
  bool Sort;
507
};
508
509
template <class ELFT>
510
class AndroidPackedRelocationSection final : public RelocationBaseSection {
511
  typedef typename ELFT::Rel Elf_Rel;
512
  typedef typename ELFT::Rela Elf_Rela;
513
514
public:
515
  AndroidPackedRelocationSection(StringRef Name);
516
517
  bool updateAllocSize() override;
518
30
  size_t getSize() const override { return RelocData.size(); }
lld::elf::AndroidPackedRelocationSection<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSize() const
Line
Count
Source
518
6
  size_t getSize() const override { return RelocData.size(); }
Unexecuted instantiation: lld::elf::AndroidPackedRelocationSection<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSize() const
lld::elf::AndroidPackedRelocationSection<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSize() const
Line
Count
Source
518
24
  size_t getSize() const override { return RelocData.size(); }
Unexecuted instantiation: lld::elf::AndroidPackedRelocationSection<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSize() const
519
5
  void writeTo(uint8_t *Buf) override {
520
5
    memcpy(Buf, RelocData.data(), RelocData.size());
521
5
  }
lld::elf::AndroidPackedRelocationSection<llvm::object::ELFType<(llvm::support::endianness)1, false> >::writeTo(unsigned char*)
Line
Count
Source
519
1
  void writeTo(uint8_t *Buf) override {
520
1
    memcpy(Buf, RelocData.data(), RelocData.size());
521
1
  }
Unexecuted instantiation: lld::elf::AndroidPackedRelocationSection<llvm::object::ELFType<(llvm::support::endianness)0, false> >::writeTo(unsigned char*)
lld::elf::AndroidPackedRelocationSection<llvm::object::ELFType<(llvm::support::endianness)1, true> >::writeTo(unsigned char*)
Line
Count
Source
519
4
  void writeTo(uint8_t *Buf) override {
520
4
    memcpy(Buf, RelocData.data(), RelocData.size());
521
4
  }
Unexecuted instantiation: lld::elf::AndroidPackedRelocationSection<llvm::object::ELFType<(llvm::support::endianness)0, true> >::writeTo(unsigned char*)
522
523
private:
524
  SmallVector<char, 0> RelocData;
525
};
526
527
struct RelativeReloc {
528
164
  uint64_t getOffset() const { return InputSec->getVA(OffsetInSec); }
529
530
  const InputSectionBase *InputSec;
531
  uint64_t OffsetInSec;
532
};
533
534
class RelrBaseSection : public SyntheticSection {
535
public:
536
  RelrBaseSection();
537
8
  bool empty() const override { return Relocs.empty(); }
538
  std::vector<RelativeReloc> Relocs;
539
};
540
541
// RelrSection is used to encode offsets for relative relocations.
542
// Proposal for adding SHT_RELR sections to generic-abi is here:
543
//   https://groups.google.com/forum/#!topic/generic-abi/bX460iggiKg
544
// For more details, see the comment in RelrSection::updateAllocSize().
545
template <class ELFT> class RelrSection final : public RelrBaseSection {
546
  typedef typename ELFT::Relr Elf_Relr;
547
548
public:
549
  RelrSection();
550
551
  bool updateAllocSize() override;
552
21
  size_t getSize() const override { return RelrRelocs.size() * this->Entsize; }
lld::elf::RelrSection<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSize() const
Line
Count
Source
552
14
  size_t getSize() const override { return RelrRelocs.size() * this->Entsize; }
Unexecuted instantiation: lld::elf::RelrSection<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSize() const
lld::elf::RelrSection<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSize() const
Line
Count
Source
552
7
  size_t getSize() const override { return RelrRelocs.size() * this->Entsize; }
Unexecuted instantiation: lld::elf::RelrSection<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSize() const
553
3
  void writeTo(uint8_t *Buf) override {
554
3
    memcpy(Buf, RelrRelocs.data(), getSize());
555
3
  }
lld::elf::RelrSection<llvm::object::ELFType<(llvm::support::endianness)1, false> >::writeTo(unsigned char*)
Line
Count
Source
553
2
  void writeTo(uint8_t *Buf) override {
554
2
    memcpy(Buf, RelrRelocs.data(), getSize());
555
2
  }
Unexecuted instantiation: lld::elf::RelrSection<llvm::object::ELFType<(llvm::support::endianness)0, false> >::writeTo(unsigned char*)
lld::elf::RelrSection<llvm::object::ELFType<(llvm::support::endianness)1, true> >::writeTo(unsigned char*)
Line
Count
Source
553
1
  void writeTo(uint8_t *Buf) override {
554
1
    memcpy(Buf, RelrRelocs.data(), getSize());
555
1
  }
Unexecuted instantiation: lld::elf::RelrSection<llvm::object::ELFType<(llvm::support::endianness)0, true> >::writeTo(unsigned char*)
556
557
private:
558
  std::vector<Elf_Relr> RelrRelocs;
559
};
560
561
struct SymbolTableEntry {
562
  Symbol *Sym;
563
  size_t StrTabOffset;
564
};
565
566
class SymbolTableBaseSection : public SyntheticSection {
567
public:
568
  SymbolTableBaseSection(StringTableSection &StrTabSec);
569
  void finalizeContents() override;
570
8.86k
  size_t getSize() const override { return getNumSymbols() * Entsize; }
571
  void addSymbol(Symbol *Sym);
572
13.2k
  unsigned getNumSymbols() const { return Symbols.size() + 1; }
573
  size_t getSymbolIndex(Symbol *Sym);
574
1.29k
  ArrayRef<SymbolTableEntry> getSymbols() const { return Symbols; }
575
576
protected:
577
  void sortSymTabSymbols();
578
579
  // A vector of symbols and their string table offsets.
580
  std::vector<SymbolTableEntry> Symbols;
581
582
  StringTableSection &StrTabSec;
583
584
  llvm::once_flag OnceFlag;
585
  llvm::DenseMap<Symbol *, size_t> SymbolIndexMap;
586
  llvm::DenseMap<OutputSection *, size_t> SectionIndexMap;
587
};
588
589
template <class ELFT>
590
class SymbolTableSection final : public SymbolTableBaseSection {
591
  typedef typename ELFT::Sym Elf_Sym;
592
593
public:
594
  SymbolTableSection(StringTableSection &StrTabSec);
595
  void writeTo(uint8_t *Buf) override;
596
};
597
598
class SymtabShndxSection final : public SyntheticSection {
599
public:
600
  SymtabShndxSection();
601
602
  void writeTo(uint8_t *Buf) override;
603
  size_t getSize() const override;
604
  bool empty() const override;
605
  void finalizeContents() override;
606
};
607
608
// Outputs GNU Hash section. For detailed explanation see:
609
// https://blogs.oracle.com/ali/entry/gnu_hash_elf_sections
610
class GnuHashTableSection final : public SyntheticSection {
611
public:
612
  GnuHashTableSection();
613
  void finalizeContents() override;
614
  void writeTo(uint8_t *Buf) override;
615
2.19k
  size_t getSize() const override { return Size; }
616
617
  // Adds symbols to the hash table.
618
  // Sorts the input to satisfy GNU hash section requirements.
619
  void addSymbols(std::vector<SymbolTableEntry> &Symbols);
620
621
private:
622
  // See the comment in writeBloomFilter.
623
  enum { Shift2 = 26 };
624
625
  void writeBloomFilter(uint8_t *Buf);
626
  void writeHashTable(uint8_t *Buf);
627
628
  struct Entry {
629
    Symbol *Sym;
630
    size_t StrTabOffset;
631
    uint32_t Hash;
632
    uint32_t BucketIdx;
633
  };
634
635
  std::vector<Entry> Symbols;
636
  size_t MaskWords;
637
  size_t NBuckets = 0;
638
  size_t Size = 0;
639
};
640
641
class HashTableSection final : public SyntheticSection {
642
public:
643
  HashTableSection();
644
  void finalizeContents() override;
645
  void writeTo(uint8_t *Buf) override;
646
2.89k
  size_t getSize() const override { return Size; }
647
648
private:
649
  size_t Size = 0;
650
};
651
652
// The PltSection is used for both the Plt and Iplt. The former usually has a
653
// header as its first entry that is used at run-time to resolve lazy binding.
654
// The latter is used for GNU Ifunc symbols, that will be subject to a
655
// Target->IRelativeRel.
656
class PltSection : public SyntheticSection {
657
public:
658
  PltSection(bool IsIplt);
659
  void writeTo(uint8_t *Buf) override;
660
  size_t getSize() const override;
661
14.0k
  bool empty() const override { return Entries.empty(); }
662
  void addSymbols();
663
  template <class ELFT> void addEntry(Symbol &Sym);
664
665
  size_t HeaderSize;
666
667
private:
668
  unsigned getPltRelocOff() const;
669
  std::vector<std::pair<const Symbol *, unsigned>> Entries;
670
  bool IsIplt;
671
};
672
673
class GdbIndexSection final : public SyntheticSection {
674
public:
675
  struct AddressEntry {
676
    InputSection *Section;
677
    uint64_t LowAddress;
678
    uint64_t HighAddress;
679
    uint32_t CuIndex;
680
  };
681
682
  struct CuEntry {
683
    uint64_t CuOffset;
684
    uint64_t CuLength;
685
  };
686
687
  struct NameAttrEntry {
688
    llvm::CachedHashStringRef Name;
689
    uint32_t CuIndexAndAttrs;
690
  };
691
692
  struct GdbChunk {
693
    InputSection *Sec;
694
    std::vector<AddressEntry> AddressAreas;
695
    std::vector<CuEntry> CompilationUnits;
696
  };
697
698
  struct GdbSymbol {
699
    llvm::CachedHashStringRef Name;
700
    std::vector<uint32_t> CuVector;
701
    uint32_t NameOff;
702
    uint32_t CuVectorOff;
703
  };
704
705
  GdbIndexSection();
706
  template <typename ELFT> static GdbIndexSection *create();
707
  void writeTo(uint8_t *Buf) override;
708
26
  size_t getSize() const override { return Size; }
709
  bool empty() const override;
710
711
private:
712
  struct GdbIndexHeader {
713
    llvm::support::ulittle32_t Version;
714
    llvm::support::ulittle32_t CuListOff;
715
    llvm::support::ulittle32_t CuTypesOff;
716
    llvm::support::ulittle32_t AddressAreaOff;
717
    llvm::support::ulittle32_t SymtabOff;
718
    llvm::support::ulittle32_t ConstantPoolOff;
719
  };
720
721
  void initOutputSize();
722
  size_t computeSymtabSize() const;
723
724
  // Each chunk contains information gathered from debug sections of a
725
  // single object file.
726
  std::vector<GdbChunk> Chunks;
727
728
  // A symbol table for this .gdb_index section.
729
  std::vector<GdbSymbol> Symbols;
730
731
  size_t Size;
732
};
733
734
// --eh-frame-hdr option tells linker to construct a header for all the
735
// .eh_frame sections. This header is placed to a section named .eh_frame_hdr
736
// and also to a PT_GNU_EH_FRAME segment.
737
// At runtime the unwinder then can find all the PT_GNU_EH_FRAME segments by
738
// calling dl_iterate_phdr.
739
// This section contains a lookup table for quick binary search of FDEs.
740
// Detailed info about internals can be found in Ian Lance Taylor's blog:
741
// http://www.airs.com/blog/archives/460 (".eh_frame")
742
// http://www.airs.com/blog/archives/462 (".eh_frame_hdr")
743
class EhFrameHeader final : public SyntheticSection {
744
public:
745
  EhFrameHeader();
746
  void writeTo(uint8_t *Buf) override;
747
  size_t getSize() const override;
748
  bool empty() const override;
749
};
750
751
// For more information about .gnu.version and .gnu.version_r see:
752
// https://www.akkadia.org/drepper/symbol-versioning
753
754
// The .gnu.version_d section which has a section type of SHT_GNU_verdef shall
755
// contain symbol version definitions. The number of entries in this section
756
// shall be contained in the DT_VERDEFNUM entry of the .dynamic section.
757
// The section shall contain an array of Elf_Verdef structures, optionally
758
// followed by an array of Elf_Verdaux structures.
759
class VersionDefinitionSection final : public SyntheticSection {
760
public:
761
  VersionDefinitionSection();
762
  void finalizeContents() override;
763
  size_t getSize() const override;
764
  void writeTo(uint8_t *Buf) override;
765
766
private:
767
  enum { EntrySize = 28 };
768
  void writeOne(uint8_t *Buf, uint32_t Index, StringRef Name, size_t NameOff);
769
770
  unsigned FileDefNameOff;
771
};
772
773
// The .gnu.version section specifies the required version of each symbol in the
774
// dynamic symbol table. It contains one Elf_Versym for each dynamic symbol
775
// table entry. An Elf_Versym is just a 16-bit integer that refers to a version
776
// identifier defined in the either .gnu.version_r or .gnu.version_d section.
777
// The values 0 and 1 are reserved. All other values are used for versions in
778
// the own object or in any of the dependencies.
779
template <class ELFT>
780
class VersionTableSection final : public SyntheticSection {
781
public:
782
  VersionTableSection();
783
  void finalizeContents() override;
784
  size_t getSize() const override;
785
  void writeTo(uint8_t *Buf) override;
786
  bool empty() const override;
787
};
788
789
// The .gnu.version_r section defines the version identifiers used by
790
// .gnu.version. It contains a linked list of Elf_Verneed data structures. Each
791
// Elf_Verneed specifies the version requirements for a single DSO, and contains
792
// a reference to a linked list of Elf_Vernaux data structures which define the
793
// mapping from version identifiers to version names.
794
template <class ELFT> class VersionNeedSection final : public SyntheticSection {
795
  typedef typename ELFT::Verneed Elf_Verneed;
796
  typedef typename ELFT::Vernaux Elf_Vernaux;
797
798
  // A vector of shared files that need Elf_Verneed data structures and the
799
  // string table offsets of their sonames.
800
  std::vector<std::pair<SharedFile<ELFT> *, size_t>> Needed;
801
802
  // The next available version identifier.
803
  unsigned NextIndex;
804
805
public:
806
  VersionNeedSection();
807
  void addSymbol(Symbol *Sym);
808
  void finalizeContents() override;
809
  void writeTo(uint8_t *Buf) override;
810
  size_t getSize() const override;
811
5.54k
  size_t getNeedNum() const { return Needed.size(); }
lld::elf::VersionNeedSection<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getNeedNum() const
Line
Count
Source
811
740
  size_t getNeedNum() const { return Needed.size(); }
lld::elf::VersionNeedSection<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getNeedNum() const
Line
Count
Source
811
356
  size_t getNeedNum() const { return Needed.size(); }
lld::elf::VersionNeedSection<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getNeedNum() const
Line
Count
Source
811
4.17k
  size_t getNeedNum() const { return Needed.size(); }
lld::elf::VersionNeedSection<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getNeedNum() const
Line
Count
Source
811
280
  size_t getNeedNum() const { return Needed.size(); }
812
  bool empty() const override;
813
};
814
815
// MergeSyntheticSection is a class that allows us to put mergeable sections
816
// with different attributes in a single output sections. To do that
817
// we put them into MergeSyntheticSection synthetic input sections which are
818
// attached to regular output sections.
819
class MergeSyntheticSection : public SyntheticSection {
820
public:
821
  void addSection(MergeInputSection *MS);
822
  std::vector<MergeInputSection *> Sections;
823
824
protected:
825
  MergeSyntheticSection(StringRef Name, uint32_t Type, uint64_t Flags,
826
                        uint32_t Alignment)
827
2.40k
      : SyntheticSection(Flags, Type, Alignment, Name) {}
828
};
829
830
class MergeTailSection final : public MergeSyntheticSection {
831
public:
832
  MergeTailSection(StringRef Name, uint32_t Type, uint64_t Flags,
833
                   uint32_t Alignment);
834
835
  size_t getSize() const override;
836
  void writeTo(uint8_t *Buf) override;
837
  void finalizeContents() override;
838
839
private:
840
  llvm::StringTableBuilder Builder;
841
};
842
843
class MergeNoTailSection final : public MergeSyntheticSection {
844
public:
845
  MergeNoTailSection(StringRef Name, uint32_t Type, uint64_t Flags,
846
                     uint32_t Alignment)
847
2.40k
      : MergeSyntheticSection(Name, Type, Flags, Alignment) {}
848
849
5.90k
  size_t getSize() const override { return Size; }
850
  void writeTo(uint8_t *Buf) override;
851
  void finalizeContents() override;
852
853
private:
854
  // We use the most significant bits of a hash as a shard ID.
855
  // The reason why we don't want to use the least significant bits is
856
  // because DenseMap also uses lower bits to determine a bucket ID.
857
  // If we use lower bits, it significantly increases the probability of
858
  // hash collisons.
859
12.4k
  size_t getShardId(uint32_t Hash) {
860
12.4k
    return Hash >> (32 - llvm::countTrailingZeros(NumShards));
861
12.4k
  }
862
863
  // Section size
864
  size_t Size;
865
866
  // String table contents
867
  constexpr static size_t NumShards = 32;
868
  std::vector<llvm::StringTableBuilder> Shards;
869
  size_t ShardOffsets[NumShards];
870
};
871
872
// .MIPS.abiflags section.
873
template <class ELFT>
874
class MipsAbiFlagsSection final : public SyntheticSection {
875
  typedef llvm::object::Elf_Mips_ABIFlags<ELFT> Elf_Mips_ABIFlags;
876
877
public:
878
  static MipsAbiFlagsSection *create();
879
880
  MipsAbiFlagsSection(Elf_Mips_ABIFlags Flags);
881
744
  size_t getSize() const override { return sizeof(Elf_Mips_ABIFlags); }
lld::elf::MipsAbiFlagsSection<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSize() const
Line
Count
Source
881
92
  size_t getSize() const override { return sizeof(Elf_Mips_ABIFlags); }
lld::elf::MipsAbiFlagsSection<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSize() const
Line
Count
Source
881
488
  size_t getSize() const override { return sizeof(Elf_Mips_ABIFlags); }
lld::elf::MipsAbiFlagsSection<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSize() const
Line
Count
Source
881
12
  size_t getSize() const override { return sizeof(Elf_Mips_ABIFlags); }
lld::elf::MipsAbiFlagsSection<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSize() const
Line
Count
Source
881
152
  size_t getSize() const override { return sizeof(Elf_Mips_ABIFlags); }
882
  void writeTo(uint8_t *Buf) override;
883
884
private:
885
  Elf_Mips_ABIFlags Flags;
886
};
887
888
// .MIPS.options section.
889
template <class ELFT> class MipsOptionsSection final : public SyntheticSection {
890
  typedef llvm::object::Elf_Mips_Options<ELFT> Elf_Mips_Options;
891
  typedef llvm::object::Elf_Mips_RegInfo<ELFT> Elf_Mips_RegInfo;
892
893
public:
894
  static MipsOptionsSection *create();
895
896
  MipsOptionsSection(Elf_Mips_RegInfo Reginfo);
897
  void writeTo(uint8_t *Buf) override;
898
899
205
  size_t getSize() const override {
900
205
    return sizeof(Elf_Mips_Options) + sizeof(Elf_Mips_RegInfo);
901
205
  }
Unexecuted instantiation: lld::elf::MipsOptionsSection<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSize() const
Unexecuted instantiation: lld::elf::MipsOptionsSection<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSize() const
lld::elf::MipsOptionsSection<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSize() const
Line
Count
Source
899
15
  size_t getSize() const override {
900
15
    return sizeof(Elf_Mips_Options) + sizeof(Elf_Mips_RegInfo);
901
15
  }
lld::elf::MipsOptionsSection<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSize() const
Line
Count
Source
899
190
  size_t getSize() const override {
900
190
    return sizeof(Elf_Mips_Options) + sizeof(Elf_Mips_RegInfo);
901
190
  }
902
903
private:
904
  Elf_Mips_RegInfo Reginfo;
905
};
906
907
// MIPS .reginfo section.
908
template <class ELFT> class MipsReginfoSection final : public SyntheticSection {
909
  typedef llvm::object::Elf_Mips_RegInfo<ELFT> Elf_Mips_RegInfo;
910
911
public:
912
  static MipsReginfoSection *create();
913
914
  MipsReginfoSection(Elf_Mips_RegInfo Reginfo);
915
580
  size_t getSize() const override { return sizeof(Elf_Mips_RegInfo); }
lld::elf::MipsReginfoSection<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSize() const
Line
Count
Source
915
92
  size_t getSize() const override { return sizeof(Elf_Mips_RegInfo); }
lld::elf::MipsReginfoSection<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSize() const
Line
Count
Source
915
488
  size_t getSize() const override { return sizeof(Elf_Mips_RegInfo); }
Unexecuted instantiation: lld::elf::MipsReginfoSection<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSize() const
Unexecuted instantiation: lld::elf::MipsReginfoSection<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSize() const
916
  void writeTo(uint8_t *Buf) override;
917
918
private:
919
  Elf_Mips_RegInfo Reginfo;
920
};
921
922
// This is a MIPS specific section to hold a space within the data segment
923
// of executable file which is pointed to by the DT_MIPS_RLD_MAP entry.
924
// See "Dynamic section" in Chapter 5 in the following document:
925
// ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
926
class MipsRldMapSection : public SyntheticSection {
927
public:
928
  MipsRldMapSection();
929
116
  size_t getSize() const override { return Config->Wordsize; }
930
29
  void writeTo(uint8_t *Buf) override {}
931
};
932
933
class ARMExidxSentinelSection : public SyntheticSection {
934
public:
935
  ARMExidxSentinelSection();
936
88
  size_t getSize() const override { return 8; }
937
  void writeTo(uint8_t *Buf) override;
938
  bool empty() const override;
939
940
  static bool classof(const SectionBase *D);
941
942
  // The last section referenced by a regular .ARM.exidx section.
943
  // It is found and filled in Writer<ELFT>::resolveShfLinkOrder().
944
  // The sentinel points at the end of that section.
945
  InputSection *Highest = nullptr;
946
};
947
948
// A container for one or more linker generated thunks. Instances of these
949
// thunks including ARM interworking and Mips LA25 PI to non-PI thunks.
950
class ThunkSection : public SyntheticSection {
951
public:
952
  // ThunkSection in OS, with desired OutSecOff of Off
953
  ThunkSection(OutputSection *OS, uint64_t Off);
954
955
  // Add a newly created Thunk to this container:
956
  // Thunk is given offset from start of this InputSection
957
  // Thunk defines a symbol in this InputSection that can be used as target
958
  // of a relocation
959
  void addThunk(Thunk *T);
960
1.37k
  size_t getSize() const override { return Size; }
961
  void writeTo(uint8_t *Buf) override;
962
  InputSection *getTargetInputSection() const;
963
  bool assignOffsets();
964
965
private:
966
  std::vector<Thunk *> Thunks;
967
  size_t Size = 0;
968
};
969
970
// This section is used to store the addresses of functions that are called
971
// in range-extending thunks on PowerPC64. When producing position dependant
972
// code the addresses are link-time constants and the table is written out to
973
// the binary. When producing position-dependant code the table is allocated and
974
// filled in by the dynamic linker.
975
class PPC64LongBranchTargetSection final : public SyntheticSection {
976
public:
977
  PPC64LongBranchTargetSection();
978
  void addEntry(Symbol &Sym);
979
  size_t getSize() const override;
980
  void writeTo(uint8_t *Buf) override;
981
  bool empty() const override;
982
140
  void finalizeContents() override { Finalized = true; }
983
984
private:
985
  std::vector<const Symbol *> Entries;
986
  bool Finalized = false;
987
};
988
989
InputSection *createInterpSection();
990
MergeInputSection *createCommentSection();
991
template <class ELFT> void splitSections();
992
void mergeSections();
993
994
Defined *addSyntheticLocal(StringRef Name, uint8_t Type, uint64_t Value,
995
                           uint64_t Size, InputSectionBase &Section);
996
997
// Linker generated sections which can be used as inputs.
998
struct InStruct {
999
  InputSection *ARMAttributes;
1000
  BssSection *Bss;
1001
  BssSection *BssRelRo;
1002
  BuildIdSection *BuildId;
1003
  EhFrameHeader *EhFrameHdr;
1004
  EhFrameSection *EhFrame;
1005
  SyntheticSection *Dynamic;
1006
  StringTableSection *DynStrTab;
1007
  SymbolTableBaseSection *DynSymTab;
1008
  GnuHashTableSection *GnuHashTab;
1009
  HashTableSection *HashTab;
1010
  InputSection *Interp;
1011
  GdbIndexSection *GdbIndex;
1012
  GotSection *Got;
1013
  GotPltSection *GotPlt;
1014
  IgotPltSection *IgotPlt;
1015
  PPC64LongBranchTargetSection *PPC64LongBranchTarget;
1016
  MipsGotSection *MipsGot;
1017
  MipsRldMapSection *MipsRldMap;
1018
  PltSection *Plt;
1019
  PltSection *Iplt;
1020
  RelocationBaseSection *RelaDyn;
1021
  RelrBaseSection *RelrDyn;
1022
  RelocationBaseSection *RelaPlt;
1023
  RelocationBaseSection *RelaIplt;
1024
  StringTableSection *ShStrTab;
1025
  StringTableSection *StrTab;
1026
  SymbolTableBaseSection *SymTab;
1027
  SymtabShndxSection *SymTabShndx;
1028
  VersionDefinitionSection *VerDef;
1029
};
1030
1031
extern InStruct In;
1032
1033
template <class ELFT> struct InX {
1034
  static VersionTableSection<ELFT> *VerSym;
1035
  static VersionNeedSection<ELFT> *VerNeed;
1036
};
1037
1038
template <class ELFT> VersionTableSection<ELFT> *InX<ELFT>::VerSym;
1039
template <class ELFT> VersionNeedSection<ELFT> *InX<ELFT>::VerNeed;
1040
} // namespace elf
1041
} // namespace lld
1042
1043
#endif