Coverage Report

Created: 2018-08-19 14:04

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/lld/ELF/InputFiles.h
Line
Count
Source (jump to first uncovered line)
1
//===- InputFiles.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
#ifndef LLD_ELF_INPUT_FILES_H
11
#define LLD_ELF_INPUT_FILES_H
12
13
#include "Config.h"
14
#include "lld/Common/ErrorHandler.h"
15
#include "lld/Common/LLVM.h"
16
#include "lld/Common/Reproduce.h"
17
#include "llvm/ADT/CachedHashString.h"
18
#include "llvm/ADT/DenseSet.h"
19
#include "llvm/ADT/STLExtras.h"
20
#include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
21
#include "llvm/IR/Comdat.h"
22
#include "llvm/Object/Archive.h"
23
#include "llvm/Object/ELF.h"
24
#include "llvm/Object/IRObjectFile.h"
25
#include "llvm/Support/Threading.h"
26
#include <map>
27
28
namespace llvm {
29
class TarWriter;
30
struct DILineInfo;
31
namespace lto {
32
class InputFile;
33
}
34
} // namespace llvm
35
36
namespace lld {
37
namespace elf {
38
class InputFile;
39
class InputSectionBase;
40
}
41
42
// Returns "<internal>", "foo.a(bar.o)" or "baz.o".
43
std::string toString(const elf::InputFile *F);
44
45
namespace elf {
46
47
using llvm::object::Archive;
48
49
class Symbol;
50
51
// If -reproduce option is given, all input files are written
52
// to this tar archive.
53
extern llvm::TarWriter *Tar;
54
55
// Opens a given file.
56
llvm::Optional<MemoryBufferRef> readFile(StringRef Path);
57
58
// The root class of input files.
59
class InputFile {
60
public:
61
  enum Kind {
62
    ObjKind,
63
    SharedKind,
64
    LazyObjKind,
65
    ArchiveKind,
66
    BitcodeKind,
67
    BinaryKind,
68
  };
69
70
38.9k
  Kind kind() const { return FileKind; }
71
72
3.99k
  bool isElf() const {
73
3.99k
    Kind K = kind();
74
3.99k
    return K == ObjKind || 
K == SharedKind908
;
75
3.99k
  }
76
77
133k
  StringRef getName() const { return MB.getBufferIdentifier(); }
78
  MemoryBufferRef MB;
79
80
  // Returns sections. It is a runtime error to call this function
81
  // on files that don't have the notion of sections.
82
3.41k
  ArrayRef<InputSectionBase *> getSections() const {
83
3.41k
    assert(FileKind == ObjKind || FileKind == BinaryKind);
84
3.41k
    return Sections;
85
3.41k
  }
86
87
  // Returns object file symbols. It is a runtime error to call this
88
  // function on files of other types.
89
2.43k
  ArrayRef<Symbol *> getSymbols() {
90
2.43k
    assert(FileKind == BinaryKind || FileKind == ObjKind ||
91
2.43k
           FileKind == BitcodeKind);
92
2.43k
    return Symbols;
93
2.43k
  }
94
95
  // Filename of .a which contained this file. If this file was
96
  // not in an archive file, it is the empty string. We use this
97
  // string for creating error messages.
98
  std::string ArchiveName;
99
100
  // If this is an architecture-specific file, the following members
101
  // have ELF type (i.e. ELF{32,64}{LE,BE}) and target machine type.
102
  ELFKind EKind = ELFNoneKind;
103
  uint16_t EMachine = llvm::ELF::EM_NONE;
104
  uint8_t OSABI = 0;
105
106
  // Cache for toString(). Only toString() should use this member.
107
  mutable std::string ToStringCache;
108
109
  std::string getSrcMsg(const Symbol &Sym, InputSectionBase &Sec,
110
                        uint64_t Offset);
111
112
  // True if this is an argument for --just-symbols. Usually false.
113
  bool JustSymbols = false;
114
115
  // GroupId is used for --warn-backrefs which is an optional error
116
  // checking feature. All files within the same --{start,end}-group or
117
  // --{start,end}-lib get the same group ID. Otherwise, each file gets a new
118
  // group ID. For more info, see checkDependency() in SymbolTable.cpp.
119
  uint32_t GroupId;
120
  static bool IsInGroup;
121
  static uint32_t NextGroupId;
122
123
  // Index of MIPS GOT built for this file.
124
  llvm::Optional<size_t> MipsGotIndex;
125
126
protected:
127
  InputFile(Kind K, MemoryBufferRef M);
128
  std::vector<InputSectionBase *> Sections;
129
  std::vector<Symbol *> Symbols;
130
131
private:
132
  const Kind FileKind;
133
};
134
135
template <typename ELFT> class ELFFileBase : public InputFile {
136
public:
137
  typedef typename ELFT::Shdr Elf_Shdr;
138
  typedef typename ELFT::Sym Elf_Sym;
139
  typedef typename ELFT::Word Elf_Word;
140
  typedef typename ELFT::SymRange Elf_Sym_Range;
141
142
  ELFFileBase(Kind K, MemoryBufferRef M);
143
520
  static bool classof(const InputFile *F) { return F->isElf(); }
lld::elf::ELFFileBase<llvm::object::ELFType<(llvm::support::endianness)1, false> >::classof(lld::elf::InputFile const*)
Line
Count
Source
143
44
  static bool classof(const InputFile *F) { return F->isElf(); }
lld::elf::ELFFileBase<llvm::object::ELFType<(llvm::support::endianness)0, false> >::classof(lld::elf::InputFile const*)
Line
Count
Source
143
361
  static bool classof(const InputFile *F) { return F->isElf(); }
lld::elf::ELFFileBase<llvm::object::ELFType<(llvm::support::endianness)1, true> >::classof(lld::elf::InputFile const*)
Line
Count
Source
143
3
  static bool classof(const InputFile *F) { return F->isElf(); }
lld::elf::ELFFileBase<llvm::object::ELFType<(llvm::support::endianness)0, true> >::classof(lld::elf::InputFile const*)
Line
Count
Source
143
112
  static bool classof(const InputFile *F) { return F->isElf(); }
144
145
778k
  llvm::object::ELFFile<ELFT> getObj() const {
146
778k
    return check(llvm::object::ELFFile<ELFT>::create(MB.getBuffer()));
147
778k
  }
lld::elf::ELFFileBase<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getObj() const
Line
Count
Source
145
755k
  llvm::object::ELFFile<ELFT> getObj() const {
146
755k
    return check(llvm::object::ELFFile<ELFT>::create(MB.getBuffer()));
147
755k
  }
lld::elf::ELFFileBase<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getObj() const
Line
Count
Source
145
7.10k
  llvm::object::ELFFile<ELFT> getObj() const {
146
7.10k
    return check(llvm::object::ELFFile<ELFT>::create(MB.getBuffer()));
147
7.10k
  }
lld::elf::ELFFileBase<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getObj() const
Line
Count
Source
145
3.83k
  llvm::object::ELFFile<ELFT> getObj() const {
146
3.83k
    return check(llvm::object::ELFFile<ELFT>::create(MB.getBuffer()));
147
3.83k
  }
lld::elf::ELFFileBase<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getObj() const
Line
Count
Source
145
12.0k
  llvm::object::ELFFile<ELFT> getObj() const {
146
12.0k
    return check(llvm::object::ELFFile<ELFT>::create(MB.getBuffer()));
147
12.0k
  }
148
149
85
  StringRef getStringTable() const { return StringTable; }
lld::elf::ELFFileBase<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getStringTable() const
Line
Count
Source
149
6
  StringRef getStringTable() const { return StringTable; }
lld::elf::ELFFileBase<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getStringTable() const
Line
Count
Source
149
6
  StringRef getStringTable() const { return StringTable; }
lld::elf::ELFFileBase<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getStringTable() const
Line
Count
Source
149
73
  StringRef getStringTable() const { return StringTable; }
Unexecuted instantiation: lld::elf::ELFFileBase<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getStringTable() const
150
151
  uint32_t getSectionIndex(const Elf_Sym &Sym) const;
152
153
  Elf_Sym_Range getGlobalELFSyms();
154
88
  Elf_Sym_Range getELFSyms() const { return ELFSyms; }
lld::elf::ELFFileBase<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getELFSyms() const
Line
Count
Source
154
6
  Elf_Sym_Range getELFSyms() const { return ELFSyms; }
Unexecuted instantiation: lld::elf::ELFFileBase<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getELFSyms() const
lld::elf::ELFFileBase<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getELFSyms() const
Line
Count
Source
154
82
  Elf_Sym_Range getELFSyms() const { return ELFSyms; }
Unexecuted instantiation: lld::elf::ELFFileBase<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getELFSyms() const
155
156
protected:
157
  ArrayRef<Elf_Sym> ELFSyms;
158
  uint32_t FirstGlobal = 0;
159
  ArrayRef<Elf_Word> SymtabSHNDX;
160
  StringRef StringTable;
161
  void initSymtab(ArrayRef<Elf_Shdr> Sections, const Elf_Shdr *Symtab);
162
};
163
164
// .o file.
165
template <class ELFT> class ObjFile : public ELFFileBase<ELFT> {
166
  typedef ELFFileBase<ELFT> Base;
167
  typedef typename ELFT::Rel Elf_Rel;
168
  typedef typename ELFT::Rela Elf_Rela;
169
  typedef typename ELFT::Sym Elf_Sym;
170
  typedef typename ELFT::Shdr Elf_Shdr;
171
  typedef typename ELFT::Word Elf_Word;
172
173
  StringRef getShtGroupSignature(ArrayRef<Elf_Shdr> Sections,
174
                                 const Elf_Shdr &Sec);
175
  ArrayRef<Elf_Word> getShtGroupEntries(const Elf_Shdr &Sec);
176
177
public:
178
0
  static bool classof(const InputFile *F) { return F->kind() == Base::ObjKind; }
Unexecuted instantiation: lld::elf::ObjFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::classof(lld::elf::InputFile const*)
Unexecuted instantiation: lld::elf::ObjFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::classof(lld::elf::InputFile const*)
Unexecuted instantiation: lld::elf::ObjFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::classof(lld::elf::InputFile const*)
Unexecuted instantiation: lld::elf::ObjFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::classof(lld::elf::InputFile const*)
179
180
  ArrayRef<Symbol *> getLocalSymbols();
181
  ArrayRef<Symbol *> getGlobalSymbols();
182
183
  ObjFile(MemoryBufferRef M, StringRef ArchiveName);
184
  void parse(llvm::DenseSet<llvm::CachedHashStringRef> &ComdatGroups);
185
186
13.9k
  Symbol &getSymbol(uint32_t SymbolIndex) const {
187
13.9k
    if (SymbolIndex >= this->Symbols.size())
188
0
      fatal(toString(this) + ": invalid symbol index");
189
13.9k
    return *this->Symbols[SymbolIndex];
190
13.9k
  }
lld::elf::ObjFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getSymbol(unsigned int) const
Line
Count
Source
186
920
  Symbol &getSymbol(uint32_t SymbolIndex) const {
187
920
    if (SymbolIndex >= this->Symbols.size())
188
0
      fatal(toString(this) + ": invalid symbol index");
189
920
    return *this->Symbols[SymbolIndex];
190
920
  }
lld::elf::ObjFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getSymbol(unsigned int) const
Line
Count
Source
186
285
  Symbol &getSymbol(uint32_t SymbolIndex) const {
187
285
    if (SymbolIndex >= this->Symbols.size())
188
0
      fatal(toString(this) + ": invalid symbol index");
189
285
    return *this->Symbols[SymbolIndex];
190
285
  }
lld::elf::ObjFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getSymbol(unsigned int) const
Line
Count
Source
186
2.46k
  Symbol &getSymbol(uint32_t SymbolIndex) const {
187
2.46k
    if (SymbolIndex >= this->Symbols.size())
188
0
      fatal(toString(this) + ": invalid symbol index");
189
2.46k
    return *this->Symbols[SymbolIndex];
190
2.46k
  }
lld::elf::ObjFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getSymbol(unsigned int) const
Line
Count
Source
186
10.2k
  Symbol &getSymbol(uint32_t SymbolIndex) const {
187
10.2k
    if (SymbolIndex >= this->Symbols.size())
188
0
      fatal(toString(this) + ": invalid symbol index");
189
10.2k
    return *this->Symbols[SymbolIndex];
190
10.2k
  }
191
192
13.9k
  template <typename RelT> Symbol &getRelocTargetSym(const RelT &Rel) const {
193
13.9k
    uint32_t SymIndex = Rel.getSymbol(Config->IsMips64EL);
194
13.9k
    return getSymbol(SymIndex);
195
13.9k
  }
lld::elf::Symbol& lld::elf::ObjFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getRelocTargetSym<llvm::object::Elf_Rel_Impl<llvm::object::ELFType<(llvm::support::endianness)1, false>, true> >(llvm::object::Elf_Rel_Impl<llvm::object::ELFType<(llvm::support::endianness)1, false>, true> const&) const
Line
Count
Source
192
73
  template <typename RelT> Symbol &getRelocTargetSym(const RelT &Rel) const {
193
73
    uint32_t SymIndex = Rel.getSymbol(Config->IsMips64EL);
194
73
    return getSymbol(SymIndex);
195
73
  }
lld::elf::Symbol& lld::elf::ObjFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::getRelocTargetSym<llvm::object::Elf_Rel_Impl<llvm::object::ELFType<(llvm::support::endianness)1, false>, false> >(llvm::object::Elf_Rel_Impl<llvm::object::ELFType<(llvm::support::endianness)1, false>, false> const&) const
Line
Count
Source
192
847
  template <typename RelT> Symbol &getRelocTargetSym(const RelT &Rel) const {
193
847
    uint32_t SymIndex = Rel.getSymbol(Config->IsMips64EL);
194
847
    return getSymbol(SymIndex);
195
847
  }
lld::elf::Symbol& lld::elf::ObjFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getRelocTargetSym<llvm::object::Elf_Rel_Impl<llvm::object::ELFType<(llvm::support::endianness)0, false>, true> >(llvm::object::Elf_Rel_Impl<llvm::object::ELFType<(llvm::support::endianness)0, false>, true> const&) const
Line
Count
Source
192
13
  template <typename RelT> Symbol &getRelocTargetSym(const RelT &Rel) const {
193
13
    uint32_t SymIndex = Rel.getSymbol(Config->IsMips64EL);
194
13
    return getSymbol(SymIndex);
195
13
  }
lld::elf::Symbol& lld::elf::ObjFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::getRelocTargetSym<llvm::object::Elf_Rel_Impl<llvm::object::ELFType<(llvm::support::endianness)0, false>, false> >(llvm::object::Elf_Rel_Impl<llvm::object::ELFType<(llvm::support::endianness)0, false>, false> const&) const
Line
Count
Source
192
271
  template <typename RelT> Symbol &getRelocTargetSym(const RelT &Rel) const {
193
271
    uint32_t SymIndex = Rel.getSymbol(Config->IsMips64EL);
194
271
    return getSymbol(SymIndex);
195
271
  }
lld::elf::Symbol& lld::elf::ObjFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getRelocTargetSym<llvm::object::Elf_Rel_Impl<llvm::object::ELFType<(llvm::support::endianness)1, true>, true> >(llvm::object::Elf_Rel_Impl<llvm::object::ELFType<(llvm::support::endianness)1, true>, true> const&) const
Line
Count
Source
192
2.46k
  template <typename RelT> Symbol &getRelocTargetSym(const RelT &Rel) const {
193
2.46k
    uint32_t SymIndex = Rel.getSymbol(Config->IsMips64EL);
194
2.46k
    return getSymbol(SymIndex);
195
2.46k
  }
lld::elf::Symbol& lld::elf::ObjFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::getRelocTargetSym<llvm::object::Elf_Rel_Impl<llvm::object::ELFType<(llvm::support::endianness)1, true>, false> >(llvm::object::Elf_Rel_Impl<llvm::object::ELFType<(llvm::support::endianness)1, true>, false> const&) const
Line
Count
Source
192
2
  template <typename RelT> Symbol &getRelocTargetSym(const RelT &Rel) const {
193
2
    uint32_t SymIndex = Rel.getSymbol(Config->IsMips64EL);
194
2
    return getSymbol(SymIndex);
195
2
  }
lld::elf::Symbol& lld::elf::ObjFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getRelocTargetSym<llvm::object::Elf_Rel_Impl<llvm::object::ELFType<(llvm::support::endianness)0, true>, true> >(llvm::object::Elf_Rel_Impl<llvm::object::ELFType<(llvm::support::endianness)0, true>, true> const&) const
Line
Count
Source
192
10.2k
  template <typename RelT> Symbol &getRelocTargetSym(const RelT &Rel) const {
193
10.2k
    uint32_t SymIndex = Rel.getSymbol(Config->IsMips64EL);
194
10.2k
    return getSymbol(SymIndex);
195
10.2k
  }
Unexecuted instantiation: lld::elf::Symbol& lld::elf::ObjFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::getRelocTargetSym<llvm::object::Elf_Rel_Impl<llvm::object::ELFType<(llvm::support::endianness)0, true>, false> >(llvm::object::Elf_Rel_Impl<llvm::object::ELFType<(llvm::support::endianness)0, true>, false> const&) const
196
197
  llvm::Optional<llvm::DILineInfo> getDILineInfo(InputSectionBase *, uint64_t);
198
  llvm::Optional<std::pair<std::string, unsigned>> getVariableLoc(StringRef Name);
199
200
  // MIPS GP0 value defined by this file. This value represents the gp value
201
  // used to create the relocatable object and required to support
202
  // R_MIPS_GPREL16 / R_MIPS_GPREL32 relocations.
203
  uint32_t MipsGp0 = 0;
204
205
  // Name of source file obtained from STT_FILE symbol value,
206
  // or empty string if there is no such symbol in object file
207
  // symbol table.
208
  StringRef SourceFile;
209
210
  // True if the file defines functions compiled with
211
  // -fsplit-stack. Usually false.
212
  bool SplitStack = false;
213
214
  // True if the file defines functions compiled with -fsplit-stack,
215
  // but had one or more functions with the no_split_stack attribute.
216
  bool SomeNoSplitStack = false;
217
218
  // Pointer to this input file's .llvm_addrsig section, if it has one.
219
  const Elf_Shdr *AddrsigSec = nullptr;
220
221
private:
222
  void
223
  initializeSections(llvm::DenseSet<llvm::CachedHashStringRef> &ComdatGroups);
224
  void initializeSymbols();
225
  void initializeJustSymbols();
226
  void initializeDwarf();
227
  InputSectionBase *getRelocTarget(const Elf_Shdr &Sec);
228
  InputSectionBase *createInputSection(const Elf_Shdr &Sec);
229
  StringRef getSectionName(const Elf_Shdr &Sec);
230
231
  bool shouldMerge(const Elf_Shdr &Sec);
232
  Symbol *createSymbol(const Elf_Sym *Sym);
233
234
  // .shstrtab contents.
235
  StringRef SectionStringTable;
236
237
  // Debugging information to retrieve source file and line for error
238
  // reporting. Linker may find reasonable number of errors in a
239
  // single object file, so we cache debugging information in order to
240
  // parse it only once for each object file we link.
241
  std::unique_ptr<llvm::DWARFContext> Dwarf;
242
  std::vector<const llvm::DWARFDebugLine::LineTable *> LineTables;
243
  struct VarLoc {
244
    const llvm::DWARFDebugLine::LineTable *LT;
245
    unsigned File;
246
    unsigned Line;
247
  };
248
  llvm::DenseMap<StringRef, VarLoc> VariableLoc;
249
  llvm::once_flag InitDwarfLine;
250
};
251
252
// LazyObjFile is analogous to ArchiveFile in the sense that
253
// the file contains lazy symbols. The difference is that
254
// LazyObjFile wraps a single file instead of multiple files.
255
//
256
// This class is used for --start-lib and --end-lib options which
257
// instruct the linker to link object files between them with the
258
// archive file semantics.
259
class LazyObjFile : public InputFile {
260
public:
261
  LazyObjFile(MemoryBufferRef M, StringRef ArchiveName,
262
              uint64_t OffsetInArchive)
263
29
      : InputFile(LazyObjKind, M), OffsetInArchive(OffsetInArchive) {
264
29
    this->ArchiveName = ArchiveName;
265
29
  }
266
267
3.19k
  static bool classof(const InputFile *F) { return F->kind() == LazyObjKind; }
268
269
  template <class ELFT> void parse();
270
  MemoryBufferRef getBuffer();
271
  InputFile *fetch();
272
  bool AddedToLink = false;
273
274
private:
275
  template <class ELFT> void addElfSymbols();
276
277
  uint64_t OffsetInArchive;
278
};
279
280
// An ArchiveFile object represents a .a file.
281
class ArchiveFile : public InputFile {
282
public:
283
  explicit ArchiveFile(std::unique_ptr<Archive> &&File);
284
3.29k
  static bool classof(const InputFile *F) { return F->kind() == ArchiveKind; }
285
  template <class ELFT> void parse();
286
287
  // Pulls out an object file that contains a definition for Sym and
288
  // returns it. If the same file was instantiated before, this
289
  // function returns a nullptr (so we don't instantiate the same file
290
  // more than once.)
291
  InputFile *fetch(const Archive::Symbol &Sym);
292
293
private:
294
  std::unique_ptr<Archive> File;
295
  llvm::DenseSet<uint64_t> Seen;
296
};
297
298
class BitcodeFile : public InputFile {
299
public:
300
  BitcodeFile(MemoryBufferRef M, StringRef ArchiveName,
301
              uint64_t OffsetInArchive);
302
3.20k
  static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; }
303
  template <class ELFT>
304
  void parse(llvm::DenseSet<llvm::CachedHashStringRef> &ComdatGroups);
305
  std::unique_ptr<llvm::lto::InputFile> Obj;
306
};
307
308
// .so file.
309
template <class ELFT> class SharedFile : public ELFFileBase<ELFT> {
310
  typedef ELFFileBase<ELFT> Base;
311
  typedef typename ELFT::Dyn Elf_Dyn;
312
  typedef typename ELFT::Shdr Elf_Shdr;
313
  typedef typename ELFT::Sym Elf_Sym;
314
  typedef typename ELFT::SymRange Elf_Sym_Range;
315
  typedef typename ELFT::Verdef Elf_Verdef;
316
  typedef typename ELFT::Versym Elf_Versym;
317
318
  const Elf_Shdr *VersymSec = nullptr;
319
  const Elf_Shdr *VerdefSec = nullptr;
320
321
public:
322
  std::vector<const Elf_Verdef *> Verdefs;
323
  std::string SoName;
324
325
4.98k
  static bool classof(const InputFile *F) {
326
4.98k
    return F->kind() == Base::SharedKind;
327
4.98k
  }
lld::elf::SharedFile<llvm::object::ELFType<(llvm::support::endianness)1, false> >::classof(lld::elf::InputFile const*)
Line
Count
Source
325
690
  static bool classof(const InputFile *F) {
326
690
    return F->kind() == Base::SharedKind;
327
690
  }
lld::elf::SharedFile<llvm::object::ELFType<(llvm::support::endianness)0, false> >::classof(lld::elf::InputFile const*)
Line
Count
Source
325
342
  static bool classof(const InputFile *F) {
326
342
    return F->kind() == Base::SharedKind;
327
342
  }
lld::elf::SharedFile<llvm::object::ELFType<(llvm::support::endianness)1, true> >::classof(lld::elf::InputFile const*)
Line
Count
Source
325
3.73k
  static bool classof(const InputFile *F) {
326
3.73k
    return F->kind() == Base::SharedKind;
327
3.73k
  }
lld::elf::SharedFile<llvm::object::ELFType<(llvm::support::endianness)0, true> >::classof(lld::elf::InputFile const*)
Line
Count
Source
325
220
  static bool classof(const InputFile *F) {
326
220
    return F->kind() == Base::SharedKind;
327
220
  }
328
329
  SharedFile(MemoryBufferRef M, StringRef DefaultSoName);
330
331
  void parseSoName();
332
  void parseRest();
333
  uint32_t getAlignment(ArrayRef<Elf_Shdr> Sections, const Elf_Sym &Sym);
334
  std::vector<const Elf_Verdef *> parseVerdefs();
335
  std::vector<uint32_t> parseVersyms();
336
337
  struct NeededVer {
338
    // The string table offset of the version name in the output file.
339
    size_t StrTab;
340
341
    // The version identifier for this version name.
342
    uint16_t Index;
343
  };
344
345
  // Mapping from Elf_Verdef data structures to information about Elf_Vernaux
346
  // data structures in the output file.
347
  std::map<const Elf_Verdef *, NeededVer> VerdefMap;
348
349
  // Used for --as-needed
350
  bool IsNeeded;
351
};
352
353
class BinaryFile : public InputFile {
354
public:
355
6
  explicit BinaryFile(MemoryBufferRef M) : InputFile(BinaryKind, M) {}
356
3.30k
  static bool classof(const InputFile *F) { return F->kind() == BinaryKind; }
357
  void parse();
358
};
359
360
InputFile *createObjectFile(MemoryBufferRef MB, StringRef ArchiveName = "",
361
                            uint64_t OffsetInArchive = 0);
362
InputFile *createSharedFile(MemoryBufferRef MB, StringRef DefaultSoName);
363
364
3.19k
inline bool isBitcode(MemoryBufferRef MB) {
365
3.19k
  return identify_magic(MB.getBuffer()) == llvm::file_magic::bitcode;
366
3.19k
}
367
368
std::string replaceThinLTOSuffix(StringRef Path);
369
370
extern std::vector<BinaryFile *> BinaryFiles;
371
extern std::vector<BitcodeFile *> BitcodeFiles;
372
extern std::vector<LazyObjFile *> LazyObjFiles;
373
extern std::vector<InputFile *> ObjectFiles;
374
extern std::vector<InputFile *> SharedFiles;
375
376
} // namespace elf
377
} // namespace lld
378
379
#endif