1//===- InputFiles.cpp -----------------------------------------------------===//
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#include "InputFiles.h"
10#include "COFFLinkerContext.h"
11#include "Chunks.h"
12#include "Config.h"
13#include "DebugTypes.h"
14#include "Driver.h"
15#include "SymbolTable.h"
16#include "Symbols.h"
17#include "lld/Common/DWARF.h"
18#include "llvm-c/lto.h"
19#include "llvm/ADT/SmallVector.h"
20#include "llvm/ADT/Twine.h"
21#include "llvm/BinaryFormat/COFF.h"
22#include "llvm/DebugInfo/CodeView/DebugSubsectionRecord.h"
23#include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
24#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
25#include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
26#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
27#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
28#include "llvm/LTO/LTO.h"
29#include "llvm/Object/Binary.h"
30#include "llvm/Object/COFF.h"
31#include "llvm/Support/Casting.h"
32#include "llvm/Support/Endian.h"
33#include "llvm/Support/Error.h"
34#include "llvm/Support/ErrorOr.h"
35#include "llvm/Support/FileSystem.h"
36#include "llvm/Support/Path.h"
37#include "llvm/Target/TargetOptions.h"
38#include "llvm/TargetParser/Triple.h"
39#include <cstring>
40#include <optional>
41#include <system_error>
42#include <utility>
43
44using namespace llvm;
45using namespace llvm::COFF;
46using namespace llvm::codeview;
47using namespace llvm::object;
48using namespace llvm::support::endian;
49using namespace lld;
50using namespace lld::coff;
51
52using llvm::Triple;
53using llvm::support::ulittle32_t;
54
55// Returns the last element of a path, which is supposed to be a filename.
56static StringRef getBasename(StringRef path) {
57  return sys::path::filename(path, sys::path::Style::windows);
58}
59
60// Returns a string in the format of "foo.obj" or "foo.obj(bar.lib)".
61std::string lld::toString(const coff::InputFile *file) {
62  if (!file)
63    return "<internal>";
64  if (file->parentName.empty() || file->kind() == coff::InputFile::ImportKind)
65    return std::string(file->getName());
66
67  return (getBasename(file->parentName) + "(" + getBasename(file->getName()) +
68          ")")
69      .str();
70}
71
72/// Checks that Source is compatible with being a weak alias to Target.
73/// If Source is Undefined and has no weak alias set, makes it a weak
74/// alias to Target.
75static void checkAndSetWeakAlias(COFFLinkerContext &ctx, InputFile *f,
76                                 Symbol *source, Symbol *target) {
77  if (auto *u = dyn_cast<Undefined>(source)) {
78    if (u->weakAlias && u->weakAlias != target) {
79      // Weak aliases as produced by GCC are named in the form
80      // .weak.<weaksymbol>.<othersymbol>, where <othersymbol> is the name
81      // of another symbol emitted near the weak symbol.
82      // Just use the definition from the first object file that defined
83      // this weak symbol.
84      if (ctx.config.allowDuplicateWeak)
85        return;
86      ctx.symtab.reportDuplicate(source, f);
87    }
88    u->weakAlias = target;
89  }
90}
91
92static bool ignoredSymbolName(StringRef name) {
93  return name == "@feat.00" || name == "@comp.id";
94}
95
96ArchiveFile::ArchiveFile(COFFLinkerContext &ctx, MemoryBufferRef m)
97    : InputFile(ctx, ArchiveKind, m) {}
98
99void ArchiveFile::parse() {
100  // Parse a MemoryBufferRef as an archive file.
101  file = CHECK(Archive::create(mb), this);
102
103  // Read the symbol table to construct Lazy objects.
104  for (const Archive::Symbol &sym : file->symbols())
105    ctx.symtab.addLazyArchive(this, sym);
106}
107
108// Returns a buffer pointing to a member file containing a given symbol.
109void ArchiveFile::addMember(const Archive::Symbol &sym) {
110  const Archive::Child &c =
111      CHECK(sym.getMember(),
112            "could not get the member for symbol " + toCOFFString(ctx, sym));
113
114  // Return an empty buffer if we have already returned the same buffer.
115  if (!seen.insert(c.getChildOffset()).second)
116    return;
117
118  ctx.driver.enqueueArchiveMember(c, sym, getName());
119}
120
121std::vector<MemoryBufferRef> lld::coff::getArchiveMembers(Archive *file) {
122  std::vector<MemoryBufferRef> v;
123  Error err = Error::success();
124  for (const Archive::Child &c : file->children(err)) {
125    MemoryBufferRef mbref =
126        CHECK(c.getMemoryBufferRef(),
127              file->getFileName() +
128                  ": could not get the buffer for a child of the archive");
129    v.push_back(mbref);
130  }
131  if (err)
132    fatal(file->getFileName() +
133          ": Archive::children failed: " + toString(std::move(err)));
134  return v;
135}
136
137void ObjFile::parseLazy() {
138  // Native object file.
139  std::unique_ptr<Binary> coffObjPtr = CHECK(createBinary(mb), this);
140  COFFObjectFile *coffObj = cast<COFFObjectFile>(coffObjPtr.get());
141  uint32_t numSymbols = coffObj->getNumberOfSymbols();
142  for (uint32_t i = 0; i < numSymbols; ++i) {
143    COFFSymbolRef coffSym = check(coffObj->getSymbol(i));
144    if (coffSym.isUndefined() || !coffSym.isExternal() ||
145        coffSym.isWeakExternal())
146      continue;
147    StringRef name = check(coffObj->getSymbolName(coffSym));
148    if (coffSym.isAbsolute() && ignoredSymbolName(name))
149      continue;
150    ctx.symtab.addLazyObject(this, name);
151    i += coffSym.getNumberOfAuxSymbols();
152  }
153}
154
155void ObjFile::parse() {
156  // Parse a memory buffer as a COFF file.
157  std::unique_ptr<Binary> bin = CHECK(createBinary(mb), this);
158
159  if (auto *obj = dyn_cast<COFFObjectFile>(bin.get())) {
160    bin.release();
161    coffObj.reset(obj);
162  } else {
163    fatal(toString(this) + " is not a COFF file");
164  }
165
166  // Read section and symbol tables.
167  initializeChunks();
168  initializeSymbols();
169  initializeFlags();
170  initializeDependencies();
171}
172
173const coff_section *ObjFile::getSection(uint32_t i) {
174  auto sec = coffObj->getSection(i);
175  if (!sec)
176    fatal("getSection failed: #" + Twine(i) + ": " + toString(sec.takeError()));
177  return *sec;
178}
179
180// We set SectionChunk pointers in the SparseChunks vector to this value
181// temporarily to mark comdat sections as having an unknown resolution. As we
182// walk the object file's symbol table, once we visit either a leader symbol or
183// an associative section definition together with the parent comdat's leader,
184// we set the pointer to either nullptr (to mark the section as discarded) or a
185// valid SectionChunk for that section.
186static SectionChunk *const pendingComdat = reinterpret_cast<SectionChunk *>(1);
187
188void ObjFile::initializeChunks() {
189  uint32_t numSections = coffObj->getNumberOfSections();
190  sparseChunks.resize(numSections + 1);
191  for (uint32_t i = 1; i < numSections + 1; ++i) {
192    const coff_section *sec = getSection(i);
193    if (sec->Characteristics & IMAGE_SCN_LNK_COMDAT)
194      sparseChunks[i] = pendingComdat;
195    else
196      sparseChunks[i] = readSection(i, nullptr, "");
197  }
198}
199
200SectionChunk *ObjFile::readSection(uint32_t sectionNumber,
201                                   const coff_aux_section_definition *def,
202                                   StringRef leaderName) {
203  const coff_section *sec = getSection(sectionNumber);
204
205  StringRef name;
206  if (Expected<StringRef> e = coffObj->getSectionName(sec))
207    name = *e;
208  else
209    fatal("getSectionName failed: #" + Twine(sectionNumber) + ": " +
210          toString(e.takeError()));
211
212  if (name == ".drectve") {
213    ArrayRef<uint8_t> data;
214    cantFail(coffObj->getSectionContents(sec, data));
215    directives = StringRef((const char *)data.data(), data.size());
216    return nullptr;
217  }
218
219  if (name == ".llvm_addrsig") {
220    addrsigSec = sec;
221    return nullptr;
222  }
223
224  if (name == ".llvm.call-graph-profile") {
225    callgraphSec = sec;
226    return nullptr;
227  }
228
229  // Object files may have DWARF debug info or MS CodeView debug info
230  // (or both).
231  //
232  // DWARF sections don't need any special handling from the perspective
233  // of the linker; they are just a data section containing relocations.
234  // We can just link them to complete debug info.
235  //
236  // CodeView needs linker support. We need to interpret debug info,
237  // and then write it to a separate .pdb file.
238
239  // Ignore DWARF debug info unless requested to be included.
240  if (!ctx.config.includeDwarfChunks && name.starts_with(".debug_"))
241    return nullptr;
242
243  if (sec->Characteristics & llvm::COFF::IMAGE_SCN_LNK_REMOVE)
244    return nullptr;
245  auto *c = make<SectionChunk>(this, sec);
246  if (def)
247    c->checksum = def->CheckSum;
248
249  // CodeView sections are stored to a different vector because they are not
250  // linked in the regular manner.
251  if (c->isCodeView())
252    debugChunks.push_back(c);
253  else if (name == ".gfids$y")
254    guardFidChunks.push_back(c);
255  else if (name == ".giats$y")
256    guardIATChunks.push_back(c);
257  else if (name == ".gljmp$y")
258    guardLJmpChunks.push_back(c);
259  else if (name == ".gehcont$y")
260    guardEHContChunks.push_back(c);
261  else if (name == ".sxdata")
262    sxDataChunks.push_back(c);
263  else if (ctx.config.tailMerge && sec->NumberOfRelocations == 0 &&
264           name == ".rdata" && leaderName.starts_with("??_C@"))
265    // COFF sections that look like string literal sections (i.e. no
266    // relocations, in .rdata, leader symbol name matches the MSVC name mangling
267    // for string literals) are subject to string tail merging.
268    MergeChunk::addSection(ctx, c);
269  else if (name == ".rsrc" || name.starts_with(".rsrc$"))
270    resourceChunks.push_back(c);
271  else
272    chunks.push_back(c);
273
274  return c;
275}
276
277void ObjFile::includeResourceChunks() {
278  chunks.insert(chunks.end(), resourceChunks.begin(), resourceChunks.end());
279}
280
281void ObjFile::readAssociativeDefinition(
282    COFFSymbolRef sym, const coff_aux_section_definition *def) {
283  readAssociativeDefinition(sym, def, def->getNumber(sym.isBigObj()));
284}
285
286void ObjFile::readAssociativeDefinition(COFFSymbolRef sym,
287                                        const coff_aux_section_definition *def,
288                                        uint32_t parentIndex) {
289  SectionChunk *parent = sparseChunks[parentIndex];
290  int32_t sectionNumber = sym.getSectionNumber();
291
292  auto diag = [&]() {
293    StringRef name = check(coffObj->getSymbolName(sym));
294
295    StringRef parentName;
296    const coff_section *parentSec = getSection(parentIndex);
297    if (Expected<StringRef> e = coffObj->getSectionName(parentSec))
298      parentName = *e;
299    error(toString(this) + ": associative comdat " + name + " (sec " +
300          Twine(sectionNumber) + ") has invalid reference to section " +
301          parentName + " (sec " + Twine(parentIndex) + ")");
302  };
303
304  if (parent == pendingComdat) {
305    // This can happen if an associative comdat refers to another associative
306    // comdat that appears after it (invalid per COFF spec) or to a section
307    // without any symbols.
308    diag();
309    return;
310  }
311
312  // Check whether the parent is prevailing. If it is, so are we, and we read
313  // the section; otherwise mark it as discarded.
314  if (parent) {
315    SectionChunk *c = readSection(sectionNumber, def, "");
316    sparseChunks[sectionNumber] = c;
317    if (c) {
318      c->selection = IMAGE_COMDAT_SELECT_ASSOCIATIVE;
319      parent->addAssociative(c);
320    }
321  } else {
322    sparseChunks[sectionNumber] = nullptr;
323  }
324}
325
326void ObjFile::recordPrevailingSymbolForMingw(
327    COFFSymbolRef sym, DenseMap<StringRef, uint32_t> &prevailingSectionMap) {
328  // For comdat symbols in executable sections, where this is the copy
329  // of the section chunk we actually include instead of discarding it,
330  // add the symbol to a map to allow using it for implicitly
331  // associating .[px]data$<func> sections to it.
332  // Use the suffix from the .text$<func> instead of the leader symbol
333  // name, for cases where the names differ (i386 mangling/decorations,
334  // cases where the leader is a weak symbol named .weak.func.default*).
335  int32_t sectionNumber = sym.getSectionNumber();
336  SectionChunk *sc = sparseChunks[sectionNumber];
337  if (sc && sc->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE) {
338    StringRef name = sc->getSectionName().split('$').second;
339    prevailingSectionMap[name] = sectionNumber;
340  }
341}
342
343void ObjFile::maybeAssociateSEHForMingw(
344    COFFSymbolRef sym, const coff_aux_section_definition *def,
345    const DenseMap<StringRef, uint32_t> &prevailingSectionMap) {
346  StringRef name = check(coffObj->getSymbolName(sym));
347  if (name.consume_front(".pdata$") || name.consume_front(".xdata$") ||
348      name.consume_front(".eh_frame$")) {
349    // For MinGW, treat .[px]data$<func> and .eh_frame$<func> as implicitly
350    // associative to the symbol <func>.
351    auto parentSym = prevailingSectionMap.find(name);
352    if (parentSym != prevailingSectionMap.end())
353      readAssociativeDefinition(sym, def, parentSym->second);
354  }
355}
356
357Symbol *ObjFile::createRegular(COFFSymbolRef sym) {
358  SectionChunk *sc = sparseChunks[sym.getSectionNumber()];
359  if (sym.isExternal()) {
360    StringRef name = check(coffObj->getSymbolName(sym));
361    if (sc)
362      return ctx.symtab.addRegular(this, name, sym.getGeneric(), sc,
363                                   sym.getValue());
364    // For MinGW symbols named .weak.* that point to a discarded section,
365    // don't create an Undefined symbol. If nothing ever refers to the symbol,
366    // everything should be fine. If something actually refers to the symbol
367    // (e.g. the undefined weak alias), linking will fail due to undefined
368    // references at the end.
369    if (ctx.config.mingw && name.starts_with(".weak."))
370      return nullptr;
371    return ctx.symtab.addUndefined(name, this, false);
372  }
373  if (sc)
374    return make<DefinedRegular>(this, /*Name*/ "", /*IsCOMDAT*/ false,
375                                /*IsExternal*/ false, sym.getGeneric(), sc);
376  return nullptr;
377}
378
379void ObjFile::initializeSymbols() {
380  uint32_t numSymbols = coffObj->getNumberOfSymbols();
381  symbols.resize(numSymbols);
382
383  SmallVector<std::pair<Symbol *, uint32_t>, 8> weakAliases;
384  std::vector<uint32_t> pendingIndexes;
385  pendingIndexes.reserve(numSymbols);
386
387  DenseMap<StringRef, uint32_t> prevailingSectionMap;
388  std::vector<const coff_aux_section_definition *> comdatDefs(
389      coffObj->getNumberOfSections() + 1);
390
391  for (uint32_t i = 0; i < numSymbols; ++i) {
392    COFFSymbolRef coffSym = check(coffObj->getSymbol(i));
393    bool prevailingComdat;
394    if (coffSym.isUndefined()) {
395      symbols[i] = createUndefined(coffSym);
396    } else if (coffSym.isWeakExternal()) {
397      symbols[i] = createUndefined(coffSym);
398      uint32_t tagIndex = coffSym.getAux<coff_aux_weak_external>()->TagIndex;
399      weakAliases.emplace_back(symbols[i], tagIndex);
400    } else if (std::optional<Symbol *> optSym =
401                   createDefined(coffSym, comdatDefs, prevailingComdat)) {
402      symbols[i] = *optSym;
403      if (ctx.config.mingw && prevailingComdat)
404        recordPrevailingSymbolForMingw(coffSym, prevailingSectionMap);
405    } else {
406      // createDefined() returns std::nullopt if a symbol belongs to a section
407      // that was pending at the point when the symbol was read. This can happen
408      // in two cases:
409      // 1) section definition symbol for a comdat leader;
410      // 2) symbol belongs to a comdat section associated with another section.
411      // In both of these cases, we can expect the section to be resolved by
412      // the time we finish visiting the remaining symbols in the symbol
413      // table. So we postpone the handling of this symbol until that time.
414      pendingIndexes.push_back(i);
415    }
416    i += coffSym.getNumberOfAuxSymbols();
417  }
418
419  for (uint32_t i : pendingIndexes) {
420    COFFSymbolRef sym = check(coffObj->getSymbol(i));
421    if (const coff_aux_section_definition *def = sym.getSectionDefinition()) {
422      if (def->Selection == IMAGE_COMDAT_SELECT_ASSOCIATIVE)
423        readAssociativeDefinition(sym, def);
424      else if (ctx.config.mingw)
425        maybeAssociateSEHForMingw(sym, def, prevailingSectionMap);
426    }
427    if (sparseChunks[sym.getSectionNumber()] == pendingComdat) {
428      StringRef name = check(coffObj->getSymbolName(sym));
429      log("comdat section " + name +
430          " without leader and unassociated, discarding");
431      continue;
432    }
433    symbols[i] = createRegular(sym);
434  }
435
436  for (auto &kv : weakAliases) {
437    Symbol *sym = kv.first;
438    uint32_t idx = kv.second;
439    checkAndSetWeakAlias(ctx, this, sym, symbols[idx]);
440  }
441
442  // Free the memory used by sparseChunks now that symbol loading is finished.
443  decltype(sparseChunks)().swap(sparseChunks);
444}
445
446Symbol *ObjFile::createUndefined(COFFSymbolRef sym) {
447  StringRef name = check(coffObj->getSymbolName(sym));
448  return ctx.symtab.addUndefined(name, this, sym.isWeakExternal());
449}
450
451static const coff_aux_section_definition *findSectionDef(COFFObjectFile *obj,
452                                                         int32_t section) {
453  uint32_t numSymbols = obj->getNumberOfSymbols();
454  for (uint32_t i = 0; i < numSymbols; ++i) {
455    COFFSymbolRef sym = check(obj->getSymbol(i));
456    if (sym.getSectionNumber() != section)
457      continue;
458    if (const coff_aux_section_definition *def = sym.getSectionDefinition())
459      return def;
460  }
461  return nullptr;
462}
463
464void ObjFile::handleComdatSelection(
465    COFFSymbolRef sym, COMDATType &selection, bool &prevailing,
466    DefinedRegular *leader,
467    const llvm::object::coff_aux_section_definition *def) {
468  if (prevailing)
469    return;
470  // There's already an existing comdat for this symbol: `Leader`.
471  // Use the comdats's selection field to determine if the new
472  // symbol in `Sym` should be discarded, produce a duplicate symbol
473  // error, etc.
474
475  SectionChunk *leaderChunk = leader->getChunk();
476  COMDATType leaderSelection = leaderChunk->selection;
477
478  assert(leader->data && "Comdat leader without SectionChunk?");
479  if (isa<BitcodeFile>(leader->file)) {
480    // If the leader is only a LTO symbol, we don't know e.g. its final size
481    // yet, so we can't do the full strict comdat selection checking yet.
482    selection = leaderSelection = IMAGE_COMDAT_SELECT_ANY;
483  }
484
485  if ((selection == IMAGE_COMDAT_SELECT_ANY &&
486       leaderSelection == IMAGE_COMDAT_SELECT_LARGEST) ||
487      (selection == IMAGE_COMDAT_SELECT_LARGEST &&
488       leaderSelection == IMAGE_COMDAT_SELECT_ANY)) {
489    // cl.exe picks "any" for vftables when building with /GR- and
490    // "largest" when building with /GR. To be able to link object files
491    // compiled with each flag, "any" and "largest" are merged as "largest".
492    leaderSelection = selection = IMAGE_COMDAT_SELECT_LARGEST;
493  }
494
495  // GCCs __declspec(selectany) doesn't actually pick "any" but "same size as".
496  // Clang on the other hand picks "any". To be able to link two object files
497  // with a __declspec(selectany) declaration, one compiled with gcc and the
498  // other with clang, we merge them as proper "same size as"
499  if (ctx.config.mingw && ((selection == IMAGE_COMDAT_SELECT_ANY &&
500                            leaderSelection == IMAGE_COMDAT_SELECT_SAME_SIZE) ||
501                           (selection == IMAGE_COMDAT_SELECT_SAME_SIZE &&
502                            leaderSelection == IMAGE_COMDAT_SELECT_ANY))) {
503    leaderSelection = selection = IMAGE_COMDAT_SELECT_SAME_SIZE;
504  }
505
506  // Other than that, comdat selections must match.  This is a bit more
507  // strict than link.exe which allows merging "any" and "largest" if "any"
508  // is the first symbol the linker sees, and it allows merging "largest"
509  // with everything (!) if "largest" is the first symbol the linker sees.
510  // Making this symmetric independent of which selection is seen first
511  // seems better though.
512  // (This behavior matches ModuleLinker::getComdatResult().)
513  if (selection != leaderSelection) {
514    log(("conflicting comdat type for " + toString(ctx, *leader) + ": " +
515         Twine((int)leaderSelection) + " in " + toString(leader->getFile()) +
516         " and " + Twine((int)selection) + " in " + toString(this))
517            .str());
518    ctx.symtab.reportDuplicate(leader, this);
519    return;
520  }
521
522  switch (selection) {
523  case IMAGE_COMDAT_SELECT_NODUPLICATES:
524    ctx.symtab.reportDuplicate(leader, this);
525    break;
526
527  case IMAGE_COMDAT_SELECT_ANY:
528    // Nothing to do.
529    break;
530
531  case IMAGE_COMDAT_SELECT_SAME_SIZE:
532    if (leaderChunk->getSize() != getSection(sym)->SizeOfRawData) {
533      if (!ctx.config.mingw) {
534        ctx.symtab.reportDuplicate(leader, this);
535      } else {
536        const coff_aux_section_definition *leaderDef = nullptr;
537        if (leaderChunk->file)
538          leaderDef = findSectionDef(leaderChunk->file->getCOFFObj(),
539                                     leaderChunk->getSectionNumber());
540        if (!leaderDef || leaderDef->Length != def->Length)
541          ctx.symtab.reportDuplicate(leader, this);
542      }
543    }
544    break;
545
546  case IMAGE_COMDAT_SELECT_EXACT_MATCH: {
547    SectionChunk newChunk(this, getSection(sym));
548    // link.exe only compares section contents here and doesn't complain
549    // if the two comdat sections have e.g. different alignment.
550    // Match that.
551    if (leaderChunk->getContents() != newChunk.getContents())
552      ctx.symtab.reportDuplicate(leader, this, &newChunk, sym.getValue());
553    break;
554  }
555
556  case IMAGE_COMDAT_SELECT_ASSOCIATIVE:
557    // createDefined() is never called for IMAGE_COMDAT_SELECT_ASSOCIATIVE.
558    // (This means lld-link doesn't produce duplicate symbol errors for
559    // associative comdats while link.exe does, but associate comdats
560    // are never extern in practice.)
561    llvm_unreachable("createDefined not called for associative comdats");
562
563  case IMAGE_COMDAT_SELECT_LARGEST:
564    if (leaderChunk->getSize() < getSection(sym)->SizeOfRawData) {
565      // Replace the existing comdat symbol with the new one.
566      StringRef name = check(coffObj->getSymbolName(sym));
567      // FIXME: This is incorrect: With /opt:noref, the previous sections
568      // make it into the final executable as well. Correct handling would
569      // be to undo reading of the whole old section that's being replaced,
570      // or doing one pass that determines what the final largest comdat
571      // is for all IMAGE_COMDAT_SELECT_LARGEST comdats and then reading
572      // only the largest one.
573      replaceSymbol<DefinedRegular>(leader, this, name, /*IsCOMDAT*/ true,
574                                    /*IsExternal*/ true, sym.getGeneric(),
575                                    nullptr);
576      prevailing = true;
577    }
578    break;
579
580  case IMAGE_COMDAT_SELECT_NEWEST:
581    llvm_unreachable("should have been rejected earlier");
582  }
583}
584
585std::optional<Symbol *> ObjFile::createDefined(
586    COFFSymbolRef sym,
587    std::vector<const coff_aux_section_definition *> &comdatDefs,
588    bool &prevailing) {
589  prevailing = false;
590  auto getName = [&]() { return check(coffObj->getSymbolName(sym)); };
591
592  if (sym.isCommon()) {
593    auto *c = make<CommonChunk>(sym);
594    chunks.push_back(c);
595    return ctx.symtab.addCommon(this, getName(), sym.getValue(),
596                                sym.getGeneric(), c);
597  }
598
599  if (sym.isAbsolute()) {
600    StringRef name = getName();
601
602    if (name == "@feat.00")
603      feat00Flags = sym.getValue();
604    // Skip special symbols.
605    if (ignoredSymbolName(name))
606      return nullptr;
607
608    if (sym.isExternal())
609      return ctx.symtab.addAbsolute(name, sym);
610    return make<DefinedAbsolute>(ctx, name, sym);
611  }
612
613  int32_t sectionNumber = sym.getSectionNumber();
614  if (sectionNumber == llvm::COFF::IMAGE_SYM_DEBUG)
615    return nullptr;
616
617  if (llvm::COFF::isReservedSectionNumber(sectionNumber))
618    fatal(toString(this) + ": " + getName() +
619          " should not refer to special section " + Twine(sectionNumber));
620
621  if ((uint32_t)sectionNumber >= sparseChunks.size())
622    fatal(toString(this) + ": " + getName() +
623          " should not refer to non-existent section " + Twine(sectionNumber));
624
625  // Comdat handling.
626  // A comdat symbol consists of two symbol table entries.
627  // The first symbol entry has the name of the section (e.g. .text), fixed
628  // values for the other fields, and one auxiliary record.
629  // The second symbol entry has the name of the comdat symbol, called the
630  // "comdat leader".
631  // When this function is called for the first symbol entry of a comdat,
632  // it sets comdatDefs and returns std::nullopt, and when it's called for the
633  // second symbol entry it reads comdatDefs and then sets it back to nullptr.
634
635  // Handle comdat leader.
636  if (const coff_aux_section_definition *def = comdatDefs[sectionNumber]) {
637    comdatDefs[sectionNumber] = nullptr;
638    DefinedRegular *leader;
639
640    if (sym.isExternal()) {
641      std::tie(leader, prevailing) =
642          ctx.symtab.addComdat(this, getName(), sym.getGeneric());
643    } else {
644      leader = make<DefinedRegular>(this, /*Name*/ "", /*IsCOMDAT*/ false,
645                                    /*IsExternal*/ false, sym.getGeneric());
646      prevailing = true;
647    }
648
649    if (def->Selection < (int)IMAGE_COMDAT_SELECT_NODUPLICATES ||
650        // Intentionally ends at IMAGE_COMDAT_SELECT_LARGEST: link.exe
651        // doesn't understand IMAGE_COMDAT_SELECT_NEWEST either.
652        def->Selection > (int)IMAGE_COMDAT_SELECT_LARGEST) {
653      fatal("unknown comdat type " + std::to_string((int)def->Selection) +
654            " for " + getName() + " in " + toString(this));
655    }
656    COMDATType selection = (COMDATType)def->Selection;
657
658    if (leader->isCOMDAT)
659      handleComdatSelection(sym, selection, prevailing, leader, def);
660
661    if (prevailing) {
662      SectionChunk *c = readSection(sectionNumber, def, getName());
663      sparseChunks[sectionNumber] = c;
664      if (!c)
665        return nullptr;
666      c->sym = cast<DefinedRegular>(leader);
667      c->selection = selection;
668      cast<DefinedRegular>(leader)->data = &c->repl;
669    } else {
670      sparseChunks[sectionNumber] = nullptr;
671    }
672    return leader;
673  }
674
675  // Prepare to handle the comdat leader symbol by setting the section's
676  // ComdatDefs pointer if we encounter a non-associative comdat.
677  if (sparseChunks[sectionNumber] == pendingComdat) {
678    if (const coff_aux_section_definition *def = sym.getSectionDefinition()) {
679      if (def->Selection != IMAGE_COMDAT_SELECT_ASSOCIATIVE)
680        comdatDefs[sectionNumber] = def;
681    }
682    return std::nullopt;
683  }
684
685  return createRegular(sym);
686}
687
688MachineTypes ObjFile::getMachineType() {
689  if (coffObj)
690    return static_cast<MachineTypes>(coffObj->getMachine());
691  return IMAGE_FILE_MACHINE_UNKNOWN;
692}
693
694ArrayRef<uint8_t> ObjFile::getDebugSection(StringRef secName) {
695  if (SectionChunk *sec = SectionChunk::findByName(debugChunks, secName))
696    return sec->consumeDebugMagic();
697  return {};
698}
699
700// OBJ files systematically store critical information in a .debug$S stream,
701// even if the TU was compiled with no debug info. At least two records are
702// always there. S_OBJNAME stores a 32-bit signature, which is loaded into the
703// PCHSignature member. S_COMPILE3 stores compile-time cmd-line flags. This is
704// currently used to initialize the hotPatchable member.
705void ObjFile::initializeFlags() {
706  ArrayRef<uint8_t> data = getDebugSection(".debug$S");
707  if (data.empty())
708    return;
709
710  DebugSubsectionArray subsections;
711
712  BinaryStreamReader reader(data, llvm::endianness::little);
713  ExitOnError exitOnErr;
714  exitOnErr(reader.readArray(subsections, data.size()));
715
716  for (const DebugSubsectionRecord &ss : subsections) {
717    if (ss.kind() != DebugSubsectionKind::Symbols)
718      continue;
719
720    unsigned offset = 0;
721
722    // Only parse the first two records. We are only looking for S_OBJNAME
723    // and S_COMPILE3, and they usually appear at the beginning of the
724    // stream.
725    for (unsigned i = 0; i < 2; ++i) {
726      Expected<CVSymbol> sym = readSymbolFromStream(ss.getRecordData(), offset);
727      if (!sym) {
728        consumeError(sym.takeError());
729        return;
730      }
731      if (sym->kind() == SymbolKind::S_COMPILE3) {
732        auto cs =
733            cantFail(SymbolDeserializer::deserializeAs<Compile3Sym>(sym.get()));
734        hotPatchable =
735            (cs.Flags & CompileSym3Flags::HotPatch) != CompileSym3Flags::None;
736      }
737      if (sym->kind() == SymbolKind::S_OBJNAME) {
738        auto objName = cantFail(SymbolDeserializer::deserializeAs<ObjNameSym>(
739            sym.get()));
740        if (objName.Signature)
741          pchSignature = objName.Signature;
742      }
743      offset += sym->length();
744    }
745  }
746}
747
748// Depending on the compilation flags, OBJs can refer to external files,
749// necessary to merge this OBJ into the final PDB. We currently support two
750// types of external files: Precomp/PCH OBJs, when compiling with /Yc and /Yu.
751// And PDB type servers, when compiling with /Zi. This function extracts these
752// dependencies and makes them available as a TpiSource interface (see
753// DebugTypes.h). Both cases only happen with cl.exe: clang-cl produces regular
754// output even with /Yc and /Yu and with /Zi.
755void ObjFile::initializeDependencies() {
756  if (!ctx.config.debug)
757    return;
758
759  bool isPCH = false;
760
761  ArrayRef<uint8_t> data = getDebugSection(".debug$P");
762  if (!data.empty())
763    isPCH = true;
764  else
765    data = getDebugSection(".debug$T");
766
767  // symbols but no types, make a plain, empty TpiSource anyway, because it
768  // simplifies adding the symbols later.
769  if (data.empty()) {
770    if (!debugChunks.empty())
771      debugTypesObj = makeTpiSource(ctx, this);
772    return;
773  }
774
775  // Get the first type record. It will indicate if this object uses a type
776  // server (/Zi) or a PCH file (/Yu).
777  CVTypeArray types;
778  BinaryStreamReader reader(data, llvm::endianness::little);
779  cantFail(reader.readArray(types, reader.getLength()));
780  CVTypeArray::Iterator firstType = types.begin();
781  if (firstType == types.end())
782    return;
783
784  // Remember the .debug$T or .debug$P section.
785  debugTypes = data;
786
787  // This object file is a PCH file that others will depend on.
788  if (isPCH) {
789    debugTypesObj = makePrecompSource(ctx, this);
790    return;
791  }
792
793  // This object file was compiled with /Zi. Enqueue the PDB dependency.
794  if (firstType->kind() == LF_TYPESERVER2) {
795    TypeServer2Record ts = cantFail(
796        TypeDeserializer::deserializeAs<TypeServer2Record>(firstType->data()));
797    debugTypesObj = makeUseTypeServerSource(ctx, this, ts);
798    enqueuePdbFile(ts.getName(), this);
799    return;
800  }
801
802  // This object was compiled with /Yu. It uses types from another object file
803  // with a matching signature.
804  if (firstType->kind() == LF_PRECOMP) {
805    PrecompRecord precomp = cantFail(
806        TypeDeserializer::deserializeAs<PrecompRecord>(firstType->data()));
807    // We're better off trusting the LF_PRECOMP signature. In some cases the
808    // S_OBJNAME record doesn't contain a valid PCH signature.
809    if (precomp.Signature)
810      pchSignature = precomp.Signature;
811    debugTypesObj = makeUsePrecompSource(ctx, this, precomp);
812    // Drop the LF_PRECOMP record from the input stream.
813    debugTypes = debugTypes.drop_front(firstType->RecordData.size());
814    return;
815  }
816
817  // This is a plain old object file.
818  debugTypesObj = makeTpiSource(ctx, this);
819}
820
821// Make a PDB path assuming the PDB is in the same folder as the OBJ
822static std::string getPdbBaseName(ObjFile *file, StringRef tSPath) {
823  StringRef localPath =
824      !file->parentName.empty() ? file->parentName : file->getName();
825  SmallString<128> path = sys::path::parent_path(localPath);
826
827  // Currently, type server PDBs are only created by MSVC cl, which only runs
828  // on Windows, so we can assume type server paths are Windows style.
829  sys::path::append(path,
830                    sys::path::filename(tSPath, sys::path::Style::windows));
831  return std::string(path);
832}
833
834// The casing of the PDB path stamped in the OBJ can differ from the actual path
835// on disk. With this, we ensure to always use lowercase as a key for the
836// pdbInputFileInstances map, at least on Windows.
837static std::string normalizePdbPath(StringRef path) {
838#if defined(_WIN32)
839  return path.lower();
840#else // LINUX
841  return std::string(path);
842#endif
843}
844
845// If existing, return the actual PDB path on disk.
846static std::optional<std::string> findPdbPath(StringRef pdbPath,
847                                              ObjFile *dependentFile) {
848  // Ensure the file exists before anything else. In some cases, if the path
849  // points to a removable device, Driver::enqueuePath() would fail with an
850  // error (EAGAIN, "resource unavailable try again") which we want to skip
851  // silently.
852  if (llvm::sys::fs::exists(pdbPath))
853    return normalizePdbPath(pdbPath);
854  std::string ret = getPdbBaseName(dependentFile, pdbPath);
855  if (llvm::sys::fs::exists(ret))
856    return normalizePdbPath(ret);
857  return std::nullopt;
858}
859
860PDBInputFile::PDBInputFile(COFFLinkerContext &ctx, MemoryBufferRef m)
861    : InputFile(ctx, PDBKind, m) {}
862
863PDBInputFile::~PDBInputFile() = default;
864
865PDBInputFile *PDBInputFile::findFromRecordPath(const COFFLinkerContext &ctx,
866                                               StringRef path,
867                                               ObjFile *fromFile) {
868  auto p = findPdbPath(path.str(), fromFile);
869  if (!p)
870    return nullptr;
871  auto it = ctx.pdbInputFileInstances.find(*p);
872  if (it != ctx.pdbInputFileInstances.end())
873    return it->second;
874  return nullptr;
875}
876
877void PDBInputFile::parse() {
878  ctx.pdbInputFileInstances[mb.getBufferIdentifier().str()] = this;
879
880  std::unique_ptr<pdb::IPDBSession> thisSession;
881  Error E = pdb::NativeSession::createFromPdb(
882      MemoryBuffer::getMemBuffer(mb, false), thisSession);
883  if (E) {
884    loadErrorStr.emplace(toString(std::move(E)));
885    return; // fail silently at this point - the error will be handled later,
886            // when merging the debug type stream
887  }
888
889  session.reset(static_cast<pdb::NativeSession *>(thisSession.release()));
890
891  pdb::PDBFile &pdbFile = session->getPDBFile();
892  auto expectedInfo = pdbFile.getPDBInfoStream();
893  // All PDB Files should have an Info stream.
894  if (!expectedInfo) {
895    loadErrorStr.emplace(toString(expectedInfo.takeError()));
896    return;
897  }
898  debugTypesObj = makeTypeServerSource(ctx, this);
899}
900
901// Used only for DWARF debug info, which is not common (except in MinGW
902// environments). This returns an optional pair of file name and line
903// number for where the variable was defined.
904std::optional<std::pair<StringRef, uint32_t>>
905ObjFile::getVariableLocation(StringRef var) {
906  if (!dwarf) {
907    dwarf = make<DWARFCache>(DWARFContext::create(*getCOFFObj()));
908    if (!dwarf)
909      return std::nullopt;
910  }
911  if (ctx.config.machine == I386)
912    var.consume_front("_");
913  std::optional<std::pair<std::string, unsigned>> ret =
914      dwarf->getVariableLoc(var);
915  if (!ret)
916    return std::nullopt;
917  return std::make_pair(saver().save(ret->first), ret->second);
918}
919
920// Used only for DWARF debug info, which is not common (except in MinGW
921// environments).
922std::optional<DILineInfo> ObjFile::getDILineInfo(uint32_t offset,
923                                                 uint32_t sectionIndex) {
924  if (!dwarf) {
925    dwarf = make<DWARFCache>(DWARFContext::create(*getCOFFObj()));
926    if (!dwarf)
927      return std::nullopt;
928  }
929
930  return dwarf->getDILineInfo(offset, sectionIndex);
931}
932
933void ObjFile::enqueuePdbFile(StringRef path, ObjFile *fromFile) {
934  auto p = findPdbPath(path.str(), fromFile);
935  if (!p)
936    return;
937  auto it = ctx.pdbInputFileInstances.emplace(*p, nullptr);
938  if (!it.second)
939    return; // already scheduled for load
940  ctx.driver.enqueuePDB(*p);
941}
942
943ImportFile::ImportFile(COFFLinkerContext &ctx, MemoryBufferRef m)
944    : InputFile(ctx, ImportKind, m), live(!ctx.config.doGC), thunkLive(live) {}
945
946void ImportFile::parse() {
947  const char *buf = mb.getBufferStart();
948  const auto *hdr = reinterpret_cast<const coff_import_header *>(buf);
949
950  // Check if the total size is valid.
951  if (mb.getBufferSize() != sizeof(*hdr) + hdr->SizeOfData)
952    fatal("broken import library");
953
954  // Read names and create an __imp_ symbol.
955  StringRef name = saver().save(StringRef(buf + sizeof(*hdr)));
956  StringRef impName = saver().save("__imp_" + name);
957  const char *nameStart = buf + sizeof(coff_import_header) + name.size() + 1;
958  dllName = std::string(StringRef(nameStart));
959  StringRef extName;
960  switch (hdr->getNameType()) {
961  case IMPORT_ORDINAL:
962    extName = "";
963    break;
964  case IMPORT_NAME:
965    extName = name;
966    break;
967  case IMPORT_NAME_NOPREFIX:
968    extName = ltrim1(name, "?@_");
969    break;
970  case IMPORT_NAME_UNDECORATE:
971    extName = ltrim1(name, "?@_");
972    extName = extName.substr(0, extName.find('@'));
973    break;
974  }
975
976  this->hdr = hdr;
977  externalName = extName;
978
979  impSym = ctx.symtab.addImportData(impName, this);
980  // If this was a duplicate, we logged an error but may continue;
981  // in this case, impSym is nullptr.
982  if (!impSym)
983    return;
984
985  if (hdr->getType() == llvm::COFF::IMPORT_CONST)
986    static_cast<void>(ctx.symtab.addImportData(name, this));
987
988  // If type is function, we need to create a thunk which jump to an
989  // address pointed by the __imp_ symbol. (This allows you to call
990  // DLL functions just like regular non-DLL functions.)
991  if (hdr->getType() == llvm::COFF::IMPORT_CODE)
992    thunkSym = ctx.symtab.addImportThunk(
993        name, cast_or_null<DefinedImportData>(impSym), hdr->Machine);
994}
995
996BitcodeFile::BitcodeFile(COFFLinkerContext &ctx, MemoryBufferRef mb,
997                         StringRef archiveName, uint64_t offsetInArchive,
998                         bool lazy)
999    : InputFile(ctx, BitcodeKind, mb, lazy) {
1000  std::string path = mb.getBufferIdentifier().str();
1001  if (ctx.config.thinLTOIndexOnly)
1002    path = replaceThinLTOSuffix(mb.getBufferIdentifier(),
1003                                ctx.config.thinLTOObjectSuffixReplace.first,
1004                                ctx.config.thinLTOObjectSuffixReplace.second);
1005
1006  // ThinLTO assumes that all MemoryBufferRefs given to it have a unique
1007  // name. If two archives define two members with the same name, this
1008  // causes a collision which result in only one of the objects being taken
1009  // into consideration at LTO time (which very likely causes undefined
1010  // symbols later in the link stage). So we append file offset to make
1011  // filename unique.
1012  MemoryBufferRef mbref(mb.getBuffer(),
1013                        saver().save(archiveName.empty()
1014                                         ? path
1015                                         : archiveName +
1016                                               sys::path::filename(path) +
1017                                               utostr(offsetInArchive)));
1018
1019  obj = check(lto::InputFile::create(mbref));
1020}
1021
1022BitcodeFile::~BitcodeFile() = default;
1023
1024void BitcodeFile::parse() {
1025  llvm::StringSaver &saver = lld::saver();
1026
1027  std::vector<std::pair<Symbol *, bool>> comdat(obj->getComdatTable().size());
1028  for (size_t i = 0; i != obj->getComdatTable().size(); ++i)
1029    // FIXME: Check nodeduplicate
1030    comdat[i] =
1031        ctx.symtab.addComdat(this, saver.save(obj->getComdatTable()[i].first));
1032  for (const lto::InputFile::Symbol &objSym : obj->symbols()) {
1033    StringRef symName = saver.save(objSym.getName());
1034    int comdatIndex = objSym.getComdatIndex();
1035    Symbol *sym;
1036    SectionChunk *fakeSC = nullptr;
1037    if (objSym.isExecutable())
1038      fakeSC = &ctx.ltoTextSectionChunk.chunk;
1039    else
1040      fakeSC = &ctx.ltoDataSectionChunk.chunk;
1041    if (objSym.isUndefined()) {
1042      sym = ctx.symtab.addUndefined(symName, this, false);
1043      if (objSym.isWeak())
1044        sym->deferUndefined = true;
1045      // If one LTO object file references (i.e. has an undefined reference to)
1046      // a symbol with an __imp_ prefix, the LTO compilation itself sees it
1047      // as unprefixed but with a dllimport attribute instead, and doesn't
1048      // understand the relation to a concrete IR symbol with the __imp_ prefix.
1049      //
1050      // For such cases, mark the symbol as used in a regular object (i.e. the
1051      // symbol must be retained) so that the linker can associate the
1052      // references in the end. If the symbol is defined in an import library
1053      // or in a regular object file, this has no effect, but if it is defined
1054      // in another LTO object file, this makes sure it is kept, to fulfill
1055      // the reference when linking the output of the LTO compilation.
1056      if (symName.starts_with("__imp_"))
1057        sym->isUsedInRegularObj = true;
1058    } else if (objSym.isCommon()) {
1059      sym = ctx.symtab.addCommon(this, symName, objSym.getCommonSize());
1060    } else if (objSym.isWeak() && objSym.isIndirect()) {
1061      // Weak external.
1062      sym = ctx.symtab.addUndefined(symName, this, true);
1063      std::string fallback = std::string(objSym.getCOFFWeakExternalFallback());
1064      Symbol *alias = ctx.symtab.addUndefined(saver.save(fallback));
1065      checkAndSetWeakAlias(ctx, this, sym, alias);
1066    } else if (comdatIndex != -1) {
1067      if (symName == obj->getComdatTable()[comdatIndex].first) {
1068        sym = comdat[comdatIndex].first;
1069        if (cast<DefinedRegular>(sym)->data == nullptr)
1070          cast<DefinedRegular>(sym)->data = &fakeSC->repl;
1071      } else if (comdat[comdatIndex].second) {
1072        sym = ctx.symtab.addRegular(this, symName, nullptr, fakeSC);
1073      } else {
1074        sym = ctx.symtab.addUndefined(symName, this, false);
1075      }
1076    } else {
1077      sym = ctx.symtab.addRegular(this, symName, nullptr, fakeSC, 0,
1078                                  objSym.isWeak());
1079    }
1080    symbols.push_back(sym);
1081    if (objSym.isUsed())
1082      ctx.config.gcroot.push_back(sym);
1083  }
1084  directives = saver.save(obj->getCOFFLinkerOpts());
1085}
1086
1087void BitcodeFile::parseLazy() {
1088  for (const lto::InputFile::Symbol &sym : obj->symbols())
1089    if (!sym.isUndefined())
1090      ctx.symtab.addLazyObject(this, sym.getName());
1091}
1092
1093MachineTypes BitcodeFile::getMachineType() {
1094  switch (Triple(obj->getTargetTriple()).getArch()) {
1095  case Triple::x86_64:
1096    return AMD64;
1097  case Triple::x86:
1098    return I386;
1099  case Triple::arm:
1100  case Triple::thumb:
1101    return ARMNT;
1102  case Triple::aarch64:
1103    return ARM64;
1104  default:
1105    return IMAGE_FILE_MACHINE_UNKNOWN;
1106  }
1107}
1108
1109std::string lld::coff::replaceThinLTOSuffix(StringRef path, StringRef suffix,
1110                                            StringRef repl) {
1111  if (path.consume_back(suffix))
1112    return (path + repl).str();
1113  return std::string(path);
1114}
1115
1116static bool isRVACode(COFFObjectFile *coffObj, uint64_t rva, InputFile *file) {
1117  for (size_t i = 1, e = coffObj->getNumberOfSections(); i <= e; i++) {
1118    const coff_section *sec = CHECK(coffObj->getSection(i), file);
1119    if (rva >= sec->VirtualAddress &&
1120        rva <= sec->VirtualAddress + sec->VirtualSize) {
1121      return (sec->Characteristics & COFF::IMAGE_SCN_CNT_CODE) != 0;
1122    }
1123  }
1124  return false;
1125}
1126
1127void DLLFile::parse() {
1128  // Parse a memory buffer as a PE-COFF executable.
1129  std::unique_ptr<Binary> bin = CHECK(createBinary(mb), this);
1130
1131  if (auto *obj = dyn_cast<COFFObjectFile>(bin.get())) {
1132    bin.release();
1133    coffObj.reset(obj);
1134  } else {
1135    error(toString(this) + " is not a COFF file");
1136    return;
1137  }
1138
1139  if (!coffObj->getPE32Header() && !coffObj->getPE32PlusHeader()) {
1140    error(toString(this) + " is not a PE-COFF executable");
1141    return;
1142  }
1143
1144  for (const auto &exp : coffObj->export_directories()) {
1145    StringRef dllName, symbolName;
1146    uint32_t exportRVA;
1147    checkError(exp.getDllName(dllName));
1148    checkError(exp.getSymbolName(symbolName));
1149    checkError(exp.getExportRVA(exportRVA));
1150
1151    if (symbolName.empty())
1152      continue;
1153
1154    bool code = isRVACode(coffObj.get(), exportRVA, this);
1155
1156    Symbol *s = make<Symbol>();
1157    s->dllName = dllName;
1158    s->symbolName = symbolName;
1159    s->importType = code ? ImportType::IMPORT_CODE : ImportType::IMPORT_DATA;
1160    s->nameType = ImportNameType::IMPORT_NAME;
1161
1162    if (coffObj->getMachine() == I386) {
1163      s->symbolName = symbolName = saver().save("_" + symbolName);
1164      s->nameType = ImportNameType::IMPORT_NAME_NOPREFIX;
1165    }
1166
1167    StringRef impName = saver().save("__imp_" + symbolName);
1168    ctx.symtab.addLazyDLLSymbol(this, s, impName);
1169    if (code)
1170      ctx.symtab.addLazyDLLSymbol(this, s, symbolName);
1171  }
1172}
1173
1174MachineTypes DLLFile::getMachineType() {
1175  if (coffObj)
1176    return static_cast<MachineTypes>(coffObj->getMachine());
1177  return IMAGE_FILE_MACHINE_UNKNOWN;
1178}
1179
1180void DLLFile::makeImport(DLLFile::Symbol *s) {
1181  if (!seen.insert(s->symbolName).second)
1182    return;
1183
1184  size_t impSize = s->dllName.size() + s->symbolName.size() + 2; // +2 for NULs
1185  size_t size = sizeof(coff_import_header) + impSize;
1186  char *buf = bAlloc().Allocate<char>(size);
1187  memset(buf, 0, size);
1188  char *p = buf;
1189  auto *imp = reinterpret_cast<coff_import_header *>(p);
1190  p += sizeof(*imp);
1191  imp->Sig2 = 0xFFFF;
1192  imp->Machine = coffObj->getMachine();
1193  imp->SizeOfData = impSize;
1194  imp->OrdinalHint = 0; // Only linking by name
1195  imp->TypeInfo = (s->nameType << 2) | s->importType;
1196
1197  // Write symbol name and DLL name.
1198  memcpy(p, s->symbolName.data(), s->symbolName.size());
1199  p += s->symbolName.size() + 1;
1200  memcpy(p, s->dllName.data(), s->dllName.size());
1201  MemoryBufferRef mbref = MemoryBufferRef(StringRef(buf, size), s->dllName);
1202  ImportFile *impFile = make<ImportFile>(ctx, mbref);
1203  ctx.symtab.addFile(impFile);
1204}
1205