Coverage Report

Created: 2018-01-17 21:32

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/lld/COFF/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_COFF_INPUT_FILES_H
11
#define LLD_COFF_INPUT_FILES_H
12
13
#include "Config.h"
14
#include "lld/Common/LLVM.h"
15
#include "llvm/ADT/ArrayRef.h"
16
#include "llvm/ADT/DenseSet.h"
17
#include "llvm/LTO/LTO.h"
18
#include "llvm/Object/Archive.h"
19
#include "llvm/Object/COFF.h"
20
#include "llvm/Support/StringSaver.h"
21
#include <memory>
22
#include <set>
23
#include <vector>
24
25
namespace llvm {
26
namespace pdb {
27
class DbiModuleDescriptorBuilder;
28
}
29
}
30
31
namespace lld {
32
namespace coff {
33
34
std::vector<MemoryBufferRef> getArchiveMembers(llvm::object::Archive *File);
35
36
using llvm::COFF::IMAGE_FILE_MACHINE_UNKNOWN;
37
using llvm::COFF::MachineTypes;
38
using llvm::object::Archive;
39
using llvm::object::COFFObjectFile;
40
using llvm::object::COFFSymbolRef;
41
using llvm::object::coff_import_header;
42
using llvm::object::coff_section;
43
44
class Chunk;
45
class Defined;
46
class DefinedImportData;
47
class DefinedImportThunk;
48
class Lazy;
49
class SectionChunk;
50
class Symbol;
51
class Undefined;
52
53
// The root class of input files.
54
class InputFile {
55
public:
56
  enum Kind { ArchiveKind, ObjectKind, ImportKind, BitcodeKind };
57
0
  Kind kind() const { return FileKind; }
58
0
  virtual ~InputFile() {}
59
60
  // Returns the filename.
61
0
  StringRef getName() const { return MB.getBufferIdentifier(); }
62
63
  // Reads a file (the constructor doesn't do that).
64
  virtual void parse() = 0;
65
66
  // Returns the CPU type this file was compiled to.
67
0
  virtual MachineTypes getMachineType() { return IMAGE_FILE_MACHINE_UNKNOWN; }
68
69
  MemoryBufferRef MB;
70
71
  // An archive file name if this file is created from an archive.
72
  StringRef ParentName;
73
74
  // Returns .drectve section contents if exist.
75
0
  StringRef getDirectives() { return StringRef(Directives).trim(); }
76
77
protected:
78
0
  InputFile(Kind K, MemoryBufferRef M) : MB(M), FileKind(K) {}
79
80
  std::string Directives;
81
82
private:
83
  const Kind FileKind;
84
};
85
86
// .lib or .a file.
87
class ArchiveFile : public InputFile {
88
public:
89
  explicit ArchiveFile(MemoryBufferRef M);
90
0
  static bool classof(const InputFile *F) { return F->kind() == ArchiveKind; }
91
  void parse() override;
92
93
  // Enqueues an archive member load for the given symbol. If we've already
94
  // enqueued a load for the same archive member, this function does nothing,
95
  // which ensures that we don't load the same member more than once.
96
  void addMember(const Archive::Symbol *Sym);
97
98
private:
99
  std::unique_ptr<Archive> File;
100
  std::string Filename;
101
  llvm::DenseSet<uint64_t> Seen;
102
};
103
104
// .obj or .o file. This may be a member of an archive file.
105
class ObjFile : public InputFile {
106
public:
107
0
  explicit ObjFile(MemoryBufferRef M) : InputFile(ObjectKind, M) {}
108
0
  static bool classof(const InputFile *F) { return F->kind() == ObjectKind; }
109
  void parse() override;
110
  MachineTypes getMachineType() override;
111
0
  ArrayRef<Chunk *> getChunks() { return Chunks; }
112
0
  ArrayRef<SectionChunk *> getDebugChunks() { return DebugChunks; }
113
0
  ArrayRef<Symbol *> getSymbols() { return Symbols; }
114
115
  // Returns a Symbol object for the SymbolIndex'th symbol in the
116
  // underlying object file.
117
0
  Symbol *getSymbol(uint32_t SymbolIndex) {
118
0
    return Symbols[SymbolIndex];
119
0
  }
120
121
  // Returns the underying COFF file.
122
0
  COFFObjectFile *getCOFFObj() { return COFFObj.get(); }
123
124
  static std::vector<ObjFile *> Instances;
125
126
  // True if this object file is compatible with SEH.
127
  // COFF-specific and x86-only.
128
  bool SEHCompat = false;
129
130
  // The symbol table indexes of the safe exception handlers.
131
  // COFF-specific and x86-only.
132
  ArrayRef<llvm::support::ulittle32_t> SXData;
133
134
  // Pointer to the PDB module descriptor builder. Various debug info records
135
  // will reference object files by "module index", which is here. Things like
136
  // source files and section contributions are also recorded here. Will be null
137
  // if we are not producing a PDB.
138
  llvm::pdb::DbiModuleDescriptorBuilder *ModuleDBI = nullptr;
139
140
private:
141
  void initializeChunks();
142
  void initializeSymbols();
143
144
  SectionChunk *
145
  readSection(uint32_t SectionNumber,
146
              const llvm::object::coff_aux_section_definition *Def);
147
148
  void readAssociativeDefinition(
149
      COFFSymbolRef COFFSym,
150
      const llvm::object::coff_aux_section_definition *Def);
151
152
  llvm::Optional<Symbol *>
153
  createDefined(COFFSymbolRef Sym,
154
                std::vector<const llvm::object::coff_aux_section_definition *>
155
                    &ComdatDefs);
156
  Symbol *createRegular(COFFSymbolRef Sym);
157
  Symbol *createUndefined(COFFSymbolRef Sym);
158
159
  std::unique_ptr<COFFObjectFile> COFFObj;
160
161
  // List of all chunks defined by this file. This includes both section
162
  // chunks and non-section chunks for common symbols.
163
  std::vector<Chunk *> Chunks;
164
165
  // CodeView debug info sections.
166
  std::vector<SectionChunk *> DebugChunks;
167
168
  // This vector contains the same chunks as Chunks, but they are
169
  // indexed such that you can get a SectionChunk by section index.
170
  // Nonexistent section indices are filled with null pointers.
171
  // (Because section number is 1-based, the first slot is always a
172
  // null pointer.)
173
  std::vector<SectionChunk *> SparseChunks;
174
175
  // This vector contains a list of all symbols defined or referenced by this
176
  // file. They are indexed such that you can get a Symbol by symbol
177
  // index. Nonexistent indices (which are occupied by auxiliary
178
  // symbols in the real symbol table) are filled with null pointers.
179
  std::vector<Symbol *> Symbols;
180
};
181
182
// This type represents import library members that contain DLL names
183
// and symbols exported from the DLLs. See Microsoft PE/COFF spec. 7
184
// for details about the format.
185
class ImportFile : public InputFile {
186
public:
187
  explicit ImportFile(MemoryBufferRef M)
188
0
      : InputFile(ImportKind, M), Live(!Config->DoGC) {}
189
190
0
  static bool classof(const InputFile *F) { return F->kind() == ImportKind; }
191
192
  static std::vector<ImportFile *> Instances;
193
194
  DefinedImportData *ImpSym = nullptr;
195
  DefinedImportThunk *ThunkSym = nullptr;
196
  std::string DLLName;
197
198
private:
199
  void parse() override;
200
201
public:
202
  StringRef ExternalName;
203
  const coff_import_header *Hdr;
204
  Chunk *Location = nullptr;
205
206
  // We want to eliminate dllimported symbols if no one actually refers them.
207
  // This "Live" bit is used to keep track of which import library members
208
  // are actually in use.
209
  //
210
  // If the Live bit is turned off by MarkLive, Writer will ignore dllimported
211
  // symbols provided by this import library member.
212
  bool Live;
213
};
214
215
// Used for LTO.
216
class BitcodeFile : public InputFile {
217
public:
218
0
  explicit BitcodeFile(MemoryBufferRef M) : InputFile(BitcodeKind, M) {}
219
0
  static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; }
220
0
  ArrayRef<Symbol *> getSymbols() { return SymbolBodies; }
221
  MachineTypes getMachineType() override;
222
  static std::vector<BitcodeFile *> Instances;
223
  std::unique_ptr<llvm::lto::InputFile> Obj;
224
225
private:
226
  void parse() override;
227
228
  std::vector<Symbol *> SymbolBodies;
229
};
230
} // namespace coff
231
232
std::string toString(const coff::InputFile *File);
233
} // namespace lld
234
235
#endif