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