[LLD] Remove global state in lld/COFF

[akhuang]

Summary

Remove globals from the lldCOFF library, by moving globals into a context class.
This patch mostly moves the config object into COFFLinkerContext.

See https://lists.llvm.org/pipermail/llvm-dev/2021-June/151184.html for
context about removing globals from LLD.

[aganea]

lld/COFF/DLL.cpp

107

I'm seeing that a lot of the *Chunk classes have this extra context now. Have you tried to measure peak RAM usage when linking large executables? Also in scenarios when /Gy is used, for example MinGW seems to use that.

My point being, if we can pass the context by argument that would be better maybe instead of storing it into these tiny objects. But I realize that isn't always practical, thus the global access proposed in D108850 - COFFLinkerContext would simply inherit from CommonLinkingContext and then could be accessed from anywhere by a call to context().

[akhuang]

lld/COFF/DLL.cpp

107

Yeah, it feels non-ideal to store the reference in a bunch of Chunks, I'll try to see whether it's feasible to pass it by argument.

Memory usage doesn't seem to increase too much, though -- peak memory usage for linking chrome (measured with https://github.com/sgraham/tim/blob/master/tim.exe) goes up by 4mb (3972mb -> 3976mb). I think chrome builds with /Gy.

[MaskRay]

(If ELF ever needs a context, I may just use Context instead of ELFLinkerContext)

[aganea]

Thanks for doing this @akhuang! Looks good generally, a few comments:

lld/COFF/COFFLinkerContext.h

62

I think this field isn't needed anymore, since after your patch, DefinedAbsolute and applySecIdx() have direct access to ctx.outputSections.size(), which this field duplicates. The only thing that is needed is probably an assert() (see other comment in Chunks.cpp)

lld/COFF/CallGraphSort.cpp

76–77

Could be ctx see other comment.

lld/COFF/Chunks.cpp

96–102

I would pass a unsigned numOutputSections here and assert within the function that the value fits on 16-bits.

lld/COFF/DLL.cpp

107

Sounds good.

lld/COFF/InputFiles.cpp

1014

Shouldn't we keep this in ctx? Otherwise we'll be creating over and over these fake sections for each bitcode file?

lld/COFF/PDB.cpp

1703

Could also be const uint32_t secrelReloc...

lld/COFF/SymbolTable.h

51

Leaving ctx as a constructor parameter is also a perfectly valid thing to do! Please see https://stackoverflow.com/questions/6185020/initializing-member-variables-using-the-same-name-for-constructor-arguments-as-f/6185043#6185043

lld/COFF/Symbols.cpp

82

Just a tiny detail, it is a bit confusing that the diff show a totally unrelated addition here, ie.before we had numOutputSection and now we have ::getRVA(). Just my preference, but I usually insert new additions in places where nothing was changed, as compared with the previous revision.

lld/COFF/Symbols.h

24–25

Please remove commented out code.

lld/COFF/Writer.cpp

679

Please capture only &ctx

1874–1875

Please remove, see the other comment.

[aganea]

Hello @akhuang! Are you able to work on this before the 14.0 branch out? If no, can I take it over and land it? Barring any comments - @MaskRay would you have a bit of time to take a look please ?

[akhuang]

@aganea Ah, right, I can take a look at the comments today

[akhuang]

Address comments

[aganea]

Thanks again Amy! LGTM with a note:

lld/COFF/Driver.cpp

1294

As an option, in this kind of long function, one could probably also create an alias at the top, if you want to avoid those many changes:

Config &config = ctx.config;

[akhuang]

cleanup and fix stuff that got messed during rebase

[akhuang]

further cleanup

[aganea]

lld/COFF/Driver.cpp

1239

Sorry I actually meant Configuration *config = &ctx.config; just so that you don’t have all these changes below when you do a git blame.

[akhuang]

lld/COFF/Driver.cpp

1239

haha right, makes sense

[akhuang]

config. to config->

[aganea]

lld/COFF/Driver.cpp

1239

Up to your discretion, I think you can apply the same "recipe" in a few other places (see other comments).

lld/COFF/DriverUtils.cpp

100

And here?

lld/COFF/Writer.cpp

972

And here?

1363

And here.

1705

Maybe here too.

1890

You could probably do the same thing here: Configuration *config = ctx.config;

[akhuang]

some more ctx.config -> config->

[aganea]

Still looks good. Perhaps if you can, before commit to ensure there are no regressions, check that the contents of Chromium's out/ dir is the same before and after this patch? (or any other real-world example)

[MaskRay]

(If ELF is ever able to do this, we may use a shorter name than const COFFLinkerContext &ctx ...)

[MaskRay]

If other ports want to follow suit, I think storing const COFFLinkerContext &ctx; in classes like *File are fine since the instances are not too many.

Placing the member in *Section is definitely too wasteful. For classes like ImportThunkChunk, I think it'd be better to avoid storing the member as well.

[aganea]

In D110450#3273293, @MaskRay wrote:

If other ports want to follow suit, I think storing const COFFLinkerContext &ctx; in classes like *File are fine since the instances are not too many.

Placing the member in *Section is definitely too wasteful. For classes like ImportThunkChunk, I think it'd be better to avoid storing the member as well.

@akhuang mentioned that this patch only increases by 4 MB the peak mem when linking a Chromium .dll with /Gy, see above https://reviews.llvm.org/D110450#3028764
Since the COFF driver would still not be thread-safe after this patch, if you prefer we can also use lld::context<COFFLinkerContext>() (instead of storing ctx in *ImportThunkChunk). And then as a second step, introduce thread_local contexts, for cases like this where passing ctx through the callstack is infeasible/requires too many changes. See https://reviews.llvm.org/D108850?id=370678, lld/Common/Globals.cpp, L44.

[MaskRay]

In D110450#3273343, @aganea wrote:

In D110450#3273293, @MaskRay wrote:

If other ports want to follow suit, I think storing const COFFLinkerContext &ctx; in classes like *File are fine since the instances are not too many.

Placing the member in *Section is definitely too wasteful. For classes like ImportThunkChunk, I think it'd be better to avoid storing the member as well.

@akhuang mentioned that this patch only increases by 4 MB the peak mem when linking a Chromium .dll with /Gy, see above https://reviews.llvm.org/D110450#3028764
Since the COFF driver would still not be thread-safe after this patch, if you prefer we can also use lld::context<COFFLinkerContext>() (instead of storing ctx in *ImportThunkChunk). And then as a second step, introduce thread_local contexts, for cases like this where passing ctx through the callstack is infeasible/requires too many changes. See https://reviews.llvm.org/D108850?id=370678, lld/Common/Globals.cpp, L44.

If it is not trivial to avoid the context variable in classes like COFFLinkerContext, I think it is fine.
4MB increase seems acceptable.

thread_local performance is fine on aarch64 but has a higher cost (hidden visibility doesn't help) on other architectures (especially x86-64 which many people are concerned) because llvm-project compiles lld files with -fPIC which uses traditional GD/LD TLS models which are slow:(

(This remind me that at some point I should implement TLSDESC for x86-64 (now that ld.lld support is fully correct after D116900)).

[aganea]

In D110450#3273360, @MaskRay wrote:

thread_local performance is fine on aarch64 but has a higher cost (hidden visibility doesn't help) on other architectures (especially x86-64 which many people are concerned) because llvm-project compiles lld files with -fPIC which uses traditional GD/LD TLS models which are slow:(

It isn't particularly cheap on the Windows ABI either: https://godbolt.org/z/frEe87zcq - however I/O dominates in LLD right now, so using thread_local for ctx doesn't really change the runtime performance of LLD, at least on Windows/x64: https://reviews.llvm.org/D108850?id=370678#2975472

[aganea]

Hello @akhuang! Do you think I can land this on your behalf? I've already rebased & tested locally.

[akhuang]

In D110450#3653404, @aganea wrote:

Hello @akhuang! Do you think I can land this on your behalf? I've already rebased & tested locally.

Yep, go ahead! Sorry I've been fairly unresponsive on this patch.

[mstorsjo]

This patch broke one case for me - it's reproducible by improving one of the existing testcases like this:

diff --git a/lld/test/COFF/export-all-lto.ll b/lld/test/COFF/export-all-lto.ll
index 13620e11d9b9..8d54b981a104 100644
--- a/lld/test/COFF/export-all-lto.ll
+++ b/lld/test/COFF/export-all-lto.ll
@@ -2,9 +2,10 @@
 
 ; RUN: llvm-as %s -o %t.bc
 
-; RUN: lld-link -lldmingw -dll -out:%t.dll %t.bc -noentry -output-def:%t.def
+; RUN: lld-link -lldmingw -dll -out:%t.dll %t.bc -noentry -output-def:%t.def -implib:%t.lib
 ; RUN: llvm-readobj --coff-exports %t.dll | grep Name: | FileCheck %s
 ; RUN: cat %t.def | FileCheck --check-prefix=IMPLIB %s
+; RUN: llvm-nm %t.lib | FileCheck --check-prefix=IMPLIB-SYMS %s
 
 ; CHECK: Name: MyComdatFunc
 ; CHECK: Name: MyExtData
@@ -14,6 +15,12 @@
 ; IMPLIB: MyExtData @2 DATA
 ; IMPLIB: MyLibFunc @3{{$}}
 
+; IMPLIB-SYMS: 00000000 T MyComdatFunc
+; IMPLIB-SYMS: 00000000 T __imp_MyComdatFunc
+; IMPLIB-SYMS: 00000000 D __imp_MyExtData
+; IMPLIB-SYMS: 00000000 T MyLibFunc
+; IMPLIB-SYMS: 00000000 T __imp_MyLibFunc
+
 target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-w64-windows-gnu"

@aganea How do you want to go about fixing this; should I revert the patch and land this test improvement separately, so that this can be relanded with the test in place?

[aganea]

@mstorsjo Yes please revert. Thanks in advance!

[mstorsjo]

In D110450#4036025, @aganea wrote:

@mstorsjo Yes please revert. Thanks in advance!

Ok, done now!

[aganea]

lld/COFF/COFFLinkerContext.cpp

75

@mstorsjo These two structs were keeping a dangling pointer, as the FakeSections above went out of scope.

[thakis]

This broke tests on Windows: http://45.33.8.238/win/73025/step_10.txt

Please take a look and revert for now if it takes a while to fix.

[andrewng]

In D110450#4039625, @thakis wrote:

This broke tests on Windows: http://45.33.8.238/win/73025/step_10.txt

Please take a look and revert for now if it takes a while to fix.

I've already committed a fix: https://reviews.llvm.org/rG85a2f29fd485d29e6a93de6f0c2bfdc009d06a56.

[aganea]

In D110450#4039625, @thakis wrote:

This broke tests on Windows: http://45.33.8.238/win/73025/step_10.txt

Please take a look and revert for now if it takes a while to fix.

Looking now!

[aganea]

In D110450#4039659, @andrewng wrote:

In D110450#4039625, @thakis wrote:

This broke tests on Windows: http://45.33.8.238/win/73025/step_10.txt

Please take a look and revert for now if it takes a while to fix.

I've already committed a fix: https://reviews.llvm.org/rG85a2f29fd485d29e6a93de6f0c2bfdc009d06a56.

Thank you!

lld/COFF/COFFLinkerContext.h

 //===- COFFLinkerContext.h --------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLD_COFF_COFFLinkerContext_H
-#define LLD_COFF_COFFLinkerContext_H
+#ifndef LLD_COFF_COFFLINKERCONTEXT_H
+#define LLD_COFF_COFFLINKERCONTEXT_H
 
 #include "Chunks.h"
 #include "Config.h"
 #include "DebugTypes.h"
+#include "Driver.h"
 #include "InputFiles.h"
 #include "SymbolTable.h"
 #include "Writer.h"
 #include "lld/Common/CommonLinkerContext.h"
 #include "lld/Common/Timer.h"
 
 namespace lld {
 namespace coff {
 
 class COFFLinkerContext : public CommonLinkerContext {
 public:
   COFFLinkerContext();
   COFFLinkerContext(const COFFLinkerContext &) = delete;
   COFFLinkerContext &operator=(const COFFLinkerContext &) = delete;
   ~COFFLinkerContext() = default;
 
-  void addTpiSource(TpiSource *tpi) { tpiSourceList.push_back(tpi); }
-
+  LinkerDriver driver;
   SymbolTable symtab;
+  COFFOptTable optTable;
 
   std::vector<ObjFile *> objFileInstances;
   std::map<std::string, PDBInputFile *> pdbInputFileInstances;
   std::vector<ImportFile *> importFileInstances;
   std::vector<BitcodeFile *> bitcodeFileInstances;
 
   MergeChunk *mergeChunkInstances[Log2MaxSectionAlignment + 1] = {};
 
   /// All sources of type information in the program.
   std::vector<TpiSource *> tpiSourceList;
 
+  void addTpiSource(TpiSource *tpi) { tpiSourceList.push_back(tpi); }
+
   std::map<llvm::codeview::GUID, TpiSource *> typeServerSourceMappings;
   std::map<uint32_t, TpiSource *> precompSourceMappings;
 
   /// List of all output sections. After output sections are finalized, this
   /// can be indexed by getOutputSection.
   std::vector<OutputSection *> outputSections;
 
   OutputSection *getOutputSection(const Chunk *c) const {
     return c->osidx == 0 ? nullptr : outputSections[c->osidx - 1];
   }
 
+  std::string maybeDemangleSymbol(StringRef symName) const;
+  std::string toString(coff::Symbol &b) const;
+
+  // There are two different ways to convert an Archive::Symbol to a string:
+  // One for Microsoft name mangling and one for Itanium name mangling.
+  // Call the functions toCOFFString and toELFString, not just toString.
+  std::string toCOFFString(const Archive::Symbol &b) const;
+
+  // Fake sections for parsing bitcode files.
+  FakeSectionChunk *ltoTextSectionChunk;
+  FakeSectionChunk *ltoDataSectionChunk;
+
   // All timers used in the COFF linker.
   Timer rootTimer;
   Timer inputFileTimer;
   Timer ltoTimer;
   Timer gcTimer;
   Timer icfTimer;
 
   // Writer timers.
public:
   Timer addObjectsTimer;
   Timer typeMergingTimer;
   Timer loadGHashTimer;
   Timer mergeGHashTimer;
   Timer symbolMergingTimer;
   Timer publicsLayoutTimer;
   Timer tpiStreamLayoutTimer;
   Timer diskCommitTimer;
+
+  Configuration config;
 };
 
 } // namespace coff
 } // namespace lld
 
 #endif

lld/COFF/COFFLinkerContext.cpp

 //===- COFFContext.cpp ----------------------------------------------------===//
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Description
 //
 //===----------------------------------------------------------------------===//
 
 #include "COFFLinkerContext.h"
+#include "Symbols.h"
 #include "lld/Common/Memory.h"
+#include "llvm/BinaryFormat/COFF.h"
 #include "llvm/DebugInfo/CodeView/TypeHashing.h"
+#include "llvm/Demangle/Demangle.h"
 
 namespace lld {
 namespace coff {
 
 COFFLinkerContext::COFFLinkerContext()
-    : symtab(*this), rootTimer("Total Linking Time"),
+    : driver(*this), symtab(*this), rootTimer("Total Linking Time"),
       inputFileTimer("Input File Reading", rootTimer),
       ltoTimer("LTO", rootTimer), gcTimer("GC", rootTimer),
       icfTimer("ICF", rootTimer), codeLayoutTimer("Code Layout", rootTimer),
       outputCommitTimer("Commit Output File", rootTimer),
       totalMapTimer("MAP Emission (Cumulative)", rootTimer),
       symbolGatherTimer("Gather Symbols", totalMapTimer),
       symbolStringsTimer("Build Symbol Strings", totalMapTimer),
       writeTimer("Write to File", totalMapTimer),
       totalPdbLinkTimer("PDB Emission (Cumulative)", rootTimer),
       addObjectsTimer("Add Objects", totalPdbLinkTimer),
       typeMergingTimer("Type Merging", addObjectsTimer),
       loadGHashTimer("Global Type Hashing", addObjectsTimer),
       mergeGHashTimer("GHash Type Merging", addObjectsTimer),
       symbolMergingTimer("Symbol Merging", addObjectsTimer),
       publicsLayoutTimer("Publics Stream Layout", totalPdbLinkTimer),
       tpiStreamLayoutTimer("TPI Stream Layout", totalPdbLinkTimer),
-      diskCommitTimer("Commit to Disk", totalPdbLinkTimer) {}
+      diskCommitTimer("Commit to Disk", totalPdbLinkTimer) {
+  FakeSection ltoTextSection(llvm::COFF::IMAGE_SCN_MEM_EXECUTE);
+  FakeSection ltoDataSection(llvm::COFF::IMAGE_SCN_CNT_INITIALIZED_DATA);
+  ltoTextSectionChunk = make<FakeSectionChunk>(&ltoTextSection.section);
+  ltoDataSectionChunk = make<FakeSectionChunk>(&ltoDataSection.section);
+}
+
+// Returns a symbol name for an error message.
+std::string COFFLinkerContext::maybeDemangleSymbol(StringRef symName) const {
+  if (config.demangle) {
+    std::string prefix;
+    StringRef prefixless = symName;
+    if (prefixless.consume_front("__imp_"))
+      prefix = "__declspec(dllimport) ";
+    StringRef demangleInput = prefixless;
+    if (config.machine == I386)
+      demangleInput.consume_front("_");
+    std::string demangled = llvm::demangle(std::string(demangleInput));
+    if (demangled != demangleInput)
+      return prefix + llvm::demangle(std::string(demangleInput));
+    return (prefix + prefixless).str();
+  }
+  return std::string(symName);
+}
+
+std::string COFFLinkerContext::toString(Symbol &b) const {
+  return maybeDemangleSymbol(b.getName());
+}
+
+std::string COFFLinkerContext::toCOFFString(const Archive::Symbol &b) const {
+  return maybeDemangleSymbol(b.getName());
+}
 
 } // namespace coff
 } // namespace lld

lld/COFF/CallGraphSort.cpp

 public:
   CallGraphSort(const COFFLinkerContext &ctx);
 
   DenseMap<const SectionChunk *, int> run();
 
 private:
   std::vector<Cluster> clusters;
   std::vector<const SectionChunk *> sections;
+
+  const COFFLinkerContext &ctx;
 };
 
 // Maximum amount the combined cluster density can be worse than the original
 // cluster to consider merging.
 constexpr int MAX_DENSITY_DEGRADATION = 8;
 
 // Maximum cluster size in bytes.
 constexpr uint64_t MAX_CLUSTER_SIZE = 1024 * 1024;
 } // end anonymous namespace
 
 using SectionPair = std::pair<const SectionChunk *, const SectionChunk *>;
 
 // Take the edge list in Config->CallGraphProfile, resolve symbol names to
 // Symbols, and generate a graph between InputSections with the provided
 // weights.
-CallGraphSort::CallGraphSort(const COFFLinkerContext &ctx) {
-  MapVector<SectionPair, uint64_t> &profile = config->callGraphProfile;
+CallGraphSort::CallGraphSort(const COFFLinkerContext &ctx) : ctx(ctx) {
+  const MapVector<SectionPair, uint64_t> &profile = ctx.config.callGraphProfile;
   DenseMap<const SectionChunk *, int> secToCluster;
 
   auto getOrCreateNode = [&](const SectionChunk *isec) -> int {
     auto res = secToCluster.try_emplace(isec, clusters.size());
     if (res.second) {
       sections.push_back(isec);
       clusters.emplace_back(clusters.size(), isec->getSize());
     }
     return res.first->second;
   };
 
   // Create the graph.
-  for (std::pair<SectionPair, uint64_t> &c : profile) {
+  for (const std::pair<SectionPair, uint64_t> &c : profile) {
     const auto *fromSec = cast<SectionChunk>(c.first.first->repl);
     const auto *toSec = cast<SectionChunk>(c.first.second->repl);
     uint64_t weight = c.second;
 
     // Ignore edges between input sections belonging to different output
     // sections.  This is done because otherwise we would end up with clusters
     // containing input sections that can't actually be placed adjacently in the
     // output.  This messes with the cluster size and density calculations.  We
DenseMap<const SectionChunk *, int> CallGraphSort::run() {
   for (int leader : sorted) {
     for (int i = leader;;) {
       orderMap[sections[i]] = curOrder++;
       i = clusters[i].next;
       if (i == leader)
         break;
     }
   }
-  if (!config->printSymbolOrder.empty()) {
+  if (!ctx.config.printSymbolOrder.empty()) {
     std::error_code ec;
-    raw_fd_ostream os(config->printSymbolOrder, ec, sys::fs::OF_None);
+    raw_fd_ostream os(ctx.config.printSymbolOrder, ec, sys::fs::OF_None);
     if (ec) {
-      error("cannot open " + config->printSymbolOrder + ": " + ec.message());
+      error("cannot open " + ctx.config.printSymbolOrder + ": " + ec.message());
       return orderMap;
     }
     // Print the symbols ordered by C3, in the order of increasing curOrder
     // Instead of sorting all the orderMap, just repeat the loops above.
     for (int leader : sorted)
       for (int i = leader;;) {
         const SectionChunk *sc = sections[i];
 

lld/COFF/Chunks.h

public:
   }
   StringRef getSectionName() const {
     return StringRef(sectionNameData, sectionNameSize);
   }
   void getBaserels(std::vector<Baserel> *res);
   bool isCOMDAT() const;
   void applyRelocation(uint8_t *off, const coff_relocation &rel) const;
   void applyRelX64(uint8_t *off, uint16_t type, OutputSection *os, uint64_t s,
-                   uint64_t p) const;
+                   uint64_t p, uint64_t imageBase) const;
   void applyRelX86(uint8_t *off, uint16_t type, OutputSection *os, uint64_t s,
-                   uint64_t p) const;
+                   uint64_t p, uint64_t imageBase) const;
   void applyRelARM(uint8_t *off, uint16_t type, OutputSection *os, uint64_t s,
-                   uint64_t p) const;
+                   uint64_t p, uint64_t imageBase) const;
   void applyRelARM64(uint8_t *off, uint16_t type, OutputSection *os, uint64_t s,
-                     uint64_t p) const;
+                     uint64_t p, uint64_t imageBase) const;
 
   void getRuntimePseudoRelocs(std::vector<RuntimePseudoReloc> &res);
 
   // Called if the garbage collector decides to not include this chunk
   // in a final output. It's supposed to print out a log message to stdout.
   void printDiscardedMessage() const;
 
   // Adds COMDAT associative sections to this COMDAT section. A chunk
static const uint8_t importThunkARM64[] = {
     0x00, 0x02, 0x1f, 0xd6, // br   x16
 };
 
 // Windows-specific.
 // A chunk for DLL import jump table entry. In a final output, its
 // contents will be a JMP instruction to some __imp_ symbol.
 class ImportThunkChunk : public NonSectionChunk {
 public:
-  ImportThunkChunk(Defined *s)
-      : NonSectionChunk(ImportThunkKind), impSymbol(s) {}
+  ImportThunkChunk(COFFLinkerContext &ctx, Defined *s)
+      : NonSectionChunk(ImportThunkKind), impSymbol(s), ctx(ctx) {}
   static bool classof(const Chunk *c) { return c->kind() == ImportThunkKind; }
 
 protected:
   Defined *impSymbol;
+  COFFLinkerContext &ctx;
 };
 
 class ImportThunkChunkX64 : public ImportThunkChunk {
 public:
-  explicit ImportThunkChunkX64(Defined *s);
+  explicit ImportThunkChunkX64(COFFLinkerContext &ctx, Defined *s);
   size_t getSize() const override { return sizeof(importThunkX86); }
   void writeTo(uint8_t *buf) const override;
 };
 
 class ImportThunkChunkX86 : public ImportThunkChunk {
 public:
-  explicit ImportThunkChunkX86(Defined *s) : ImportThunkChunk(s) {}
+  explicit ImportThunkChunkX86(COFFLinkerContext &ctx, Defined *s)
+      : ImportThunkChunk(ctx, s) {}
   size_t getSize() const override { return sizeof(importThunkX86); }
   void getBaserels(std::vector<Baserel> *res) override;
   void writeTo(uint8_t *buf) const override;
 };
 
 class ImportThunkChunkARM : public ImportThunkChunk {
 public:
-  explicit ImportThunkChunkARM(Defined *s) : ImportThunkChunk(s) {
+  explicit ImportThunkChunkARM(COFFLinkerContext &ctx, Defined *s)
+      : ImportThunkChunk(ctx, s) {
     setAlignment(2);
   }
   size_t getSize() const override { return sizeof(importThunkARM); }
   void getBaserels(std::vector<Baserel> *res) override;
   void writeTo(uint8_t *buf) const override;
 };
 
 class ImportThunkChunkARM64 : public ImportThunkChunk {
 public:
-  explicit ImportThunkChunkARM64(Defined *s) : ImportThunkChunk(s) {
+  explicit ImportThunkChunkARM64(COFFLinkerContext &ctx, Defined *s)
+      : ImportThunkChunk(ctx, s) {
     setAlignment(4);
   }
   size_t getSize() const override { return sizeof(importThunkARM64); }
   void writeTo(uint8_t *buf) const override;
 };
 
 class RangeExtensionThunkARM : public NonSectionChunk {
 public:
-  explicit RangeExtensionThunkARM(Defined *t) : target(t) { setAlignment(2); }
+  explicit RangeExtensionThunkARM(COFFLinkerContext &ctx, Defined *t)
+      : target(t), ctx(ctx) {
+    setAlignment(2);
+  }
   size_t getSize() const override;
   void writeTo(uint8_t *buf) const override;
 
   Defined *target;
+
+private:
+  COFFLinkerContext &ctx;
 };
 
 class RangeExtensionThunkARM64 : public NonSectionChunk {
 public:
-  explicit RangeExtensionThunkARM64(Defined *t) : target(t) { setAlignment(4); }
+  explicit RangeExtensionThunkARM64(COFFLinkerContext &ctx, Defined *t)
+      : target(t), ctx(ctx) {
+    setAlignment(4);
+  }
   size_t getSize() const override;
   void writeTo(uint8_t *buf) const override;
 
   Defined *target;
+
+private:
+  COFFLinkerContext &ctx;
 };
 
 // Windows-specific.
 // See comments for DefinedLocalImport class.
 class LocalImportChunk : public NonSectionChunk {
 public:
-  explicit LocalImportChunk(Defined *s) : sym(s) {
-    setAlignment(config->wordsize);
-  }
+  explicit LocalImportChunk(COFFLinkerContext &ctx, Defined *s);
   size_t getSize() const override;
   void getBaserels(std::vector<Baserel> *res) override;
   void writeTo(uint8_t *buf) const override;
 
 private:
   Defined *sym;
+  COFFLinkerContext &ctx;
 };
 
 // Duplicate RVAs are not allowed in RVA tables, so unique symbols by chunk and
 // offset into the chunk. Order does not matter as the RVA table will be sorted
 // later.
 struct ChunkAndOffset {
   Chunk *inputChunk;
   uint32_t offset;

 
 private:
   std::vector<uint8_t> data;
 };
 
 class Baserel {
 public:
   Baserel(uint32_t v, uint8_t ty) : rva(v), type(ty) {}
-  explicit Baserel(uint32_t v) : Baserel(v, getDefaultType()) {}
-  uint8_t getDefaultType();
+  explicit Baserel(uint32_t v, llvm::COFF::MachineTypes machine)
+      : Baserel(v, getDefaultType(machine)) {}
+  uint8_t getDefaultType(llvm::COFF::MachineTypes machine);
 
   uint32_t rva;
   uint8_t type;
 };
 
 // This is a placeholder Chunk, to allow attaching a DefinedSynthetic to a
 // specific place in a section, without any data. This is used for the MinGW
 // specific symbol __RUNTIME_PSEUDO_RELOC_LIST_END__, even though the concept
public:
   // The Flags field contains the size of the relocation, in bits. No other
   // flags are currently defined.
   int flags;
 };
 
 // MinGW specific. A Chunk that contains one pointer-sized absolute value.
 class AbsolutePointerChunk : public NonSectionChunk {
 public:
-  AbsolutePointerChunk(uint64_t value) : value(value) {
+  AbsolutePointerChunk(COFFLinkerContext &ctx, uint64_t value)
+      : value(value), ctx(ctx) {
     setAlignment(getSize());
   }
   size_t getSize() const override;
   void writeTo(uint8_t *buf) const override;
 
 private:
   uint64_t value;
+  COFFLinkerContext &ctx;
 };
 
 // Return true if this file has the hotpatch flag set to true in the S_COMPILE3
 // record in codeview debug info. Also returns true for some thunks synthesized
 // by the linker.
 inline bool Chunk::isHotPatchable() const {
   if (auto *sc = dyn_cast<SectionChunk>(this))
     return sc->file->hotPatchable;
   else if (isa<ImportThunkChunk>(this))
     return true;
   return false;
 }
 
 void applyMOV32T(uint8_t *off, uint32_t v);
 void applyBranch24T(uint8_t *off, int32_t v);
 
 void applyArm64Addr(uint8_t *off, uint64_t s, uint64_t p, int shift);
 void applyArm64Imm(uint8_t *off, uint64_t imm, uint32_t rangeLimit);
 void applyArm64Branch26(uint8_t *off, int64_t v);
 
+// Convenience class for initializing a SectionChunk with specific flags.
+class FakeSectionChunk {
+public:
+  FakeSectionChunk(const coff_section *section) : chunk(nullptr, section) {
+    // Comdats from LTO files can't be fully treated as regular comdats
+    // at this point; we don't know what size or contents they are going to
+    // have, so we can't do proper checking of such aspects of them.
+    chunk.selection = llvm::COFF::IMAGE_COMDAT_SELECT_ANY;
+  }
+
+  SectionChunk chunk;
+};
+
 } // namespace coff
 } // namespace lld
 
 namespace llvm {
 template <>
 struct DenseMapInfo<lld::coff::ChunkAndOffset>
     : lld::coff::ChunkAndOffset::DenseMapInfo {};
 }
 
 #endif

lld/COFF/Chunks.cpp

SectionChunk::SectionChunk(ObjFile *f, const coff_section *h)
   setAlignment(header->getAlignment());
 
   hasData = !(header->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA);
 
   // If linker GC is disabled, every chunk starts out alive.  If linker GC is
   // enabled, treat non-comdat sections as roots. Generally optimized object
   // files will be built with -ffunction-sections or /Gy, so most things worth
   // stripping will be in a comdat.
-  if (config)
-    live = !config->doGC || !isCOMDAT();
+  if (file)
+    live = !file->ctx.config.doGC || !isCOMDAT();
   else
     live = true;
 }
 
 // SectionChunk is one of the most frequently allocated classes, so it is
 // important to keep it as compact as possible. As of this writing, the number
 // below is the size of this class on x64 platforms.
 static_assert(sizeof(SectionChunk) <= 88, "SectionChunk grew unexpectedly");
static void applySecRel(const SectionChunk *sec, uint8_t *off,
   uint64_t secRel = s - os->getRVA();
   if (secRel > UINT32_MAX) {
     error("overflow in SECREL relocation in section: " + sec->getSectionName());
     return;
   }
   add32(off, secRel);
 }
 
-static void applySecIdx(uint8_t *off, OutputSection *os) {
+static void applySecIdx(uint8_t *off, OutputSection *os,
+                        unsigned numOutputSections) {
+  // numOutputSections is the largest valid section index. Make sure that
+  // it fits in 16 bits.
+  assert(sizeof(numOutputSections) <= 0xffff &&
+         "size of outputSections is too big");
+
   // Absolute symbol doesn't have section index, but section index relocation
   // against absolute symbol should be resolved to one plus the last output
   // section index. This is required for compatibility with MSVC.
   if (os)
     add16(off, os->sectionIndex);
   else
-    add16(off, DefinedAbsolute::numOutputSections + 1);
+    add16(off, numOutputSections + 1);
 }
 
 void SectionChunk::applyRelX64(uint8_t *off, uint16_t type, OutputSection *os,
-                               uint64_t s, uint64_t p) const {
+                               uint64_t s, uint64_t p,
+                               uint64_t imageBase) const {
   switch (type) {
-  case IMAGE_REL_AMD64_ADDR32:   add32(off, s + config->imageBase); break;
-  case IMAGE_REL_AMD64_ADDR64:   add64(off, s + config->imageBase); break;
+  case IMAGE_REL_AMD64_ADDR32:
+    add32(off, s + imageBase);
+    break;
+  case IMAGE_REL_AMD64_ADDR64:
+    add64(off, s + imageBase);
+    break;
   case IMAGE_REL_AMD64_ADDR32NB: add32(off, s); break;
   case IMAGE_REL_AMD64_REL32:    add32(off, s - p - 4); break;
   case IMAGE_REL_AMD64_REL32_1:  add32(off, s - p - 5); break;
   case IMAGE_REL_AMD64_REL32_2:  add32(off, s - p - 6); break;
   case IMAGE_REL_AMD64_REL32_3:  add32(off, s - p - 7); break;
   case IMAGE_REL_AMD64_REL32_4:  add32(off, s - p - 8); break;
   case IMAGE_REL_AMD64_REL32_5:  add32(off, s - p - 9); break;
-  case IMAGE_REL_AMD64_SECTION:  applySecIdx(off, os); break;
+  case IMAGE_REL_AMD64_SECTION:
+    applySecIdx(off, os, file->ctx.outputSections.size());
+    break;
   case IMAGE_REL_AMD64_SECREL:   applySecRel(this, off, os, s); break;
   default:
     error("unsupported relocation type 0x" + Twine::utohexstr(type) + " in " +
           toString(file));
   }
 }
 
 void SectionChunk::applyRelX86(uint8_t *off, uint16_t type, OutputSection *os,
-                               uint64_t s, uint64_t p) const {
+                               uint64_t s, uint64_t p,
+                               uint64_t imageBase) const {
   switch (type) {
   case IMAGE_REL_I386_ABSOLUTE: break;
-  case IMAGE_REL_I386_DIR32:    add32(off, s + config->imageBase); break;
+  case IMAGE_REL_I386_DIR32:
+    add32(off, s + imageBase);
+    break;
   case IMAGE_REL_I386_DIR32NB:  add32(off, s); break;
   case IMAGE_REL_I386_REL32:    add32(off, s - p - 4); break;
-  case IMAGE_REL_I386_SECTION:  applySecIdx(off, os); break;
+  case IMAGE_REL_I386_SECTION:
+    applySecIdx(off, os, file->ctx.outputSections.size());
+    break;
   case IMAGE_REL_I386_SECREL:   applySecRel(this, off, os, s); break;
   default:
     error("unsupported relocation type 0x" + Twine::utohexstr(type) + " in " +
           toString(file));
   }
 }
 
 static void applyMOV(uint8_t *off, uint16_t v) {
void applyBranch24T(uint8_t *off, int32_t v) {
   uint32_t j1 = ((~v >> 23) & 1) ^ s;
   uint32_t j2 = ((~v >> 22) & 1) ^ s;
   or16(off, (s << 10) | ((v >> 12) & 0x3ff));
   // Clear out the J1 and J2 bits which may be set.
   write16le(off + 2, (read16le(off + 2) & 0xd000) | (j1 << 13) | (j2 << 11) | ((v >> 1) & 0x7ff));
 }
 
 void SectionChunk::applyRelARM(uint8_t *off, uint16_t type, OutputSection *os,
-                               uint64_t s, uint64_t p) const {
+                               uint64_t s, uint64_t p,
+                               uint64_t imageBase) const {
   // Pointer to thumb code must have the LSB set.
   uint64_t sx = s;
   if (os && (os->header.Characteristics & IMAGE_SCN_MEM_EXECUTE))
     sx |= 1;
   switch (type) {
-  case IMAGE_REL_ARM_ADDR32:    add32(off, sx + config->imageBase); break;
+  case IMAGE_REL_ARM_ADDR32:
+    add32(off, sx + imageBase);
+    break;
   case IMAGE_REL_ARM_ADDR32NB:  add32(off, sx); break;
-  case IMAGE_REL_ARM_MOV32T:    applyMOV32T(off, sx + config->imageBase); break;
+  case IMAGE_REL_ARM_MOV32T:
+    applyMOV32T(off, sx + imageBase);
+    break;
   case IMAGE_REL_ARM_BRANCH20T: applyBranch20T(off, sx - p - 4); break;
   case IMAGE_REL_ARM_BRANCH24T: applyBranch24T(off, sx - p - 4); break;
   case IMAGE_REL_ARM_BLX23T:    applyBranch24T(off, sx - p - 4); break;
-  case IMAGE_REL_ARM_SECTION:   applySecIdx(off, os); break;
+  case IMAGE_REL_ARM_SECTION:
+    applySecIdx(off, os, file->ctx.outputSections.size());
+    break;
   case IMAGE_REL_ARM_SECREL:    applySecRel(this, off, os, s); break;
   case IMAGE_REL_ARM_REL32:     add32(off, sx - p - 4); break;
   default:
     error("unsupported relocation type 0x" + Twine::utohexstr(type) + " in " +
           toString(file));
   }
 }
 

 
 static void applyArm64Branch14(uint8_t *off, int64_t v) {
   if (!isInt<16>(v))
     error("relocation out of range");
   or32(off, (v & 0x0000FFFC) << 3);
 }
 
 void SectionChunk::applyRelARM64(uint8_t *off, uint16_t type, OutputSection *os,
-                                 uint64_t s, uint64_t p) const {
+                                 uint64_t s, uint64_t p,
+                                 uint64_t imageBase) const {
   switch (type) {
   case IMAGE_REL_ARM64_PAGEBASE_REL21: applyArm64Addr(off, s, p, 12); break;
   case IMAGE_REL_ARM64_REL21:          applyArm64Addr(off, s, p, 0); break;
   case IMAGE_REL_ARM64_PAGEOFFSET_12A: applyArm64Imm(off, s & 0xfff, 0); break;
   case IMAGE_REL_ARM64_PAGEOFFSET_12L: applyArm64Ldr(off, s & 0xfff); break;
   case IMAGE_REL_ARM64_BRANCH26:       applyArm64Branch26(off, s - p); break;
   case IMAGE_REL_ARM64_BRANCH19:       applyArm64Branch19(off, s - p); break;
   case IMAGE_REL_ARM64_BRANCH14:       applyArm64Branch14(off, s - p); break;
-  case IMAGE_REL_ARM64_ADDR32:         add32(off, s + config->imageBase); break;
+  case IMAGE_REL_ARM64_ADDR32:
+    add32(off, s + imageBase);
+    break;
   case IMAGE_REL_ARM64_ADDR32NB:       add32(off, s); break;
-  case IMAGE_REL_ARM64_ADDR64:         add64(off, s + config->imageBase); break;
+  case IMAGE_REL_ARM64_ADDR64:
+    add64(off, s + imageBase);
+    break;
   case IMAGE_REL_ARM64_SECREL:         applySecRel(this, off, os, s); break;
   case IMAGE_REL_ARM64_SECREL_LOW12A:  applySecRelLow12A(this, off, os, s); break;
   case IMAGE_REL_ARM64_SECREL_HIGH12A: applySecRelHigh12A(this, off, os, s); break;
   case IMAGE_REL_ARM64_SECREL_LOW12L:  applySecRelLdr(this, off, os, s); break;
-  case IMAGE_REL_ARM64_SECTION:        applySecIdx(off, os); break;
+  case IMAGE_REL_ARM64_SECTION:
+    applySecIdx(off, os, file->ctx.outputSections.size());
+    break;
   case IMAGE_REL_ARM64_REL32:          add32(off, s - p - 4); break;
   default:
     error("unsupported relocation type 0x" + Twine::utohexstr(type) + " in " +
           toString(file));
   }
 }
 
 static void maybeReportRelocationToDiscarded(const SectionChunk *fromChunk,
                                              Defined *sym,
-                                             const coff_relocation &rel) {
+                                             const coff_relocation &rel,
+                                             bool isMinGW) {
   // Don't report these errors when the relocation comes from a debug info
   // section or in mingw mode. MinGW mode object files (built by GCC) can
   // have leftover sections with relocations against discarded comdat
   // sections. Such sections are left as is, with relocations untouched.
-  if (fromChunk->isCodeView() || fromChunk->isDWARF() || config->mingw)
+  if (fromChunk->isCodeView() || fromChunk->isDWARF() || isMinGW)
     return;
 
   // Get the name of the symbol. If it's null, it was discarded early, so we
   // have to go back to the object file.
   ObjFile *file = fromChunk->file;
   StringRef name;
   if (sym) {
     name = sym->getName();
void SectionChunk::applyRelocation(uint8_t *off,
   OutputSection *os = c ? file->ctx.getOutputSection(c) : nullptr;
 
   // Skip the relocation if it refers to a discarded section, and diagnose it
   // as an error if appropriate. If a symbol was discarded early, it may be
   // null. If it was discarded late, the output section will be null, unless
   // it was an absolute or synthetic symbol.
   if (!sym ||
       (!os && !isa<DefinedAbsolute>(sym) && !isa<DefinedSynthetic>(sym))) {
-    maybeReportRelocationToDiscarded(this, sym, rel);
+    maybeReportRelocationToDiscarded(this, sym, rel, file->ctx.config.mingw);
     return;
   }
 
   uint64_t s = sym->getRVA();
 
   // Compute the RVA of the relocation for relative relocations.
   uint64_t p = rva + rel.VirtualAddress;
-  switch (config->machine) {
+  uint64_t imageBase = file->ctx.config.imageBase;
+  switch (file->ctx.config.machine) {
   case AMD64:
-    applyRelX64(off, rel.Type, os, s, p);
+    applyRelX64(off, rel.Type, os, s, p, imageBase);
     break;
   case I386:
-    applyRelX86(off, rel.Type, os, s, p);
+    applyRelX86(off, rel.Type, os, s, p, imageBase);
     break;
   case ARMNT:
-    applyRelARM(off, rel.Type, os, s, p);
+    applyRelARM(off, rel.Type, os, s, p, imageBase);
     break;
   case ARM64:
-    applyRelARM64(off, rel.Type, os, s, p);
+    applyRelARM64(off, rel.Type, os, s, p, imageBase);
     break;
   default:
     llvm_unreachable("unknown machine type");
   }
 }
 
 // Defend against unsorted relocations. This may be overly conservative.
 void SectionChunk::sortRelocations() {
void SectionChunk::addAssociative(SectionChunk *child) {
   }
 
   // Insert child between prev and next.
   assert(prev->assocChildren == next);
   prev->assocChildren = child;
   child->assocChildren = next;
 }
 
-static uint8_t getBaserelType(const coff_relocation &rel) {
-  switch (config->machine) {
+static uint8_t getBaserelType(const coff_relocation &rel,
+                              llvm::COFF::MachineTypes machine) {
+  switch (machine) {
   case AMD64:
     if (rel.Type == IMAGE_REL_AMD64_ADDR64)
       return IMAGE_REL_BASED_DIR64;
     if (rel.Type == IMAGE_REL_AMD64_ADDR32)
       return IMAGE_REL_BASED_HIGHLOW;
     return IMAGE_REL_BASED_ABSOLUTE;
   case I386:
     if (rel.Type == IMAGE_REL_I386_DIR32)

 }
 
 // Windows-specific.
 // Collect all locations that contain absolute addresses, which need to be
 // fixed by the loader if load-time relocation is needed.
 // Only called when base relocation is enabled.
 void SectionChunk::getBaserels(std::vector<Baserel> *res) {
   for (const coff_relocation &rel : getRelocs()) {
-    uint8_t ty = getBaserelType(rel);
+    uint8_t ty = getBaserelType(rel, file->ctx.config.machine);
     if (ty == IMAGE_REL_BASED_ABSOLUTE)
       continue;
     Symbol *target = file->getSymbol(rel.SymbolTableIndex);
     if (!target || isa<DefinedAbsolute>(target))
       continue;
     res->emplace_back(rva + rel.VirtualAddress, ty);
   }
 }
 
 // MinGW specific.
 // Check whether a static relocation of type Type can be deferred and
 // handled at runtime as a pseudo relocation (for references to a module
 // local variable, which turned out to actually need to be imported from
 // another DLL) This returns the size the relocation is supposed to update,
 // in bits, or 0 if the relocation cannot be handled as a runtime pseudo
 // relocation.
-static int getRuntimePseudoRelocSize(uint16_t type) {
+static int getRuntimePseudoRelocSize(uint16_t type,
+                                     llvm::COFF::MachineTypes machine) {
   // Relocations that either contain an absolute address, or a plain
   // relative offset, since the runtime pseudo reloc implementation
   // adds 8/16/32/64 bit values to a memory address.
   //
   // Given a pseudo relocation entry,
   //
   // typedef struct {
   //   DWORD sym;
static int getRuntimePseudoRelocSize(uint16_t type,
   // the address of the IAT slot, and for relative addresses (IMAGE_REL*_REL32),
   // where the memory location originally contains the relative offset to the
   // IAT slot.
   //
   // This requires the target address to be writable, either directly out of
   // the image, or temporarily changed at runtime with VirtualProtect.
   // Since this only operates on direct address values, it doesn't work for
   // ARM/ARM64 relocations, other than the plain ADDR32/ADDR64 relocations.
-  switch (config->machine) {
+  switch (machine) {
   case AMD64:
     switch (type) {
     case IMAGE_REL_AMD64_ADDR64:
       return 64;
     case IMAGE_REL_AMD64_ADDR32:
     case IMAGE_REL_AMD64_REL32:
     case IMAGE_REL_AMD64_REL32_1:
     case IMAGE_REL_AMD64_REL32_2:

 // imported from another DLL).
 void SectionChunk::getRuntimePseudoRelocs(
     std::vector<RuntimePseudoReloc> &res) {
   for (const coff_relocation &rel : getRelocs()) {
     auto *target =
         dyn_cast_or_null<Defined>(file->getSymbol(rel.SymbolTableIndex));
     if (!target || !target->isRuntimePseudoReloc)
       continue;
-    int sizeInBits = getRuntimePseudoRelocSize(rel.Type);
+    int sizeInBits =
+        getRuntimePseudoRelocSize(rel.Type, file->ctx.config.machine);
     if (sizeInBits == 0) {
       error("unable to automatically import from " + target->getName() +
             " with relocation type " +
             file->getCOFFObj()->getRelocationTypeName(rel.Type) + " in " +
             toString(file));
       continue;
     }
     // sizeInBits is used to initialize the Flags field; currently no
return IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_READ |
          IMAGE_SCN_MEM_WRITE;
 }
 
 void StringChunk::writeTo(uint8_t *buf) const {
   memcpy(buf, str.data(), str.size());
   buf[str.size()] = '\0';
 }
 
-ImportThunkChunkX64::ImportThunkChunkX64(Defined *s) : ImportThunkChunk(s) {
+ImportThunkChunkX64::ImportThunkChunkX64(COFFLinkerContext &ctx, Defined *s)
+    : ImportThunkChunk(ctx, s) {
   // Intel Optimization Manual says that all branch targets
   // should be 16-byte aligned. MSVC linker does this too.
   setAlignment(16);
 }
 
 void ImportThunkChunkX64::writeTo(uint8_t *buf) const {
   memcpy(buf, importThunkX86, sizeof(importThunkX86));
   // The first two bytes is a JMP instruction. Fill its operand.
   write32le(buf + 2, impSymbol->getRVA() - rva - getSize());
 }
 
 void ImportThunkChunkX86::getBaserels(std::vector<Baserel> *res) {
-  res->emplace_back(getRVA() + 2);
+  res->emplace_back(getRVA() + 2, ctx.config.machine);
 }
 
 void ImportThunkChunkX86::writeTo(uint8_t *buf) const {
   memcpy(buf, importThunkX86, sizeof(importThunkX86));
   // The first two bytes is a JMP instruction. Fill its operand.
-  write32le(buf + 2,
-            impSymbol->getRVA() + config->imageBase);
+  write32le(buf + 2, impSymbol->getRVA() + ctx.config.imageBase);
 }
 
 void ImportThunkChunkARM::getBaserels(std::vector<Baserel> *res) {
   res->emplace_back(getRVA(), IMAGE_REL_BASED_ARM_MOV32T);
 }
 
 void ImportThunkChunkARM::writeTo(uint8_t *buf) const {
   memcpy(buf, importThunkARM, sizeof(importThunkARM));
   // Fix mov.w and mov.t operands.
-  applyMOV32T(buf, impSymbol->getRVA() + config->imageBase);
+  applyMOV32T(buf, impSymbol->getRVA() + ctx.config.imageBase);
 }
 
 void ImportThunkChunkARM64::writeTo(uint8_t *buf) const {
   int64_t off = impSymbol->getRVA() & 0xfff;
   memcpy(buf, importThunkARM64, sizeof(importThunkARM64));
   applyArm64Addr(buf, impSymbol->getRVA(), rva, 12);
   applyArm64Ldr(buf + 4, off);
 }
 
 // A Thumb2, PIC, non-interworking range extension thunk.
 const uint8_t armThunk[] = {
     0x40, 0xf2, 0x00, 0x0c, // P:  movw ip,:lower16:S - (P + (L1-P) + 4)
     0xc0, 0xf2, 0x00, 0x0c, //     movt ip,:upper16:S - (P + (L1-P) + 4)
     0xe7, 0x44,             // L1: add  pc, ip
 };
 
 size_t RangeExtensionThunkARM::getSize() const {
-  assert(config->machine == ARMNT);
+  assert(ctx.config.machine == ARMNT);
   return sizeof(armThunk);
 }
 
 void RangeExtensionThunkARM::writeTo(uint8_t *buf) const {
-  assert(config->machine == ARMNT);
+  assert(ctx.config.machine == ARMNT);
   uint64_t offset = target->getRVA() - rva - 12;
   memcpy(buf, armThunk, sizeof(armThunk));
   applyMOV32T(buf, uint32_t(offset));
 }
 
 // A position independent ARM64 adrp+add thunk, with a maximum range of
 // +/- 4 GB, which is enough for any PE-COFF.
 const uint8_t arm64Thunk[] = {
     0x10, 0x00, 0x00, 0x90, // adrp x16, Dest
     0x10, 0x02, 0x00, 0x91, // add  x16, x16, :lo12:Dest
     0x00, 0x02, 0x1f, 0xd6, // br   x16
 };
 
 size_t RangeExtensionThunkARM64::getSize() const {
-  assert(config->machine == ARM64);
+  assert(ctx.config.machine == ARM64);
   return sizeof(arm64Thunk);
 }
 
 void RangeExtensionThunkARM64::writeTo(uint8_t *buf) const {
-  assert(config->machine == ARM64);
+  assert(ctx.config.machine == ARM64);
   memcpy(buf, arm64Thunk, sizeof(arm64Thunk));
   applyArm64Addr(buf + 0, target->getRVA(), rva, 12);
   applyArm64Imm(buf + 4, target->getRVA() & 0xfff, 0);
 }
 
+LocalImportChunk::LocalImportChunk(COFFLinkerContext &c, Defined *s)
+    : sym(s), ctx(c) {
+  setAlignment(ctx.config.wordsize);
+}
+
 void LocalImportChunk::getBaserels(std::vector<Baserel> *res) {
-  res->emplace_back(getRVA());
+  res->emplace_back(getRVA(), ctx.config.machine);
 }
 
-size_t LocalImportChunk::getSize() const { return config->wordsize; }
+size_t LocalImportChunk::getSize() const { return ctx.config.wordsize; }
 
 void LocalImportChunk::writeTo(uint8_t *buf) const {
-  if (config->is64()) {
-    write64le(buf, sym->getRVA() + config->imageBase);
+  if (ctx.config.is64()) {
+    write64le(buf, sym->getRVA() + ctx.config.imageBase);
   } else {
-    write32le(buf, sym->getRVA() + config->imageBase);
+    write32le(buf, sym->getRVA() + ctx.config.imageBase);
   }
 }
 
 void RVATableChunk::writeTo(uint8_t *buf) const {
   ulittle32_t *begin = reinterpret_cast<ulittle32_t *>(buf);
   size_t cnt = 0;
   for (const ChunkAndOffset &co : syms)
     begin[cnt++] = co.inputChunk->getRVA() + co.offset;
for (Baserel *i = begin; i != end; ++i) {
     p += 2;
   }
 }
 
 void BaserelChunk::writeTo(uint8_t *buf) const {
   memcpy(buf, data.data(), data.size());
 }
 
-uint8_t Baserel::getDefaultType() {
-  switch (config->machine) {
+uint8_t Baserel::getDefaultType(llvm::COFF::MachineTypes machine) {
+  switch (machine) {
   case AMD64:
   case ARM64:
     return IMAGE_REL_BASED_DIR64;
   case I386:
   case ARMNT:
     return IMAGE_REL_BASED_HIGHLOW;
   default:
     llvm_unreachable("unknown machine type");
size_t MergeChunk::getSize() const {
   return builder.getSize();
 }
 
 void MergeChunk::writeTo(uint8_t *buf) const {
   builder.write(buf);
 }
 
 // MinGW specific.
-size_t AbsolutePointerChunk::getSize() const { return config->wordsize; }
+size_t AbsolutePointerChunk::getSize() const { return ctx.config.wordsize; }
 
 void AbsolutePointerChunk::writeTo(uint8_t *buf) const {
-  if (config->is64()) {
+  if (ctx.config.is64()) {
     write64le(buf, value);
   } else {
     write32le(buf, value);
   }
 }
 
 } // namespace coff
 } // namespace lld

lld/COFF/Config.h

enum class ICFLevel {
   Safe, // Safe ICF for all sections.
   All,  // Aggressive ICF for code, but safe ICF for data, similar to MSVC's
         // behavior.
 };
 
 // Global configuration.
 struct Configuration {
   enum ManifestKind { Default, SideBySide, Embed, No };
-  bool is64() { return machine == AMD64 || machine == ARM64; }
+  bool is64() const { return machine == AMD64 || machine == ARM64; }
 
   llvm::COFF::MachineTypes machine = IMAGE_FILE_MACHINE_UNKNOWN;
   size_t wordsize;
   bool verbose = false;
   WindowsSubsystem subsystem = llvm::COFF::IMAGE_SUBSYSTEM_UNKNOWN;
   Symbol *entry = nullptr;
   bool noEntry = false;
   std::string outputFile;
struct Configuration {
   bool swaprunNet = false;
   bool thinLTOEmitImportsFiles;
   bool thinLTOIndexOnly;
   bool autoImport = false;
   bool pseudoRelocs = false;
   bool stdcallFixup = false;
 };
 
-extern std::unique_ptr<Configuration> config;
-
 } // namespace coff
 } // namespace lld
 
 #endif

lld/COFF/DLL.h

 // IdataContents creates all chunks for the DLL import table.
 // You are supposed to call add() to add symbols and then
 // call create() to populate the chunk vectors.
 class IdataContents {
 public:
   void add(DefinedImportData *sym) { imports.push_back(sym); }
   bool empty() { return imports.empty(); }
 
-  void create();
+  void create(COFFLinkerContext &ctx);
 
   std::vector<DefinedImportData *> imports;
   std::vector<Chunk *> dirs;
   std::vector<Chunk *> lookups;
   std::vector<Chunk *> addresses;
   std::vector<Chunk *> hints;
   std::vector<Chunk *> dllNames;
 };
 
 // Windows-specific.
 // DelayLoadContents creates all chunks for the delay-load DLL import table.
 class DelayLoadContents {
 public:
+  DelayLoadContents(COFFLinkerContext &ctx) : ctx(ctx) {}
   void add(DefinedImportData *sym) { imports.push_back(sym); }
   bool empty() { return imports.empty(); }
-  void create(COFFLinkerContext &ctx, Defined *helper);
+  void create(Defined *helper);
   std::vector<Chunk *> getChunks();
   std::vector<Chunk *> getDataChunks();
   ArrayRef<Chunk *> getCodeChunks() { return thunks; }
 
   uint64_t getDirRVA() { return dirs[0]->getRVA(); }
   uint64_t getDirSize();
 
 private:
   Chunk *newThunkChunk(DefinedImportData *s, Chunk *tailMerge);
   Chunk *newTailMergeChunk(Chunk *dir);
 
   Defined *helper;
   std::vector<DefinedImportData *> imports;
   std::vector<Chunk *> dirs;
   std::vector<Chunk *> moduleHandles;
   std::vector<Chunk *> addresses;
   std::vector<Chunk *> names;
   std::vector<Chunk *> hintNames;
   std::vector<Chunk *> thunks;
   std::vector<Chunk *> dllNames;
+
+  COFFLinkerContext &ctx;
 };
 
 // Windows-specific.
 // EdataContents creates all chunks for the DLL export table.
 class EdataContents {
 public:
-  EdataContents();
+  EdataContents(COFFLinkerContext &ctx);
   std::vector<Chunk *> chunks;
 
   uint64_t getRVA() { return chunks[0]->getRVA(); }
   uint64_t getSize() {
     return chunks.back()->getRVA() + chunks.back()->getSize() - getRVA();
   }
+
+  COFFLinkerContext &ctx;
 };
 
 } // namespace coff
 } // namespace lld
 
 #endif

lld/COFF/DLL.cpp

 private:
   StringRef name;
   uint16_t hint;
 };
 
 // A chunk for the import descriptor table.
 class LookupChunk : public NonSectionChunk {
 public:
-  explicit LookupChunk(Chunk *c) : hintName(c) {
-    setAlignment(config->wordsize);
+  explicit LookupChunk(COFFLinkerContext &ctx, Chunk *c)
+      : hintName(c), ctx(ctx) {
+    setAlignment(ctx.config.wordsize);
   }
-  size_t getSize() const override { return config->wordsize; }
+  size_t getSize() const override { return ctx.config.wordsize; }
 
   void writeTo(uint8_t *buf) const override {
-    if (config->is64())
+    if (ctx.config.is64())
       write64le(buf, hintName->getRVA());
     else
       write32le(buf, hintName->getRVA());
   }
 
   Chunk *hintName;
+
+private:
+  COFFLinkerContext &ctx;
 };
 
 // A chunk for the import descriptor table.
 // This chunk represent import-by-ordinal symbols.
 // See Microsoft PE/COFF spec 7.1. Import Header for details.
 class OrdinalOnlyChunk : public NonSectionChunk {
 public:
-  explicit OrdinalOnlyChunk(uint16_t v) : ordinal(v) {
-    setAlignment(config->wordsize);
+  explicit OrdinalOnlyChunk(COFFLinkerContext &c, uint16_t v)
+      : ordinal(v), ctx(c) {
+    setAlignment(ctx.config.wordsize);
   }
-  size_t getSize() const override { return config->wordsize; }
+  size_t getSize() const override { return ctx.config.wordsize; }
 
   void writeTo(uint8_t *buf) const override {
     // An import-by-ordinal slot has MSB 1 to indicate that
     // this is import-by-ordinal (and not import-by-name).
-    if (config->is64()) {
+    if (ctx.config.is64()) {
       write64le(buf, (1ULL << 63) | ordinal);
     } else {
       write32le(buf, (1ULL << 31) | ordinal);
     }
   }
 
   uint16_t ordinal;
+
+private:
+  COFFLinkerContext &ctx;
 };
 
 // A chunk for the import descriptor table.
 class ImportDirectoryChunk : public NonSectionChunk {
 public:
   explicit ImportDirectoryChunk(Chunk *n) : dllName(n) {}
   size_t getSize() const override { return sizeof(ImportDirectoryTableEntry); }
 
void writeTo(uint8_t *buf) const override {
     memset(buf, 0, size);
   }
 
 private:
   size_t size;
 };
 
 static std::vector<std::vector<DefinedImportData *>>
-binImports(const std::vector<DefinedImportData *> &imports) {
+binImports(COFFLinkerContext &ctx,
+           const std::vector<DefinedImportData *> &imports) {
   // Group DLL-imported symbols by DLL name because that's how
   // symbols are laid out in the import descriptor table.
-  auto less = [](const std::string &a, const std::string &b) {
-    return config->dllOrder[a] < config->dllOrder[b];
+  auto less = [&ctx](const std::string &a, const std::string &b) {
+    return ctx.config.dllOrder[a] < ctx.config.dllOrder[b];
   };
-  std::map<std::string, std::vector<DefinedImportData *>,
-           bool(*)(const std::string &, const std::string &)> m(less);
+  std::map<std::string, std::vector<DefinedImportData *>, decltype(less)> m(
+      less);
   for (DefinedImportData *sym : imports)
     m[sym->getDLLName().lower()].push_back(sym);
 
   std::vector<std::vector<DefinedImportData *>> v;
   for (auto &kv : m) {
     // Sort symbols by name for each group.
     std::vector<DefinedImportData *> &syms = kv.second;
     std::sort(syms.begin(), syms.end(),
public:
   }
 
   Chunk *desc = nullptr;
   Defined *helper = nullptr;
 };
 
 class ThunkChunkX86 : public NonSectionChunk {
 public:
-  ThunkChunkX86(Defined *i, Chunk *tm) : imp(i), tailMerge(tm) {}
+  ThunkChunkX86(COFFLinkerContext &ctx, Defined *i, Chunk *tm)
+      : imp(i), tailMerge(tm), ctx(ctx) {}
 
   size_t getSize() const override { return sizeof(thunkX86); }
 
   void writeTo(uint8_t *buf) const override {
     memcpy(buf, thunkX86, sizeof(thunkX86));
-    write32le(buf + 1, imp->getRVA() + config->imageBase);
+    write32le(buf + 1, imp->getRVA() + ctx.config.imageBase);
     write32le(buf + 6, tailMerge->getRVA() - rva - 10);
   }
 
   void getBaserels(std::vector<Baserel> *res) override {
-    res->emplace_back(rva + 1);
+    res->emplace_back(rva + 1, ctx.config.machine);
   }
 
   Defined *imp = nullptr;
   Chunk *tailMerge = nullptr;
+
+private:
+  const COFFLinkerContext &ctx;
 };
 
 class TailMergeChunkX86 : public NonSectionChunk {
 public:
-  TailMergeChunkX86(Chunk *d, Defined *h) : desc(d), helper(h) {}
+  TailMergeChunkX86(COFFLinkerContext &ctx, Chunk *d, Defined *h)
+      : desc(d), helper(h), ctx(ctx) {}
 
   size_t getSize() const override { return sizeof(tailMergeX86); }
 
   void writeTo(uint8_t *buf) const override {
     memcpy(buf, tailMergeX86, sizeof(tailMergeX86));
-    write32le(buf + 4, desc->getRVA() + config->imageBase);
+    write32le(buf + 4, desc->getRVA() + ctx.config.imageBase);
     write32le(buf + 9, helper->getRVA() - rva - 13);
   }
 
   void getBaserels(std::vector<Baserel> *res) override {
-    res->emplace_back(rva + 4);
+    res->emplace_back(rva + 4, ctx.config.machine);
   }
 
   Chunk *desc = nullptr;
   Defined *helper = nullptr;
+
+private:
+  const COFFLinkerContext &ctx;
 };
 
 class ThunkChunkARM : public NonSectionChunk {
 public:
-  ThunkChunkARM(Defined *i, Chunk *tm) : imp(i), tailMerge(tm) {
+  ThunkChunkARM(COFFLinkerContext &ctx, Defined *i, Chunk *tm)
+      : imp(i), tailMerge(tm), ctx(ctx) {
     setAlignment(2);
   }
 
   size_t getSize() const override { return sizeof(thunkARM); }
 
   void writeTo(uint8_t *buf) const override {
     memcpy(buf, thunkARM, sizeof(thunkARM));
-    applyMOV32T(buf + 0, imp->getRVA() + config->imageBase);
+    applyMOV32T(buf + 0, imp->getRVA() + ctx.config.imageBase);
     applyBranch24T(buf + 8, tailMerge->getRVA() - rva - 12);
   }
 
   void getBaserels(std::vector<Baserel> *res) override {
     res->emplace_back(rva + 0, IMAGE_REL_BASED_ARM_MOV32T);
   }
 
   Defined *imp = nullptr;
   Chunk *tailMerge = nullptr;
+
+private:
+  const COFFLinkerContext &ctx;
 };
 
 class TailMergeChunkARM : public NonSectionChunk {
 public:
-  TailMergeChunkARM(Chunk *d, Defined *h) : desc(d), helper(h) {
+  TailMergeChunkARM(COFFLinkerContext &ctx, Chunk *d, Defined *h)
+      : desc(d), helper(h), ctx(ctx) {
     setAlignment(2);
   }
 
   size_t getSize() const override { return sizeof(tailMergeARM); }
 
   void writeTo(uint8_t *buf) const override {
     memcpy(buf, tailMergeARM, sizeof(tailMergeARM));
-    applyMOV32T(buf + 14, desc->getRVA() + config->imageBase);
+    applyMOV32T(buf + 14, desc->getRVA() + ctx.config.imageBase);
     applyBranch24T(buf + 22, helper->getRVA() - rva - 26);
   }
 
   void getBaserels(std::vector<Baserel> *res) override {
     res->emplace_back(rva + 14, IMAGE_REL_BASED_ARM_MOV32T);
   }
 
   Chunk *desc = nullptr;
   Defined *helper = nullptr;
+
+private:
+  const COFFLinkerContext &ctx;
 };
 
 class ThunkChunkARM64 : public NonSectionChunk {
 public:
   ThunkChunkARM64(Defined *i, Chunk *tm) : imp(i), tailMerge(tm) {
     setAlignment(4);
   }
 
public:
 
   Chunk *desc = nullptr;
   Defined *helper = nullptr;
 };
 
 // A chunk for the import descriptor table.
 class DelayAddressChunk : public NonSectionChunk {
 public:
-  explicit DelayAddressChunk(Chunk *c) : thunk(c) {
-    setAlignment(config->wordsize);
+  explicit DelayAddressChunk(COFFLinkerContext &ctx, Chunk *c)
+      : thunk(c), ctx(ctx) {
+    setAlignment(ctx.config.wordsize);
   }
-  size_t getSize() const override { return config->wordsize; }
+  size_t getSize() const override { return ctx.config.wordsize; }
 
   void writeTo(uint8_t *buf) const override {
-    if (config->is64()) {
-      write64le(buf, thunk->getRVA() + config->imageBase);
+    if (ctx.config.is64()) {
+      write64le(buf, thunk->getRVA() + ctx.config.imageBase);
     } else {
       uint32_t bit = 0;
       // Pointer to thumb code must have the LSB set, so adjust it.
-      if (config->machine == ARMNT)
+      if (ctx.config.machine == ARMNT)
         bit = 1;
-      write32le(buf, (thunk->getRVA() + config->imageBase) | bit);
+      write32le(buf, (thunk->getRVA() + ctx.config.imageBase) | bit);
     }
   }
 
   void getBaserels(std::vector<Baserel> *res) override {
-    res->emplace_back(rva);
+    res->emplace_back(rva, ctx.config.machine);
   }
 
   Chunk *thunk;
+
+private:
+  const COFFLinkerContext &ctx;
 };
 
 // Export table
 // Read Microsoft PE/COFF spec 5.3 for details.
 
 // A chunk for the export descriptor table.
 class ExportDirectoryChunk : public NonSectionChunk {
 public:
public:
   Chunk *dllName;
   Chunk *addressTab;
   Chunk *nameTab;
   Chunk *ordinalTab;
 };
 
 class AddressTableChunk : public NonSectionChunk {
 public:
-  explicit AddressTableChunk(size_t maxOrdinal) : size(maxOrdinal + 1) {}
+  explicit AddressTableChunk(COFFLinkerContext &ctx, size_t maxOrdinal)
+      : size(maxOrdinal + 1), ctx(ctx) {}
   size_t getSize() const override { return size * 4; }
 
   void writeTo(uint8_t *buf) const override {
     memset(buf, 0, getSize());
 
-    for (const Export &e : config->exports) {
+    for (const Export &e : ctx.config.exports) {
       uint8_t *p = buf + e.ordinal * 4;
       uint32_t bit = 0;
       // Pointer to thumb code must have the LSB set, so adjust it.
-      if (config->machine == ARMNT && !e.data)
+      if (ctx.config.machine == ARMNT && !e.data)
         bit = 1;
       if (e.forwardChunk) {
         write32le(p, e.forwardChunk->getRVA() | bit);
       } else {
         assert(cast<Defined>(e.sym)->getRVA() != 0 &&
                "Exported symbol unmapped");
         write32le(p, cast<Defined>(e.sym)->getRVA() | bit);
       }
     }
   }
 
 private:
   size_t size;
+  const COFFLinkerContext &ctx;
 };
 
 class NamePointersChunk : public NonSectionChunk {
 public:
   explicit NamePointersChunk(std::vector<Chunk *> &v) : chunks(v) {}
   size_t getSize() const override { return chunks.size() * 4; }
 
   void writeTo(uint8_t *buf) const override {
     for (Chunk *c : chunks) {
       write32le(buf, c->getRVA());
       buf += 4;
     }
   }
 
 private:
   std::vector<Chunk *> chunks;
 };
 
 class ExportOrdinalChunk : public NonSectionChunk {
 public:
-  explicit ExportOrdinalChunk(size_t i) : size(i) {}
+  explicit ExportOrdinalChunk(const COFFLinkerContext &ctx, size_t i)
+      : size(i), ctx(ctx) {}
   size_t getSize() const override { return size * 2; }
 
   void writeTo(uint8_t *buf) const override {
-    for (Export &e : config->exports) {
+    for (const Export &e : ctx.config.exports) {
       if (e.noname)
         continue;
       write16le(buf, e.ordinal);
       buf += 2;
     }
   }
 
 private:
   size_t size;
+  const COFFLinkerContext &ctx;
 };
 
 } // anonymous namespace
 
-void IdataContents::create() {
-  std::vector<std::vector<DefinedImportData *>> v = binImports(imports);
+void IdataContents::create(COFFLinkerContext &ctx) {
+  std::vector<std::vector<DefinedImportData *>> v = binImports(ctx, imports);
 
   // Create .idata contents for each DLL.
   for (std::vector<DefinedImportData *> &syms : v) {
     // Create lookup and address tables. If they have external names,
     // we need to create hintName chunks to store the names.
     // If they don't (if they are import-by-ordinals), we store only
     // ordinal values to the table.
     size_t base = lookups.size();
     for (DefinedImportData *s : syms) {
       uint16_t ord = s->getOrdinal();
       if (s->getExternalName().empty()) {
-        lookups.push_back(make<OrdinalOnlyChunk>(ord));
-        addresses.push_back(make<OrdinalOnlyChunk>(ord));
+        lookups.push_back(make<OrdinalOnlyChunk>(ctx, ord));
+        addresses.push_back(make<OrdinalOnlyChunk>(ctx, ord));
         continue;
       }
       auto *c = make<HintNameChunk>(s->getExternalName(), ord);
-      lookups.push_back(make<LookupChunk>(c));
-      addresses.push_back(make<LookupChunk>(c));
+      lookups.push_back(make<LookupChunk>(ctx, c));
+      addresses.push_back(make<LookupChunk>(ctx, c));
       hints.push_back(c);
     }
     // Terminate with null values.
-    lookups.push_back(make<NullChunk>(config->wordsize));
-    addresses.push_back(make<NullChunk>(config->wordsize));
+    lookups.push_back(make<NullChunk>(ctx.config.wordsize));
+    addresses.push_back(make<NullChunk>(ctx.config.wordsize));
 
     for (int i = 0, e = syms.size(); i < e; ++i)
       syms[i]->setLocation(addresses[base + i]);
 
     // Create the import table header.
     dllNames.push_back(make<StringChunk>(syms[0]->getDLLName()));
     auto *dir = make<ImportDirectoryChunk>(dllNames.back());
     dir->lookupTab = lookups[base];
std::vector<Chunk *> DelayLoadContents::getDataChunks() {
   v.insert(v.end(), addresses.begin(), addresses.end());
   return v;
 }
 
 uint64_t DelayLoadContents::getDirSize() {
   return dirs.size() * sizeof(delay_import_directory_table_entry);
 }
 
-void DelayLoadContents::create(COFFLinkerContext &ctx, Defined *h) {
+void DelayLoadContents::create(Defined *h) {
   helper = h;
-  std::vector<std::vector<DefinedImportData *>> v = binImports(imports);
+  std::vector<std::vector<DefinedImportData *>> v = binImports(ctx, imports);
 
   // Create .didat contents for each DLL.
   for (std::vector<DefinedImportData *> &syms : v) {
     // Create the delay import table header.
     dllNames.push_back(make<StringChunk>(syms[0]->getDLLName()));
     auto *dir = make<DelayDirectoryChunk>(dllNames.back());
 
     size_t base = addresses.size();
     Chunk *tm = newTailMergeChunk(dir);
     for (DefinedImportData *s : syms) {
       Chunk *t = newThunkChunk(s, tm);
-      auto *a = make<DelayAddressChunk>(t);
+      auto *a = make<DelayAddressChunk>(ctx, t);
       addresses.push_back(a);
       thunks.push_back(t);
       StringRef extName = s->getExternalName();
       if (extName.empty()) {
-        names.push_back(make<OrdinalOnlyChunk>(s->getOrdinal()));
+        names.push_back(make<OrdinalOnlyChunk>(ctx, s->getOrdinal()));
       } else {
         auto *c = make<HintNameChunk>(extName, 0);
-        names.push_back(make<LookupChunk>(c));
+        names.push_back(make<LookupChunk>(ctx, c));
         hintNames.push_back(c);
         // Add a syntentic symbol for this load thunk, using the "__imp_load"
         // prefix, in case this thunk needs to be added to the list of valid
         // call targets for Control Flow Guard.
         StringRef symName = saver().save("__imp_load_" + extName);
         s->loadThunkSym =
             cast<DefinedSynthetic>(ctx.symtab.addSynthetic(symName, t));
       }
for (std::vector<DefinedImportData *> &syms : v) {
     dir->nameTab = names[base];
     dirs.push_back(dir);
   }
   // Add null terminator.
   dirs.push_back(make<NullChunk>(sizeof(delay_import_directory_table_entry)));
 }
 
 Chunk *DelayLoadContents::newTailMergeChunk(Chunk *dir) {
-  switch (config->machine) {
+  switch (ctx.config.machine) {
   case AMD64:
     return make<TailMergeChunkX64>(dir, helper);
   case I386:
-    return make<TailMergeChunkX86>(dir, helper);
+    return make<TailMergeChunkX86>(ctx, dir, helper);
   case ARMNT:
-    return make<TailMergeChunkARM>(dir, helper);
+    return make<TailMergeChunkARM>(ctx, dir, helper);
   case ARM64:
     return make<TailMergeChunkARM64>(dir, helper);
   default:
     llvm_unreachable("unsupported machine type");
   }
 }
 
 Chunk *DelayLoadContents::newThunkChunk(DefinedImportData *s,
                                         Chunk *tailMerge) {
-  switch (config->machine) {
+  switch (ctx.config.machine) {
   case AMD64:
     return make<ThunkChunkX64>(s, tailMerge);
   case I386:
-    return make<ThunkChunkX86>(s, tailMerge);
+    return make<ThunkChunkX86>(ctx, s, tailMerge);
   case ARMNT:
-    return make<ThunkChunkARM>(s, tailMerge);
+    return make<ThunkChunkARM>(ctx, s, tailMerge);
   case ARM64:
     return make<ThunkChunkARM64>(s, tailMerge);
   default:
     llvm_unreachable("unsupported machine type");
   }
 }
 
-EdataContents::EdataContents() {
+EdataContents::EdataContents(COFFLinkerContext &ctx) : ctx(ctx) {
   uint16_t maxOrdinal = 0;
-  for (Export &e : config->exports)
+  for (Export &e : ctx.config.exports)
     maxOrdinal = std::max(maxOrdinal, e.ordinal);
 
-  auto *dllName = make<StringChunk>(sys::path::filename(config->outputFile));
-  auto *addressTab = make<AddressTableChunk>(maxOrdinal);
+  auto *dllName = make<StringChunk>(sys::path::filename(ctx.config.outputFile));
+  auto *addressTab = make<AddressTableChunk>(ctx, maxOrdinal);
   std::vector<Chunk *> names;
-  for (Export &e : config->exports)
+  for (Export &e : ctx.config.exports)
     if (!e.noname)
       names.push_back(make<StringChunk>(e.exportName));
 
   std::vector<Chunk *> forwards;
-  for (Export &e : config->exports) {
+  for (Export &e : ctx.config.exports) {
     if (e.forwardTo.empty())
       continue;
     e.forwardChunk = make<StringChunk>(e.forwardTo);
     forwards.push_back(e.forwardChunk);
   }
 
   auto *nameTab = make<NamePointersChunk>(names);
-  auto *ordinalTab = make<ExportOrdinalChunk>(names.size());
+  auto *ordinalTab = make<ExportOrdinalChunk>(ctx, names.size());
   auto *dir = make<ExportDirectoryChunk>(maxOrdinal, names.size(), dllName,
                                          addressTab, nameTab, ordinalTab);
   chunks.push_back(dir);
   chunks.push_back(dllName);
   chunks.push_back(addressTab);
   chunks.push_back(nameTab);
   chunks.push_back(ordinalTab);
   chunks.insert(chunks.end(), names.begin(), names.end());
   chunks.insert(chunks.end(), forwards.begin(), forwards.end());
 }
 
 } // namespace coff
 } // namespace lld

lld/COFF/DebugTypes.cpp

for (const TiReference &ref : typeRefs) {
     unsigned byteSize = ref.Count * sizeof(TypeIndex);
     if (contents.size() < ref.Offset + byteSize)
       fatal("symbol record too short");
 
     MutableArrayRef<TypeIndex> indices(
         reinterpret_cast<TypeIndex *>(contents.data() + ref.Offset), ref.Count);
     for (TypeIndex &ti : indices) {
       if (!remapTypeIndex(ti, ref.Kind)) {
-        if (config->verbose) {
+        if (ctx.config.verbose) {
           uint16_t kind =
               reinterpret_cast<const RecordPrefix *>(rec.data())->RecordKind;
           StringRef fname = file ? file->getName() : "<unknown PDB>";
           log("failed to remap type index in record of kind 0x" +
               utohexstr(kind) + " in " + fname + " with bad " +
               (ref.Kind == TiRefKind::IndexRef ? "item" : "type") +
               " index 0x" + utohexstr(ti.getIndex()));
         }
getHashesFromDebugH(ArrayRef<uint8_t> debugH) {
   assert(canUseDebugH(debugH));
   debugH = debugH.drop_front(sizeof(object::debug_h_header));
   uint32_t count = debugH.size() / sizeof(GloballyHashedType);
   return {reinterpret_cast<const GloballyHashedType *>(debugH.data()), count};
 }
 
 // Merge .debug$T for a generic object file.
 Error TpiSource::mergeDebugT(TypeMerger *m) {
-  assert(!config->debugGHashes &&
+  assert(!ctx.config.debugGHashes &&
          "use remapTpiWithGHashes when ghash is enabled");
 
   CVTypeArray types;
   BinaryStreamReader reader(file->debugTypes, support::little);
   cantFail(reader.readArray(types, reader.getLength()));
 
   // When dealing with PCH.OBJ, some indices were already merged.
   unsigned nbHeadIndices = indexMapStorage.size();
 
   if (auto err = mergeTypeAndIdRecords(
           m->idTable, m->typeTable, indexMapStorage, types, file->pchSignature))
     fatal("codeview::mergeTypeAndIdRecords failed: " +
           toString(std::move(err)));
 
   // In an object, there is only one mapping for both types and items.
   tpiMap = indexMapStorage;
   ipiMap = indexMapStorage;
 
-  if (config->showSummary) {
+  if (ctx.config.showSummary) {
     nbTypeRecords = indexMapStorage.size() - nbHeadIndices;
     nbTypeRecordsBytes = reader.getLength();
     // Count how many times we saw each type record in our input. This
     // calculation requires a second pass over the type records to classify each
     // record as a type or index. This is slow, but this code executes when
     // collecting statistics.
     m->tpiCounts.resize(m->getTypeTable().size());
     m->ipiCounts.resize(m->getIDTable().size());
if (ctx.config.showSummary) {
     }
   }
 
   return Error::success();
 }
 
 // Merge types from a type server PDB.
 Error TypeServerSource::mergeDebugT(TypeMerger *m) {
-  assert(!config->debugGHashes &&
+  assert(!ctx.config.debugGHashes &&
          "use remapTpiWithGHashes when ghash is enabled");
 
   pdb::PDBFile &pdbFile = pdbInputFile->session->getPDBFile();
   Expected<pdb::TpiStream &> expectedTpi = pdbFile.getPDBTpiStream();
   if (auto e = expectedTpi.takeError())
     fatal("Type server does not have TPI stream: " + toString(std::move(e)));
   pdb::TpiStream *maybeIpi = nullptr;
   if (pdbFile.hasPDBIpiStream()) {
Error TypeServerSource::mergeDebugT(TypeMerger *m) {
   // Merge IPI.
   if (maybeIpi) {
     if (auto err = mergeIdRecords(m->idTable, tpiMap, ipiSrc->indexMapStorage,
                                   maybeIpi->typeArray()))
       fatal("codeview::mergeIdRecords failed: " + toString(std::move(err)));
     ipiMap = ipiSrc->indexMapStorage;
   }
 
-  if (config->showSummary) {
+  if (ctx.config.showSummary) {
     nbTypeRecords = tpiMap.size() + ipiMap.size();
     nbTypeRecordsBytes =
         expectedTpi->typeArray().getUnderlyingStream().getLength() +
         (maybeIpi ? maybeIpi->typeArray().getUnderlyingStream().getLength()
                   : 0);
 
     // Count how many times we saw each type record in our input. If a
     // destination type index is present in the source to destination type index
void TpiSource::mergeUniqueTypeRecords(ArrayRef<uint8_t> typeRecords,
   assert(nextUniqueIndex == uniqueTypes.end() &&
          "failed to merge all desired records");
   assert(uniqueTypes.size() ==
              mergedTpi.recSizes.size() + mergedIpi.recSizes.size() &&
          "missing desired record");
 }
 
 void TpiSource::remapTpiWithGHashes(GHashState *g) {
-  assert(config->debugGHashes && "ghashes must be enabled");
+  assert(ctx.config.debugGHashes && "ghashes must be enabled");
   fillMapFromGHashes(g);
   tpiMap = indexMapStorage;
   ipiMap = indexMapStorage;
   mergeUniqueTypeRecords(file->debugTypes);
   // TODO: Free all unneeded ghash resources now that we have a full index map.
 
-  if (config->showSummary) {
+  if (ctx.config.showSummary) {
     nbTypeRecords = ghashes.size();
     nbTypeRecordsBytes = file->debugTypes.size();
   }
 }
 
 // PDBs do not actually store global hashes, so when merging a type server
 // PDB we have to synthesize global hashes.  To do this, we first synthesize
 // global hashes for the TPI stream, since it is independent, then we
static ArrayRef<uint8_t> typeArrayToBytes(const CVTypeArray &types) {
   BinaryStreamRef stream = types.getUnderlyingStream();
   ArrayRef<uint8_t> debugTypes;
   checkError(stream.readBytes(0, stream.getLength(), debugTypes));
   return debugTypes;
 }
 
 // Merge types from a type server PDB.
 void TypeServerSource::remapTpiWithGHashes(GHashState *g) {
-  assert(config->debugGHashes && "ghashes must be enabled");
+  assert(ctx.config.debugGHashes && "ghashes must be enabled");
 
   // IPI merging depends on TPI, so do TPI first, then do IPI.  No need to
   // propagate errors, those should've been handled during ghash loading.
   pdb::PDBFile &pdbFile = pdbInputFile->session->getPDBFile();
   pdb::TpiStream &tpi = check(pdbFile.getPDBTpiStream());
   fillMapFromGHashes(g);
   tpiMap = indexMapStorage;
   mergeUniqueTypeRecords(typeArrayToBytes(tpi.typeArray()));
   if (pdbFile.hasPDBIpiStream()) {
     pdb::TpiStream &ipi = check(pdbFile.getPDBIpiStream());
     ipiSrc->indexMapStorage.resize(ipiSrc->ghashes.size());
     ipiSrc->fillMapFromGHashes(g);
     ipiMap = ipiSrc->indexMapStorage;
     ipiSrc->tpiMap = tpiMap;
     ipiSrc->ipiMap = ipiMap;
     ipiSrc->mergeUniqueTypeRecords(typeArrayToBytes(ipi.typeArray()));
 
-    if (config->showSummary) {
+    if (ctx.config.showSummary) {
       nbTypeRecords = ipiSrc->ghashes.size();
       nbTypeRecordsBytes = ipi.typeArray().getUnderlyingStream().getLength();
     }
   }
 
-  if (config->showSummary) {
+  if (ctx.config.showSummary) {
     nbTypeRecords += ghashes.size();
     nbTypeRecordsBytes += tpi.typeArray().getUnderlyingStream().getLength();
   }
 }
 
 void UseTypeServerSource::remapTpiWithGHashes(GHashState *g) {
   // No remapping to do with /Zi objects. Simply use the index map from the type
   // server. Errors should have been reported earlier. Symbols from this object
if (Error e = mergeInPrecompHeaderObj()) {
     return;
   }
 
   tpiMap = indexMapStorage;
   ipiMap = indexMapStorage;
   mergeUniqueTypeRecords(file->debugTypes,
                          TypeIndex(precompDependency.getStartTypeIndex() +
                                    precompDependency.getTypesCount()));
-  if (config->showSummary) {
+  if (ctx.config.showSummary) {
     nbTypeRecords = ghashes.size();
     nbTypeRecordsBytes = file->debugTypes.size();
   }
 }
 
 namespace {
 /// A concurrent hash table for global type hashing. It is based on this paper:
 /// Concurrent Hash Tables: Fast and General(?)!

lld/COFF/Driver.h

 //===- Driver.h -------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_DRIVER_H
 #define LLD_COFF_DRIVER_H
 
-#include "COFFLinkerContext.h"
 #include "Config.h"
 #include "SymbolTable.h"
 #include "lld/Common/LLVM.h"
 #include "lld/Common/Reproduce.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/TarWriter.h"
 #include <memory>
 #include <set>
 #include <vector>
 
 namespace lld {
 namespace coff {
 
-extern std::unique_ptr<class LinkerDriver> driver;
-
 using llvm::COFF::MachineTypes;
 using llvm::COFF::WindowsSubsystem;
 using llvm::Optional;
 
 class COFFOptTable : public llvm::opt::OptTable {
 public:
   COFFOptTable();
 };
 
-// Constructing the option table is expensive. Use a global table to avoid doing
-// it more than once.
-extern COFFOptTable optTable;
-
 // The result of parsing the .drective section. The /export: and /include:
 // options are handled separately because they reference symbols, and the number
 // of symbols can be quite large. The LLVM Option library will perform at least
 // one memory allocation per argument, and that is prohibitively slow for
 // parsing directives.
 struct ParsedDirectives {
   std::vector<StringRef> exports;
   std::vector<StringRef> includes;
   llvm::opt::InputArgList args;
 };
 
 class ArgParser {
 public:
+  ArgParser(COFFLinkerContext &ctx);
+
   // Parses command line options.
   llvm::opt::InputArgList parse(llvm::ArrayRef<const char *> args);
 
   // Tokenizes a given string and then parses as command line options.
   llvm::opt::InputArgList parse(StringRef s) { return parse(tokenize(s)); }
 
   // Tokenizes a given string and then parses as command line options in
   // .drectve section. /EXPORT options are returned in second element
   // to be processed in fastpath.
   ParsedDirectives parseDirectives(StringRef s);
 
 private:
   // Concatenate LINK environment variable.
   void addLINK(SmallVector<const char *, 256> &argv);
 
   std::vector<const char *> tokenize(StringRef s);
+
+  COFFLinkerContext &ctx;
 };
 
 class LinkerDriver {
 public:
-  LinkerDriver(COFFLinkerContext &c) : ctx(c) {}
+  LinkerDriver(COFFLinkerContext &ctx) : ctx(ctx) {}
 
   void linkerMain(llvm::ArrayRef<const char *> args);
 
   // Used by the resolver to parse .drectve section contents.
   void parseDirectives(InputFile *file);
 
   // Used by ArchiveFile to enqueue members.
   void enqueueArchiveMember(const Archive::Child &c, const Archive::Symbol &sym,
private:
   Optional<StringRef> findFile(StringRef filename);
   Optional<StringRef> findLib(StringRef filename);
   StringRef doFindFile(StringRef filename);
   StringRef doFindLib(StringRef filename);
   StringRef doFindLibMinGW(StringRef filename);
 
   bool findUnderscoreMangle(StringRef sym);
 
+  // Symbol names are mangled by prepending "_" on x86.
+  StringRef mangle(StringRef sym);
+
+  uint64_t getDefaultImageBase();
+
+  bool isDecorated(StringRef sym);
+
+  std::string getMapFile(const llvm::opt::InputArgList &args,
+                         llvm::opt::OptSpecifier os,
+                         llvm::opt::OptSpecifier osFile);
+
+  std::string getImplibPath();
+
+  // The import name is calculated as follows:
+  //
+  //        | LIBRARY w/ ext |   LIBRARY w/o ext   | no LIBRARY
+  //   -----+----------------+---------------------+------------------
+  //   LINK | {value}        | {value}.{.dll/.exe} | {output name}
+  //    LIB | {value}        | {value}.dll         | {output name}.dll
+  //
+  std::string getImportName(bool asLib);
+
+  void createImportLibrary(bool asLib);
+
+  void parseModuleDefs(StringRef path);
+
+  // Parse an /order file. If an option is given, the linker places COMDAT
+  // sections int he same order as their names appear in the given file.
+  void parseOrderFile(StringRef arg);
+
+  void parseCallGraphFile(StringRef path);
+
+  void parsePDBAltPath();
+
   // Parses LIB environment which contains a list of search paths.
   void addLibSearchPaths();
 
   // Library search path. The first element is always "" (current directory).
   std::vector<StringRef> searchPaths;
 
   // Convert resource files and potentially merge input resource object
   // trees into one resource tree.
private:
 
   std::list<std::function<void()>> taskQueue;
   std::vector<StringRef> filePaths;
   std::vector<MemoryBufferRef> resources;
 
   llvm::StringSet<> directivesExports;
 
   COFFLinkerContext &ctx;
-};
 
   // Functions below this line are defined in DriverUtils.cpp.
 
-void printHelp(const char *argv0);
-
   // Parses a string in the form of "<integer>[,<integer>]".
   void parseNumbers(StringRef arg, uint64_t *addr, uint64_t *size = nullptr);
 
   void parseGuard(StringRef arg);
 
   // Parses a string in the form of "<integer>[.<integer>]".
   // Minor's default value is 0.
   void parseVersion(StringRef arg, uint32_t *major, uint32_t *minor);
 
   // Parses a string in the form of "<subsystem>[,<integer>[.<integer>]]".
   void parseSubsystem(StringRef arg, WindowsSubsystem *sys, uint32_t *major,
                       uint32_t *minor, bool *gotVersion = nullptr);
 
   void parseAlternateName(StringRef);
   void parseMerge(StringRef);
-void parsePDBPageSize(StringRef);
   void parseSection(StringRef);
   void parseAligncomm(StringRef);
+  void parsePDBPageSize(StringRef);
 
   // Parses a string in the form of "[:<integer>]"
-void parseFunctionPadMin(llvm::opt::Arg *a, llvm::COFF::MachineTypes machine);
+  void parseFunctionPadMin(llvm::opt::Arg *a);
 
   // Parses a string in the form of "EMBED[,=<integer>]|NO".
   void parseManifest(StringRef arg);
 
   // Parses a string in the form of "level=<string>|uiAccess=<string>"
   void parseManifestUAC(StringRef arg);
 
   // Parses a string in the form of "cd|net[,(cd|net)]*"
   void parseSwaprun(StringRef arg);
 
   // Create a resource file containing a manifest XML.
   std::unique_ptr<MemoryBuffer> createManifestRes();
   void createSideBySideManifest();
+  std::string createDefaultXml();
+  std::string createManifestXmlWithInternalMt(StringRef defaultXml);
+  std::string createManifestXmlWithExternalMt(StringRef defaultXml);
+  std::string createManifestXml();
+
+  std::unique_ptr<llvm::WritableMemoryBuffer>
+  createMemoryBufferForManifestRes(size_t manifestRes);
 
   // Used for dllexported symbols.
   Export parseExport(StringRef arg);
   void fixupExports();
   void assignExportOrdinals();
 
   // Parses a string in the form of "key=value" and check
   // if value matches previous values for the key.
   // This feature used in the directive section to reject
   // incompatible objects.
   void checkFailIfMismatch(StringRef arg, InputFile *source);
 
   // Convert Windows resource files (.res files) to a .obj file.
   MemoryBufferRef convertResToCOFF(ArrayRef<MemoryBufferRef> mbs,
                                    ArrayRef<ObjFile *> objs);
 
+  void printHelp(const char *argv0);
+};
+
 // Create enum with OPT_xxx values for each option in Options.td
 enum {
   OPT_INVALID = 0,
 #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
 #include "Options.inc"
 #undef OPTION
 };
 
 } // namespace coff
 } // namespace lld
 
 #endif

lld/COFF/Driver.cpp

 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::COFF;
 using namespace llvm::sys;
 
 namespace lld {
 namespace coff {
 
-std::unique_ptr<Configuration> config;
-std::unique_ptr<LinkerDriver> driver;
-
 bool link(ArrayRef<const char *> args, llvm::raw_ostream &stdoutOS,
           llvm::raw_ostream &stderrOS, bool exitEarly, bool disableOutput) {
   // This driver-specific context will be freed later by lldMain().
   auto *ctx = new COFFLinkerContext;
 
   ctx->e.initialize(stdoutOS, stderrOS, exitEarly, disableOutput);
   ctx->e.logName = args::getFilenameWithoutExe(args[0]);
   ctx->e.errorLimitExceededMsg = "too many errors emitted, stopping now"
                                  " (use /errorlimit:0 to see all errors)";
 
-  config = std::make_unique<Configuration>();
-  driver = std::make_unique<LinkerDriver>(*ctx);
-
-  driver->linkerMain(args);
+  ctx->driver.linkerMain(args);
 
   return errorCount() == 0;
 }
 
 // Parse options of the form "old;new".
 static std::pair<StringRef, StringRef> getOldNewOptions(opt::InputArgList &args,
                                                         unsigned id) {
   auto *arg = args.getLastArg(id);
   if (!arg)
     return {"", ""};
 
   StringRef s = arg->getValue();
   std::pair<StringRef, StringRef> ret = s.split(';');
   if (ret.second.empty())
     error(arg->getSpelling() + " expects 'old;new' format, but got " + s);
   return ret;
 }
 
 // Drop directory components and replace extension with
 // ".exe", ".dll" or ".sys".
-static std::string getOutputPath(StringRef path) {
+static std::string getOutputPath(StringRef path, bool isDll, bool isDriver) {
   StringRef ext = ".exe";
-  if (config->dll)
+  if (isDll)
     ext = ".dll";
-  else if (config->driver)
+  else if (isDriver)
     ext = ".sys";
 
   return (sys::path::stem(path) + ext).str();
 }
 
 // Returns true if S matches /crtend.?\.o$/.
 static bool isCrtend(StringRef s) {
   if (!s.endswith(".o"))
auto mbOrErr = MemoryBuffer::getFile(path, /*IsText=*/false,
                                          /*RequiresNullTerminator=*/false);
     if (!mbOrErr)
       return MBErrPair{nullptr, mbOrErr.getError()};
     return MBErrPair{std::move(*mbOrErr), std::error_code()};
   });
 }
 
 // Symbol names are mangled by prepending "_" on x86.
-static StringRef mangle(StringRef sym) {
-  assert(config->machine != IMAGE_FILE_MACHINE_UNKNOWN);
-  if (config->machine == I386)
+StringRef LinkerDriver::mangle(StringRef sym) {
+  assert(ctx.config.machine != IMAGE_FILE_MACHINE_UNKNOWN);
+  if (ctx.config.machine == I386)
     return saver().save("_" + sym);
   return sym;
 }
 
 bool LinkerDriver::findUnderscoreMangle(StringRef sym) {
   Symbol *s = ctx.symtab.findMangle(mangle(sym));
   return s && !isa<Undefined>(s);
 }
 
 MemoryBufferRef LinkerDriver::takeBuffer(std::unique_ptr<MemoryBuffer> mb) {
   MemoryBufferRef mbref = *mb;
   make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take ownership
 
-  if (driver->tar)
-    driver->tar->append(relativeToRoot(mbref.getBufferIdentifier()),
+  if (ctx.driver.tar)
+    ctx.driver.tar->append(relativeToRoot(mbref.getBufferIdentifier()),
                            mbref.getBuffer());
   return mbref;
 }
 
 void LinkerDriver::addBuffer(std::unique_ptr<MemoryBuffer> mb,
                              bool wholeArchive, bool lazy) {
   StringRef filename = mb->getBufferIdentifier();
 
   MemoryBufferRef mbref = takeBuffer(std::move(mb));
case file_magic::coff_import_library:
     break;
   case file_magic::pdb:
     ctx.symtab.addFile(make<PDBInputFile>(ctx, mbref));
     break;
   case file_magic::coff_cl_gl_object:
     error(filename + ": is not a native COFF file. Recompile without /GL");
     break;
   case file_magic::pecoff_executable:
-    if (config->mingw) {
+    if (ctx.config.mingw) {
       ctx.symtab.addFile(make<DLLFile>(ctx, mbref));
       break;
     }
     if (filename.endswith_insensitive(".dll")) {
       error(filename + ": bad file type. Did you specify a DLL instead of an "
                        "import library?");
       break;
     }
if (mbOrErr.second) {
       std::string msg =
           "could not open '" + pathStr + "': " + mbOrErr.second.message();
       // Check if the filename is a typo for an option flag. OptTable thinks
       // that all args that are not known options and that start with / are
       // filenames, but e.g. `/nodefaultlibs` is more likely a typo for
       // the option `/nodefaultlib` than a reference to a file in the root
       // directory.
       std::string nearest;
-      if (optTable.findNearest(pathStr, nearest) > 1)
+      if (ctx.optTable.findNearest(pathStr, nearest) > 1)
         error(msg);
       else
         error(msg + "; did you mean '" + nearest + "'");
     } else
-      driver->addBuffer(std::move(mbOrErr.first), wholeArchive, lazy);
+      ctx.driver.addBuffer(std::move(mbOrErr.first), wholeArchive, lazy);
   });
 }
 
 void LinkerDriver::addArchiveBuffer(MemoryBufferRef mb, StringRef symName,
                                     StringRef parentName,
                                     uint64_t offsetInArchive) {
   file_magic magic = identify_magic(mb.getBuffer());
   if (magic == file_magic::coff_import_library) {

 }
 
 void LinkerDriver::enqueueArchiveMember(const Archive::Child &c,
                                         const Archive::Symbol &sym,
                                         StringRef parentName) {
 
   auto reportBufferError = [=](Error &&e, StringRef childName) {
     fatal("could not get the buffer for the member defining symbol " +
-          toCOFFString(sym) + ": " + parentName + "(" + childName + "): " +
-          toString(std::move(e)));
+          ctx.toCOFFString(sym) + ": " + parentName + "(" + childName +
+          "): " + toString(std::move(e)));
   };
 
   if (!c.getParent()->isThin()) {
     uint64_t offsetInArchive = c.getChildOffset();
     Expected<MemoryBufferRef> mbOrErr = c.getMemoryBufferRef();
     if (!mbOrErr)
       reportBufferError(mbOrErr.takeError(), check(c.getFullName()));
     MemoryBufferRef mb = mbOrErr.get();
     enqueueTask([=]() {
-      driver->addArchiveBuffer(mb, toCOFFString(sym), parentName,
+      ctx.driver.addArchiveBuffer(mb, ctx.toCOFFString(sym), parentName,
                                   offsetInArchive);
     });
     return;
   }
 
-  std::string childName = CHECK(
-      c.getFullName(),
+  std::string childName =
+      CHECK(c.getFullName(),
             "could not get the filename for the member defining symbol " +
-      toCOFFString(sym));
+                ctx.toCOFFString(sym));
   auto future = std::make_shared<std::future<MBErrPair>>(
       createFutureForFile(childName));
   enqueueTask([=]() {
     auto mbOrErr = future->get();
     if (mbOrErr.second)
       reportBufferError(errorCodeToError(mbOrErr.second), childName);
     // Pass empty string as archive name so that the original filename is
     // used as the buffer identifier.
-    driver->addArchiveBuffer(takeBuffer(std::move(mbOrErr.first)),
-                             toCOFFString(sym), "", /*OffsetInArchive=*/0);
+    ctx.driver.addArchiveBuffer(takeBuffer(std::move(mbOrErr.first)),
+                                ctx.toCOFFString(sym), "",
+                                /*OffsetInArchive=*/0);
   });
 }
 
-static bool isDecorated(StringRef sym) {
+bool LinkerDriver::isDecorated(StringRef sym) {
   return sym.startswith("@") || sym.contains("@@") || sym.startswith("?") ||
-         (!config->mingw && sym.contains('@'));
+         (!ctx.config.mingw && sym.contains('@'));
 }
 
 // Parses .drectve section contents and returns a list of files
 // specified by /defaultlib.
 void LinkerDriver::parseDirectives(InputFile *file) {
   StringRef s = file->getDirectives();
   if (s.empty())
     return;
 
   log("Directives: " + toString(file) + ": " + s);
 
-  ArgParser parser;
+  ArgParser parser(ctx);
   // .drectve is always tokenized using Windows shell rules.
   // /EXPORT: option can appear too many times, processing in fastpath.
   ParsedDirectives directives = parser.parseDirectives(s);
 
   for (StringRef e : directives.exports) {
     // If a common header file contains dllexported function
     // declarations, many object files may end up with having the
     // same /EXPORT options. In order to save cost of parsing them,
     // we dedup them first.
     if (!directivesExports.insert(e).second)
       continue;
 
     Export exp = parseExport(e);
-    if (config->machine == I386 && config->mingw) {
+    if (ctx.config.machine == I386 && ctx.config.mingw) {
       if (!isDecorated(exp.name))
         exp.name = saver().save("_" + exp.name);
       if (!exp.extName.empty() && !isDecorated(exp.extName))
         exp.extName = saver().save("_" + exp.extName);
     }
     exp.directives = true;
-    config->exports.push_back(exp);
+    ctx.config.exports.push_back(exp);
   }
 
   // Handle /include: in bulk.
   for (StringRef inc : directives.includes)
     addUndefined(inc);
 
   // https://docs.microsoft.com/en-us/cpp/preprocessor/comment-c-cpp?view=msvc-160
   for (auto *arg : directives.args) {
     switch (arg->getOption().getID()) {
     case OPT_aligncomm:
       parseAligncomm(arg->getValue());
       break;
     case OPT_alternatename:
       parseAlternateName(arg->getValue());
       break;
     case OPT_defaultlib:
       if (Optional<StringRef> path = findLib(arg->getValue()))
         enqueuePath(*path, false, false);
       break;
     case OPT_entry:
-      config->entry = addUndefined(mangle(arg->getValue()));
+      ctx.config.entry = addUndefined(mangle(arg->getValue()));
       break;
     case OPT_failifmismatch:
       checkFailIfMismatch(arg->getValue(), file);
       break;
     case OPT_incl:
       addUndefined(arg->getValue());
       break;
     case OPT_manifestdependency:
-      config->manifestDependencies.insert(arg->getValue());
+      ctx.config.manifestDependencies.insert(arg->getValue());
       break;
     case OPT_merge:
       parseMerge(arg->getValue());
       break;
     case OPT_nodefaultlib:
-      config->noDefaultLibs.insert(doFindLib(arg->getValue()).lower());
+      ctx.config.noDefaultLibs.insert(doFindLib(arg->getValue()).lower());
       break;
     case OPT_section:
       parseSection(arg->getValue());
       break;
     case OPT_stack:
-      parseNumbers(arg->getValue(), &config->stackReserve,
-                   &config->stackCommit);
+      parseNumbers(arg->getValue(), &ctx.config.stackReserve,
+                   &ctx.config.stackCommit);
       break;
     case OPT_subsystem: {
       bool gotVersion = false;
-      parseSubsystem(arg->getValue(), &config->subsystem,
-                     &config->majorSubsystemVersion,
-                     &config->minorSubsystemVersion, &gotVersion);
+      parseSubsystem(arg->getValue(), &ctx.config.subsystem,
+                     &ctx.config.majorSubsystemVersion,
+                     &ctx.config.minorSubsystemVersion, &gotVersion);
       if (gotVersion) {
-        config->majorOSVersion = config->majorSubsystemVersion;
-        config->minorOSVersion = config->minorSubsystemVersion;
+        ctx.config.majorOSVersion = ctx.config.majorSubsystemVersion;
+        ctx.config.minorOSVersion = ctx.config.minorSubsystemVersion;
       }
       break;
     }
     // Only add flags here that link.exe accepts in
     // `#pragma comment(linker, "/flag")`-generated sections.
     case OPT_editandcontinue:
     case OPT_guardsym:
     case OPT_throwingnew:

 StringRef LinkerDriver::doFindLib(StringRef filename) {
   // Add ".lib" to Filename if that has no file extension.
   bool hasExt = filename.contains('.');
   if (!hasExt)
     filename = saver().save(filename + ".lib");
   StringRef ret = doFindFile(filename);
   // For MinGW, if the find above didn't turn up anything, try
   // looking for a MinGW formatted library name.
-  if (config->mingw && ret == filename)
+  if (ctx.config.mingw && ret == filename)
     return doFindLibMinGW(filename);
   return ret;
 }
 
 // Resolves a library path. /nodefaultlib options are taken into
 // consideration. This never returns the same path (in that case,
 // it returns None).
 Optional<StringRef> LinkerDriver::findLib(StringRef filename) {
-  if (config->noDefaultLibAll)
+  if (ctx.config.noDefaultLibAll)
     return None;
   if (!visitedLibs.insert(filename.lower()).second)
     return None;
 
   StringRef path = doFindLib(filename);
-  if (config->noDefaultLibs.count(path.lower()))
+  if (ctx.config.noDefaultLibs.count(path.lower()))
     return None;
 
   if (Optional<sys::fs::UniqueID> id = getUniqueID(path))
     if (!visitedFiles.insert(*id).second)
       return None;
   return path;
 }
 
while (!env.empty()) {
     searchPaths.push_back(path);
   }
 }
 
 Symbol *LinkerDriver::addUndefined(StringRef name) {
   Symbol *b = ctx.symtab.addUndefined(name);
   if (!b->isGCRoot) {
     b->isGCRoot = true;
-    config->gcroot.push_back(b);
+    ctx.config.gcroot.push_back(b);
   }
   return b;
 }
 
 StringRef LinkerDriver::mangleMaybe(Symbol *s) {
   // If the plain symbol name has already been resolved, do nothing.
   Undefined *unmangled = dyn_cast<Undefined>(s);
   if (!unmangled)

 }
 
 // Windows specific -- find default entry point name.
 //
 // There are four different entry point functions for Windows executables,
 // each of which corresponds to a user-defined "main" function. This function
 // infers an entry point from a user-defined "main" function.
 StringRef LinkerDriver::findDefaultEntry() {
-  assert(config->subsystem != IMAGE_SUBSYSTEM_UNKNOWN &&
+  assert(ctx.config.subsystem != IMAGE_SUBSYSTEM_UNKNOWN &&
          "must handle /subsystem before calling this");
 
-  if (config->mingw)
-    return mangle(config->subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI
+  if (ctx.config.mingw)
+    return mangle(ctx.config.subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI
                       ? "WinMainCRTStartup"
                       : "mainCRTStartup");
 
-  if (config->subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI) {
+  if (ctx.config.subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI) {
     if (findUnderscoreMangle("wWinMain")) {
       if (!findUnderscoreMangle("WinMain"))
         return mangle("wWinMainCRTStartup");
       warn("found both wWinMain and WinMain; using latter");
     }
     return mangle("WinMainCRTStartup");
   }
   if (findUnderscoreMangle("wmain")) {
     if (!findUnderscoreMangle("main"))
       return mangle("wmainCRTStartup");
     warn("found both wmain and main; using latter");
   }
   return mangle("mainCRTStartup");
 }
 
 WindowsSubsystem LinkerDriver::inferSubsystem() {
-  if (config->dll)
+  if (ctx.config.dll)
     return IMAGE_SUBSYSTEM_WINDOWS_GUI;
-  if (config->mingw)
+  if (ctx.config.mingw)
     return IMAGE_SUBSYSTEM_WINDOWS_CUI;
   // Note that link.exe infers the subsystem from the presence of these
   // functions even if /entry: or /nodefaultlib are passed which causes them
   // to not be called.
   bool haveMain = findUnderscoreMangle("main");
   bool haveWMain = findUnderscoreMangle("wmain");
   bool haveWinMain = findUnderscoreMangle("WinMain");
   bool haveWWinMain = findUnderscoreMangle("wWinMain");
   if (haveMain || haveWMain) {
     if (haveWinMain || haveWWinMain) {
       warn(std::string("found ") + (haveMain ? "main" : "wmain") + " and " +
            (haveWinMain ? "WinMain" : "wWinMain") +
            "; defaulting to /subsystem:console");
     }
     return IMAGE_SUBSYSTEM_WINDOWS_CUI;
   }
   if (haveWinMain || haveWWinMain)
     return IMAGE_SUBSYSTEM_WINDOWS_GUI;
   return IMAGE_SUBSYSTEM_UNKNOWN;
 }
 
-static uint64_t getDefaultImageBase() {
-  if (config->is64())
-    return config->dll ? 0x180000000 : 0x140000000;
-  return config->dll ? 0x10000000 : 0x400000;
+uint64_t LinkerDriver::getDefaultImageBase() {
+  if (ctx.config.is64())
+    return ctx.config.dll ? 0x180000000 : 0x140000000;
+  return ctx.config.dll ? 0x10000000 : 0x400000;
 }
 
 static std::string rewritePath(StringRef s) {
   if (fs::exists(s))
     return relativeToRoot(s);
   return std::string(s);
 }
 
static unsigned parseDebugTypes(const opt::InputArgList &args) {
   if (args.hasArg(OPT_driver))
     debugTypes |= static_cast<unsigned>(DebugType::PData);
   if (args.hasArg(OPT_profile))
     debugTypes |= static_cast<unsigned>(DebugType::Fixup);
 
   return debugTypes;
 }
 
-static std::string getMapFile(const opt::InputArgList &args,
-                              opt::OptSpecifier os, opt::OptSpecifier osFile) {
+std::string LinkerDriver::getMapFile(const opt::InputArgList &args,
+                                     opt::OptSpecifier os,
+                                     opt::OptSpecifier osFile) {
   auto *arg = args.getLastArg(os, osFile);
   if (!arg)
     return "";
   if (arg->getOption().getID() == osFile.getID())
     return arg->getValue();
 
   assert(arg->getOption().getID() == os.getID());
-  StringRef outFile = config->outputFile;
+  StringRef outFile = ctx.config.outputFile;
   return (outFile.substr(0, outFile.rfind('.')) + ".map").str();
 }
 
-static std::string getImplibPath() {
-  if (!config->implib.empty())
-    return std::string(config->implib);
-  SmallString<128> out = StringRef(config->outputFile);
+std::string LinkerDriver::getImplibPath() {
+  if (!ctx.config.implib.empty())
+    return std::string(ctx.config.implib);
+  SmallString<128> out = StringRef(ctx.config.outputFile);
   sys::path::replace_extension(out, ".lib");
   return std::string(out.str());
 }
 
 // The import name is calculated as follows:
 //
 //        | LIBRARY w/ ext |   LIBRARY w/o ext   | no LIBRARY
 //   -----+----------------+---------------------+------------------
 //   LINK | {value}        | {value}.{.dll/.exe} | {output name}
 //    LIB | {value}        | {value}.dll         | {output name}.dll
 //
-static std::string getImportName(bool asLib) {
+std::string LinkerDriver::getImportName(bool asLib) {
   SmallString<128> out;
 
-  if (config->importName.empty()) {
-    out.assign(sys::path::filename(config->outputFile));
+  if (ctx.config.importName.empty()) {
+    out.assign(sys::path::filename(ctx.config.outputFile));
     if (asLib)
       sys::path::replace_extension(out, ".dll");
   } else {
-    out.assign(config->importName);
+    out.assign(ctx.config.importName);
     if (!sys::path::has_extension(out))
       sys::path::replace_extension(out,
-                                   (config->dll || asLib) ? ".dll" : ".exe");
+                                   (ctx.config.dll || asLib) ? ".dll" : ".exe");
   }
 
   return std::string(out.str());
 }
 
-static void createImportLibrary(bool asLib) {
+void LinkerDriver::createImportLibrary(bool asLib) {
   std::vector<COFFShortExport> exports;
-  for (Export &e1 : config->exports) {
+  for (Export &e1 : ctx.config.exports) {
     COFFShortExport e2;
     e2.Name = std::string(e1.name);
     e2.SymbolName = std::string(e1.symbolName);
     e2.ExtName = std::string(e1.extName);
     e2.AliasTarget = std::string(e1.aliasTarget);
     e2.Ordinal = e1.ordinal;
     e2.Noname = e1.noname;
     e2.Data = e1.data;
     e2.Private = e1.isPrivate;
     e2.Constant = e1.constant;
     exports.push_back(e2);
   }
 
   std::string libName = getImportName(asLib);
   std::string path = getImplibPath();
 
-  if (!config->incremental) {
-    checkError(writeImportLibrary(libName, path, exports, config->machine,
-                                  config->mingw));
+  if (!ctx.config.incremental) {
+    checkError(writeImportLibrary(libName, path, exports, ctx.config.machine,
+                                  ctx.config.mingw));
     return;
   }
 
   // If the import library already exists, replace it only if the contents
   // have changed.
   ErrorOr<std::unique_ptr<MemoryBuffer>> oldBuf = MemoryBuffer::getFile(
       path, /*IsText=*/false, /*RequiresNullTerminator=*/false);
   if (!oldBuf) {
-    checkError(writeImportLibrary(libName, path, exports, config->machine,
-                                  config->mingw));
+    checkError(writeImportLibrary(libName, path, exports, ctx.config.machine,
+                                  ctx.config.mingw));
     return;
   }
 
   SmallString<128> tmpName;
   if (std::error_code ec =
           sys::fs::createUniqueFile(path + ".tmp-%%%%%%%%.lib", tmpName))
     fatal("cannot create temporary file for import library " + path + ": " +
           ec.message());
 
-  if (Error e = writeImportLibrary(libName, tmpName, exports, config->machine,
-                                   config->mingw)) {
+  if (Error e = writeImportLibrary(libName, tmpName, exports,
+                                   ctx.config.machine, ctx.config.mingw)) {
     checkError(std::move(e));
     return;
   }
 
   std::unique_ptr<MemoryBuffer> newBuf = check(MemoryBuffer::getFile(
       tmpName, /*IsText=*/false, /*RequiresNullTerminator=*/false));
   if ((*oldBuf)->getBuffer() != newBuf->getBuffer()) {
     oldBuf->reset();
     checkError(errorCodeToError(sys::fs::rename(tmpName, path)));
   } else {
     sys::fs::remove(tmpName);
   }
 }
 
-static void parseModuleDefs(StringRef path) {
+void LinkerDriver::parseModuleDefs(StringRef path) {
   std::unique_ptr<MemoryBuffer> mb =
       CHECK(MemoryBuffer::getFile(path, /*IsText=*/false,
                                   /*RequiresNullTerminator=*/false,
                                   /*IsVolatile=*/true),
             "could not open " + path);
   COFFModuleDefinition m = check(parseCOFFModuleDefinition(
-      mb->getMemBufferRef(), config->machine, config->mingw));
+      mb->getMemBufferRef(), ctx.config.machine, ctx.config.mingw));
 
   // Include in /reproduce: output if applicable.
-  driver->takeBuffer(std::move(mb));
+  ctx.driver.takeBuffer(std::move(mb));
 
-  if (config->outputFile.empty())
-    config->outputFile = std::string(saver().save(m.OutputFile));
-  config->importName = std::string(saver().save(m.ImportName));
+  if (ctx.config.outputFile.empty())
+    ctx.config.outputFile = std::string(saver().save(m.OutputFile));
+  ctx.config.importName = std::string(saver().save(m.ImportName));
   if (m.ImageBase)
-    config->imageBase = m.ImageBase;
+    ctx.config.imageBase = m.ImageBase;
   if (m.StackReserve)
-    config->stackReserve = m.StackReserve;
+    ctx.config.stackReserve = m.StackReserve;
   if (m.StackCommit)
-    config->stackCommit = m.StackCommit;
+    ctx.config.stackCommit = m.StackCommit;
   if (m.HeapReserve)
-    config->heapReserve = m.HeapReserve;
+    ctx.config.heapReserve = m.HeapReserve;
   if (m.HeapCommit)
-    config->heapCommit = m.HeapCommit;
+    ctx.config.heapCommit = m.HeapCommit;
   if (m.MajorImageVersion)
-    config->majorImageVersion = m.MajorImageVersion;
+    ctx.config.majorImageVersion = m.MajorImageVersion;
   if (m.MinorImageVersion)
-    config->minorImageVersion = m.MinorImageVersion;
+    ctx.config.minorImageVersion = m.MinorImageVersion;
   if (m.MajorOSVersion)
-    config->majorOSVersion = m.MajorOSVersion;
+    ctx.config.majorOSVersion = m.MajorOSVersion;
   if (m.MinorOSVersion)
-    config->minorOSVersion = m.MinorOSVersion;
+    ctx.config.minorOSVersion = m.MinorOSVersion;
 
   for (COFFShortExport e1 : m.Exports) {
     Export e2;
     // In simple cases, only Name is set. Renamed exports are parsed
     // and set as "ExtName = Name". If Name has the form "OtherDll.Func",
     // it shouldn't be a normal exported function but a forward to another
     // DLL instead. This is supported by both MS and GNU linkers.
     if (!e1.ExtName.empty() && e1.ExtName != e1.Name &&
         StringRef(e1.Name).contains('.')) {
       e2.name = saver().save(e1.ExtName);
       e2.forwardTo = saver().save(e1.Name);
-      config->exports.push_back(e2);
+      ctx.config.exports.push_back(e2);
       continue;
     }
     e2.name = saver().save(e1.Name);
     e2.extName = saver().save(e1.ExtName);
     e2.aliasTarget = saver().save(e1.AliasTarget);
     e2.ordinal = e1.Ordinal;
     e2.noname = e1.Noname;
     e2.data = e1.Data;
     e2.isPrivate = e1.Private;
     e2.constant = e1.Constant;
-    config->exports.push_back(e2);
+    ctx.config.exports.push_back(e2);
   }
 }
 
 void LinkerDriver::enqueueTask(std::function<void()> task) {
   taskQueue.push_back(std::move(task));
 }
 
 bool LinkerDriver::run() {
   ScopedTimer t(ctx.inputFileTimer);
 
   bool didWork = !taskQueue.empty();
   while (!taskQueue.empty()) {
     taskQueue.front()();
     taskQueue.pop_front();
   }
   return didWork;
 }
 
 // Parse an /order file. If an option is given, the linker places
 // COMDAT sections in the same order as their names appear in the
 // given file.
-static void parseOrderFile(COFFLinkerContext &ctx, StringRef arg) {
+void LinkerDriver::parseOrderFile(StringRef arg) {
   // For some reason, the MSVC linker requires a filename to be
   // preceded by "@".
   if (!arg.startswith("@")) {
     error("malformed /order option: '@' missing");
     return;
   }
 
   // Get a list of all comdat sections for error checking.
std::unique_ptr<MemoryBuffer> mb =
             "could not open " + path);
 
   // Parse a file. An order file contains one symbol per line.
   // All symbols that were not present in a given order file are
   // considered to have the lowest priority 0 and are placed at
   // end of an output section.
   for (StringRef arg : args::getLines(mb->getMemBufferRef())) {
     std::string s(arg);
-    if (config->machine == I386 && !isDecorated(s))
+    if (ctx.config.machine == I386 && !isDecorated(s))
       s = "_" + s;
 
     if (set.count(s) == 0) {
-      if (config->warnMissingOrderSymbol)
+      if (ctx.config.warnMissingOrderSymbol)
         warn("/order:" + arg + ": missing symbol: " + s + " [LNK4037]");
     }
     else
-      config->order[s] = INT_MIN + config->order.size();
+      ctx.config.order[s] = INT_MIN + ctx.config.order.size();
   }
 
   // Include in /reproduce: output if applicable.
-  driver->takeBuffer(std::move(mb));
+  ctx.driver.takeBuffer(std::move(mb));
 }
 
-static void parseCallGraphFile(COFFLinkerContext &ctx, StringRef path) {
+void LinkerDriver::parseCallGraphFile(StringRef path) {
   std::unique_ptr<MemoryBuffer> mb =
       CHECK(MemoryBuffer::getFile(path, /*IsText=*/false,
                                   /*RequiresNullTerminator=*/false,
                                   /*IsVolatile=*/true),
             "could not open " + path);
 
   // Build a map from symbol name to section.
   DenseMap<StringRef, Symbol *> map;
   for (ObjFile *file : ctx.objFileInstances)
     for (Symbol *sym : file->getSymbols())
       if (sym)
         map[sym->getName()] = sym;
 
   auto findSection = [&](StringRef name) -> SectionChunk * {
     Symbol *sym = map.lookup(name);
     if (!sym) {
-      if (config->warnMissingOrderSymbol)
+      if (ctx.config.warnMissingOrderSymbol)
         warn(path + ": no such symbol: " + name);
       return nullptr;
     }
 
     if (DefinedCOFF *dr = dyn_cast_or_null<DefinedCOFF>(sym))
       return dyn_cast_or_null<SectionChunk>(dr->getChunk());
     return nullptr;
   };
 
   for (StringRef line : args::getLines(*mb)) {
     SmallVector<StringRef, 3> fields;
     line.split(fields, ' ');
     uint64_t count;
 
     if (fields.size() != 3 || !to_integer(fields[2], count)) {
       error(path + ": parse error");
       return;
     }
 
     if (SectionChunk *from = findSection(fields[0]))
       if (SectionChunk *to = findSection(fields[1]))
-        config->callGraphProfile[{from, to}] += count;
+        ctx.config.callGraphProfile[{from, to}] += count;
   }
 
   // Include in /reproduce: output if applicable.
-  driver->takeBuffer(std::move(mb));
+  ctx.driver.takeBuffer(std::move(mb));
 }
 
 static void readCallGraphsFromObjectFiles(COFFLinkerContext &ctx) {
   for (ObjFile *obj : ctx.objFileInstances) {
     if (obj->callgraphSec) {
       ArrayRef<uint8_t> contents;
       cantFail(
           obj->getCOFFObj()->getSectionContents(obj->callgraphSec, contents));
if (obj->callgraphSec) {
           fatal(toString(obj) + ": Expected 64-bit integer");
         auto *fromSym = dyn_cast_or_null<Defined>(obj->getSymbol(fromIndex));
         auto *toSym = dyn_cast_or_null<Defined>(obj->getSymbol(toIndex));
         if (!fromSym || !toSym)
           continue;
         auto *from = dyn_cast_or_null<SectionChunk>(fromSym->getChunk());
         auto *to = dyn_cast_or_null<SectionChunk>(toSym->getChunk());
         if (from && to)
-          config->callGraphProfile[{from, to}] += count;
+          ctx.config.callGraphProfile[{from, to}] += count;
       }
     }
   }
 }
 
 static void markAddrsig(Symbol *s) {
   if (auto *d = dyn_cast_or_null<Defined>(s))
     if (SectionChunk *c = dyn_cast_or_null<SectionChunk>(d->getChunk()))
       c->keepUnique = true;
 }
 
 static void findKeepUniqueSections(COFFLinkerContext &ctx) {
   // Exported symbols could be address-significant in other executables or DSOs,
   // so we conservatively mark them as address-significant.
-  for (Export &r : config->exports)
+  for (Export &r : ctx.config.exports)
     markAddrsig(r.sym);
 
   // Visit the address-significance table in each object file and mark each
   // referenced symbol as address-significant.
   for (ObjFile *obj : ctx.objFileInstances) {
     ArrayRef<Symbol *> syms = obj->getSymbols();
     if (obj->addrsigSec) {
       ArrayRef<uint8_t> contents;

 }
 
 // link.exe replaces each %foo% in altPath with the contents of environment
 // variable foo, and adds the two magic env vars _PDB (expands to the basename
 // of pdb's output path) and _EXT (expands to the extension of the output
 // binary).
 // lld only supports %_PDB% and %_EXT% and warns on references to all other env
 // vars.
-static void parsePDBAltPath(StringRef altPath) {
+void LinkerDriver::parsePDBAltPath() {
   SmallString<128> buf;
   StringRef pdbBasename =
-      sys::path::filename(config->pdbPath, sys::path::Style::windows);
+      sys::path::filename(ctx.config.pdbPath, sys::path::Style::windows);
   StringRef binaryExtension =
-      sys::path::extension(config->outputFile, sys::path::Style::windows);
+      sys::path::extension(ctx.config.outputFile, sys::path::Style::windows);
   if (!binaryExtension.empty())
     binaryExtension = binaryExtension.substr(1); // %_EXT% does not include '.'.
 
   // Invariant:
   //   +--------- cursor ('a...' might be the empty string).
   //   |   +----- firstMark
   //   |   |   +- secondMark
   //   v   v   v
   //   a...%...%...
   size_t cursor = 0;
-  while (cursor < altPath.size()) {
+  while (cursor < ctx.config.pdbAltPath.size()) {
     size_t firstMark, secondMark;
-    if ((firstMark = altPath.find('%', cursor)) == StringRef::npos ||
-        (secondMark = altPath.find('%', firstMark + 1)) == StringRef::npos) {
+    if ((firstMark = ctx.config.pdbAltPath.find('%', cursor)) ==
+            StringRef::npos ||
+        (secondMark = ctx.config.pdbAltPath.find('%', firstMark + 1)) ==
+            StringRef::npos) {
       // Didn't find another full fragment, treat rest of string as literal.
-      buf.append(altPath.substr(cursor));
+      buf.append(ctx.config.pdbAltPath.substr(cursor));
       break;
     }
 
     // Found a full fragment. Append text in front of first %, and interpret
     // text between first and second % as variable name.
-    buf.append(altPath.substr(cursor, firstMark - cursor));
-    StringRef var = altPath.substr(firstMark, secondMark - firstMark + 1);
+    buf.append(ctx.config.pdbAltPath.substr(cursor, firstMark - cursor));
+    StringRef var =
+        ctx.config.pdbAltPath.substr(firstMark, secondMark - firstMark + 1);
     if (var.equals_insensitive("%_pdb%"))
       buf.append(pdbBasename);
     else if (var.equals_insensitive("%_ext%"))
       buf.append(binaryExtension);
     else {
       warn("only %_PDB% and %_EXT% supported in /pdbaltpath:, keeping " +
            var + " as literal");
       buf.append(var);
     }
 
     cursor = secondMark + 1;
   }
 
-  config->pdbAltPath = buf;
+  ctx.config.pdbAltPath = buf;
 }
 
 /// Convert resource files and potentially merge input resource object
 /// trees into one resource tree.
 /// Call after ObjFile::Instances is complete.
 void LinkerDriver::convertResources() {
   std::vector<ObjFile *> resourceObjFiles;
 
   for (ObjFile *f : ctx.objFileInstances) {
     if (f->isResourceObjFile())
       resourceObjFiles.push_back(f);
   }
 
-  if (!config->mingw &&
+  if (!ctx.config.mingw &&
       (resourceObjFiles.size() > 1 ||
        (resourceObjFiles.size() == 1 && !resources.empty()))) {
     error((!resources.empty() ? "internal .obj file created from .res files"
                               : toString(resourceObjFiles[1])) +
           ": more than one resource obj file not allowed, already got " +
           toString(resourceObjFiles.front()));
     return;
   }

 // In MinGW, if no symbols are chosen to be exported, then all symbols are
 // automatically exported by default. This behavior can be forced by the
 // -export-all-symbols option, so that it happens even when exports are
 // explicitly specified. The automatic behavior can be disabled using the
 // -exclude-all-symbols option, so that lld-link behaves like link.exe rather
 // than MinGW in the case that nothing is explicitly exported.
 void LinkerDriver::maybeExportMinGWSymbols(const opt::InputArgList &args) {
   if (!args.hasArg(OPT_export_all_symbols)) {
-    if (!config->dll)
+    if (!ctx.config.dll)
       return;
 
-    if (!config->exports.empty())
+    if (!ctx.config.exports.empty())
       return;
     if (args.hasArg(OPT_exclude_all_symbols))
       return;
   }
 
-  AutoExporter exporter;
+  AutoExporter exporter(ctx);
 
   for (auto *arg : args.filtered(OPT_wholearchive_file))
     if (Optional<StringRef> path = doFindFile(arg->getValue()))
       exporter.addWholeArchive(*path);
 
   ctx.symtab.forEachSymbol([&](Symbol *s) {
     auto *def = dyn_cast<Defined>(s);
-    if (!exporter.shouldExport(ctx, def))
+    if (!exporter.shouldExport(def))
       return;
 
     if (!def->isGCRoot) {
       def->isGCRoot = true;
-      config->gcroot.push_back(def);
+      ctx.config.gcroot.push_back(def);
     }
 
     Export e;
     e.name = def->getName();
     e.sym = def;
     if (Chunk *c = def->getChunk())
       if (!(c->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE))
         e.data = true;
     s->isUsedInRegularObj = true;
-    config->exports.push_back(e);
+    ctx.config.exports.push_back(e);
   });
 }
 
 // lld has a feature to create a tar file containing all input files as well as
 // all command line options, so that other people can run lld again with exactly
 // the same inputs. This feature is accessible via /linkrepro and /reproduce.
 //
 // /linkrepro and /reproduce are very similar, but /linkrepro takes a directory
Optional<std::string> getReproduceFile(const opt::InputArgList &args) {
   if (auto *path = getenv("LLD_REPRODUCE"))
     return std::string(path);
 
   return None;
 }
 
 void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
   ScopedTimer rootTimer(ctx.rootTimer);
+  Configuration *config = &ctx.config;
 
   // Needed for LTO.
   InitializeAllTargetInfos();
   InitializeAllTargets();
   InitializeAllTargetMCs();
   InitializeAllAsmParsers();
   InitializeAllAsmPrinters();
 
   // If the first command line argument is "/lib", link.exe acts like lib.exe.
   // We call our own implementation of lib.exe that understands bitcode files.
   if (argsArr.size() > 1 &&
       (StringRef(argsArr[1]).equals_insensitive("/lib") ||
        StringRef(argsArr[1]).equals_insensitive("-lib"))) {
     if (llvm::libDriverMain(argsArr.slice(1)) != 0)
       fatal("lib failed");
     return;
   }
 
   // Parse command line options.
-  ArgParser parser;
+  ArgParser parser(ctx);
   opt::InputArgList args = parser.parse(argsArr);
 
   // Parse and evaluate -mllvm options.
   std::vector<const char *> v;
   v.push_back("lld-link (LLVM option parsing)");
   for (auto *arg : args.filtered(OPT_mllvm))
     v.push_back(arg->getValue());
   cl::ResetAllOptionOccurrences();
void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
   // /opt:lldltojobs=.
   if (auto *arg = args.getLastArg(OPT_threads)) {
     StringRef v(arg->getValue());
     unsigned threads = 0;
     if (!llvm::to_integer(v, threads, 0) || threads == 0)
       error(arg->getSpelling() + ": expected a positive integer, but got '" +
             arg->getValue() + "'");
     parallel::strategy = hardware_concurrency(threads);
     config->thinLTOJobs = v.str();
   }
 
   if (args.hasArg(OPT_show_timing))
     config->showTiming = true;
 
   config->showSummary = args.hasArg(OPT_summary);
 
   // Handle --version, which is an lld extension. This option is a bit odd
void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
   // Handle /demangle
   config->demangle = args.hasFlag(OPT_demangle, OPT_demangle_no);
 
   // Handle /debugtype
   config->debugTypes = parseDebugTypes(args);
 
   // Handle /driver[:uponly|:wdm].
   config->driverUponly = args.hasArg(OPT_driver_uponly) ||
-                         args.hasArg(OPT_driver_uponly_wdm) ||
-                         args.hasArg(OPT_driver_wdm_uponly);
   config->driverWdm = args.hasArg(OPT_driver_wdm) ||
-                      args.hasArg(OPT_driver_uponly_wdm) ||
-                      args.hasArg(OPT_driver_wdm_uponly);
   config->driver =
       config->driverUponly || config->driverWdm || args.hasArg(OPT_driver);
 
   // Handle /pdb
   bool shouldCreatePDB =
       (debug == DebugKind::Full || debug == DebugKind::GHash ||
        debug == DebugKind::NoGHash);
   if (shouldCreatePDB) {
void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
 
   if (!config->manifestInput.empty() &&
       config->manifest != Configuration::Embed) {
     fatal("/manifestinput: requires /manifest:embed");
   }
 
   config->thinLTOEmitImportsFiles = args.hasArg(OPT_thinlto_emit_imports_files);
   config->thinLTOIndexOnly = args.hasArg(OPT_thinlto_index_only) ||
-                             args.hasArg(OPT_thinlto_index_only_arg);
-  config->thinLTOIndexOnlyArg =
-      args.getLastArgValue(OPT_thinlto_index_only_arg);
+  config->thinLTOIndexOnlyArg = args.getLastArgValue(OPT_thinlto_index_only_arg);
   config->thinLTOPrefixReplace =
       getOldNewOptions(args, OPT_thinlto_prefix_replace);
   config->thinLTOObjectSuffixReplace =
       getOldNewOptions(args, OPT_thinlto_object_suffix_replace);
   config->ltoObjPath = args.getLastArgValue(OPT_lto_obj_path);
   config->ltoCSProfileGenerate = args.hasArg(OPT_lto_cs_profile_generate);
   config->ltoCSProfileFile = args.getLastArgValue(OPT_lto_cs_profile_file);
   // Handle miscellaneous boolean flags.
   config->ltoPGOWarnMismatch = args.hasFlag(OPT_lto_pgo_warn_mismatch,
-                                            OPT_lto_pgo_warn_mismatch_no, true);
   config->allowBind = args.hasFlag(OPT_allowbind, OPT_allowbind_no, true);
   config->allowIsolation =
       args.hasFlag(OPT_allowisolation, OPT_allowisolation_no, true);
   config->incremental =
       args.hasFlag(OPT_incremental, OPT_incremental_no,
                    !config->doGC && config->doICF == ICFLevel::None &&
                        !args.hasArg(OPT_order) && !args.hasArg(OPT_profile));
   config->integrityCheck =
       args.hasFlag(OPT_integritycheck, OPT_integritycheck_no, false);
   config->cetCompat = args.hasFlag(OPT_cetcompat, OPT_cetcompat_no, false);
   config->nxCompat = args.hasFlag(OPT_nxcompat, OPT_nxcompat_no, true);
   for (auto *arg : args.filtered(OPT_swaprun))
     parseSwaprun(arg->getValue());
   config->terminalServerAware =
       !config->dll && args.hasFlag(OPT_tsaware, OPT_tsaware_no, true);
   config->debugDwarf = debug == DebugKind::Dwarf;
   config->debugGHashes = debug == DebugKind::GHash || debug == DebugKind::Full;
   config->debugSymtab = debug == DebugKind::Symtab;
   config->autoImport =
       args.hasFlag(OPT_auto_import, OPT_auto_import_no, config->mingw);
-  config->pseudoRelocs = args.hasFlag(
-      OPT_runtime_pseudo_reloc, OPT_runtime_pseudo_reloc_no, config->mingw);
+  config->pseudoRelocs = args.hasFlag(OPT_runtime_pseudo_reloc,
+                                     OPT_runtime_pseudo_reloc_no, config->mingw);
   config->callGraphProfileSort = args.hasFlag(
       OPT_call_graph_profile_sort, OPT_call_graph_profile_sort_no, true);
   config->stdcallFixup =
       args.hasFlag(OPT_stdcall_fixup, OPT_stdcall_fixup_no, config->mingw);
   config->warnStdcallFixup = !args.hasArg(OPT_stdcall_fixup);
 
   // Don't warn about long section names, such as .debug_info, for mingw or
   // when -debug:dwarf is requested.
void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
   // Handle /safeseh, x86 only, on by default, except for mingw.
   if (config->machine == I386) {
     config->safeSEH = args.hasFlag(OPT_safeseh, OPT_safeseh_no, !config->mingw);
     config->noSEH = args.hasArg(OPT_noseh);
   }
 
   // Handle /functionpadmin
   for (auto *arg : args.filtered(OPT_functionpadmin, OPT_functionpadmin_opt))
-    parseFunctionPadMin(arg, config->machine);
+    parseFunctionPadMin(arg);
 
   if (tar)
     tar->append("response.txt",
                 createResponseFile(args, filePaths,
                                    ArrayRef<StringRef>(searchPaths).slice(1)));
 
   // Handle /largeaddressaware
   config->largeAddressAware = args.hasFlag(
void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
   }
 
   // Handle /entry and /dll
   if (auto *arg = args.getLastArg(OPT_entry)) {
     config->entry = addUndefined(mangle(arg->getValue()));
   } else if (!config->entry && !config->noEntry) {
     if (args.hasArg(OPT_dll)) {
       StringRef s = (config->machine == I386) ? "__DllMainCRTStartup@12"
-                                              : "_DllMainCRTStartup";
       config->entry = addUndefined(s);
     } else if (config->driverWdm) {
       // /driver:wdm implies /entry:_NtProcessStartup
       config->entry = addUndefined(mangle("_NtProcessStartup"));
     } else {
       // Windows specific -- If entry point name is not given, we need to
       // infer that from user-defined entry name.
       StringRef s = findDefaultEntry();
for (auto *arg : args.filtered(OPT_delayload)) {
     } else {
       config->delayLoadHelper = addUndefined("__delayLoadHelper2");
     }
   }
 
   // Set default image name if neither /out or /def set it.
   if (config->outputFile.empty()) {
     config->outputFile = getOutputPath(
-        (*args.filtered(OPT_INPUT, OPT_wholearchive_file).begin())->getValue());
+        (*args.filtered(OPT_INPUT, OPT_wholearchive_file).begin())->getValue(),
+        config->dll, config->driver);
   }
 
   // Fail early if an output file is not writable.
   if (auto e = tryCreateFile(config->outputFile)) {
     error("cannot open output file " + config->outputFile + ": " + e.message());
     return;
   }
 
if (config->pdbAltPath.empty()) {
       config->pdbAltPath = config->pdbPath;
 
       // It's important to make the path absolute and remove dots.  This path
       // will eventually be written into the PE header, and certain Microsoft
       // tools won't work correctly if these assumptions are not held.
       sys::fs::make_absolute(config->pdbAltPath);
       sys::path::remove_dots(config->pdbAltPath);
     } else {
-      // Don't do this earlier, so that Config->OutputFile is ready.
-      parsePDBAltPath(config->pdbAltPath);
+      // Don't do this earlier, so that ctx.OutputFile is ready.
+      parsePDBAltPath();
     }
   }
 
   // Set default image base if /base is not given.
   if (config->imageBase == uint64_t(-1))
     config->imageBase = getDefaultImageBase();
 
   ctx.symtab.addSynthetic(mangle("__ImageBase"), nullptr);
void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
 
   // Do LTO by compiling bitcode input files to a set of native COFF files then
   // link those files (unless -thinlto-index-only was given, in which case we
   // resolve symbols and write indices, but don't generate native code or link).
   ctx.symtab.compileBitcodeFiles();
 
   // If -thinlto-index-only is given, we should create only "index
   // files" and not object files. Index file creation is already done
-  // in compileBitcodeFiles, so we are done if that's the case.
+  // in addCombinedLTOObject, so we are done if that's the case.
   if (config->thinLTOIndexOnly)
     return;
 
   // If we generated native object files from bitcode files, this resolves
   // references to the symbols we use from them.
   run();
 
   // Apply symbol renames for -wrap.
if (!config->exports.empty() || config->dll) {
     fixupExports();
     if (!config->mingw || !config->implib.empty())
       createImportLibrary(/*asLib=*/false);
     assignExportOrdinals();
   }
 
   // Handle /output-def (MinGW specific).
   if (auto *arg = args.getLastArg(OPT_output_def))
-    writeDefFile(arg->getValue());
+    writeDefFile(arg->getValue(), config->exports);
 
   // Set extra alignment for .comm symbols
   for (auto pair : config->alignComm) {
     StringRef name = pair.first;
     uint32_t alignment = pair.second;
 
     Symbol *sym = ctx.symtab.find(name);
     if (!sym) {
else if (config->manifest == Configuration::SideBySide ||
     createSideBySideManifest();
 
   // Handle /order. We want to do this at this moment because we
   // need a complete list of comdat sections to warn on nonexistent
   // functions.
   if (auto *arg = args.getLastArg(OPT_order)) {
     if (args.hasArg(OPT_call_graph_ordering_file))
       error("/order and /call-graph-order-file may not be used together");
-    parseOrderFile(ctx, arg->getValue());
+    parseOrderFile(arg->getValue());
     config->callGraphProfileSort = false;
   }
 
   // Handle /call-graph-ordering-file and /call-graph-profile-sort (default on).
   if (config->callGraphProfileSort) {
     if (auto *arg = args.getLastArg(OPT_call_graph_ordering_file)) {
-      parseCallGraphFile(ctx, arg->getValue());
+      parseCallGraphFile(arg->getValue());
     }
     readCallGraphsFromObjectFiles(ctx);
   }
 
   // Handle /print-symbol-order.
   if (auto *arg = args.getLastArg(OPT_print_symbol_order))
     config->printSymbolOrder = arg->getValue();
 

   }
 
   // Needs to happen after the last call to addFile().
   convertResources();
 
   // Identify identical COMDAT sections to merge them.
   if (config->doICF != ICFLevel::None) {
     findKeepUniqueSections(ctx);
-    doICF(ctx, config->doICF);
+    doICF(ctx);
   }
 
   // Write the result.
   writeResult(ctx);
 
   // Stop early so we can print the results.
   rootTimer.stop();
   if (config->showTiming)
     ctx.rootTimer.print();
 }
 
 } // namespace coff
 } // namespace lld

lld/COFF/DriverUtils.cpp

 //===- DriverUtils.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains utility functions for the driver. Because there
 // are so many small functions, we created this separate file to make
 // Driver.cpp less cluttered.
 //
 //===----------------------------------------------------------------------===//
 
-#include "Config.h"
+#include "COFFLinkerContext.h"
 #include "Driver.h"
 #include "Symbols.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/Object/COFF.h"

 private:
   StringRef prog;
   std::vector<StringRef> args;
 };
 
 } // anonymous namespace
 
 // Parses a string in the form of "<integer>[,<integer>]".
-void parseNumbers(StringRef arg, uint64_t *addr, uint64_t *size) {
+void LinkerDriver::parseNumbers(StringRef arg, uint64_t *addr, uint64_t *size) {
   StringRef s1, s2;
   std::tie(s1, s2) = arg.split(',');
   if (s1.getAsInteger(0, *addr))
     fatal("invalid number: " + s1);
   if (size && !s2.empty() && s2.getAsInteger(0, *size))
     fatal("invalid number: " + s2);
 }
 
 // Parses a string in the form of "<integer>[.<integer>]".
 // If second number is not present, Minor is set to 0.
-void parseVersion(StringRef arg, uint32_t *major, uint32_t *minor) {
+void LinkerDriver::parseVersion(StringRef arg, uint32_t *major,
+                                uint32_t *minor) {
   StringRef s1, s2;
   std::tie(s1, s2) = arg.split('.');
   if (s1.getAsInteger(10, *major))
     fatal("invalid number: " + s1);
   *minor = 0;
   if (!s2.empty() && s2.getAsInteger(10, *minor))
     fatal("invalid number: " + s2);
 }
 
-void parseGuard(StringRef fullArg) {
+void LinkerDriver::parseGuard(StringRef fullArg) {
   SmallVector<StringRef, 1> splitArgs;
   fullArg.split(splitArgs, ",");
   for (StringRef arg : splitArgs) {
     if (arg.equals_insensitive("no"))
-      config->guardCF = GuardCFLevel::Off;
+      ctx.config.guardCF = GuardCFLevel::Off;
     else if (arg.equals_insensitive("nolongjmp"))
-      config->guardCF &= ~GuardCFLevel::LongJmp;
+      ctx.config.guardCF &= ~GuardCFLevel::LongJmp;
     else if (arg.equals_insensitive("noehcont"))
-      config->guardCF &= ~GuardCFLevel::EHCont;
+      ctx.config.guardCF &= ~GuardCFLevel::EHCont;
     else if (arg.equals_insensitive("cf"))
-      config->guardCF = GuardCFLevel::CF;
+      ctx.config.guardCF = GuardCFLevel::CF;
     else if (arg.equals_insensitive("longjmp"))
-      config->guardCF |= GuardCFLevel::CF | GuardCFLevel::LongJmp;
+      ctx.config.guardCF |= GuardCFLevel::CF | GuardCFLevel::LongJmp;
     else if (arg.equals_insensitive("ehcont"))
-      config->guardCF |= GuardCFLevel::CF | GuardCFLevel::EHCont;
+      ctx.config.guardCF |= GuardCFLevel::CF | GuardCFLevel::EHCont;
     else
       fatal("invalid argument to /guard: " + arg);
   }
 }
 
 // Parses a string in the form of "<subsystem>[,<integer>[.<integer>]]".
-void parseSubsystem(StringRef arg, WindowsSubsystem *sys, uint32_t *major,
-                    uint32_t *minor, bool *gotVersion) {
+void LinkerDriver::parseSubsystem(StringRef arg, WindowsSubsystem *sys,
+                                  uint32_t *major, uint32_t *minor,
+                                  bool *gotVersion) {
   StringRef sysStr, ver;
   std::tie(sysStr, ver) = arg.split(',');
   std::string sysStrLower = sysStr.lower();
   *sys = StringSwitch<WindowsSubsystem>(sysStrLower)
     .Case("boot_application", IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION)
     .Case("console", IMAGE_SUBSYSTEM_WINDOWS_CUI)
     .Case("default", IMAGE_SUBSYSTEM_UNKNOWN)
     .Case("efi_application", IMAGE_SUBSYSTEM_EFI_APPLICATION)
void LinkerDriver::parseSubsystem(StringRef arg, WindowsSubsystem *sys,
   if (!ver.empty())
     parseVersion(ver, major, minor);
   if (gotVersion)
     *gotVersion = !ver.empty();
 }
 
 // Parse a string of the form of "<from>=<to>".
 // Results are directly written to Config.
-void parseAlternateName(StringRef s) {
+void LinkerDriver::parseAlternateName(StringRef s) {
   StringRef from, to;
   std::tie(from, to) = s.split('=');
   if (from.empty() || to.empty())
     fatal("/alternatename: invalid argument: " + s);
-  auto it = config->alternateNames.find(from);
-  if (it != config->alternateNames.end() && it->second != to)
+  auto it = ctx.config.alternateNames.find(from);
+  if (it != ctx.config.alternateNames.end() && it->second != to)
     fatal("/alternatename: conflicts: " + s);
-  config->alternateNames.insert(it, std::make_pair(from, to));
+  ctx.config.alternateNames.insert(it, std::make_pair(from, to));
 }
 
 // Parse a string of the form of "<from>=<to>".
 // Results are directly written to Config.
-void parseMerge(StringRef s) {
+void LinkerDriver::parseMerge(StringRef s) {
   StringRef from, to;
   std::tie(from, to) = s.split('=');
   if (from.empty() || to.empty())
     fatal("/merge: invalid argument: " + s);
   if (from == ".rsrc" || to == ".rsrc")
     fatal("/merge: cannot merge '.rsrc' with any section");
   if (from == ".reloc" || to == ".reloc")
     fatal("/merge: cannot merge '.reloc' with any section");
-  auto pair = config->merge.insert(std::make_pair(from, to));
+  auto pair = ctx.config.merge.insert(std::make_pair(from, to));
   bool inserted = pair.second;
   if (!inserted) {
     StringRef existing = pair.first->second;
     if (existing != to)
       warn(s + ": already merged into " + existing);
   }
 }
 
-void parsePDBPageSize(StringRef s) {
+void LinkerDriver::parsePDBPageSize(StringRef s) {
   int v;
   if (s.getAsInteger(0, v)) {
     error("/pdbpagesize: invalid argument: " + s);
     return;
   }
   if (v != 4096 && v != 8192 && v != 16384 && v != 32768) {
     error("/pdbpagesize: invalid argument: " + s);
     return;
   }
 
-  config->pdbPageSize = v;
+  ctx.config.pdbPageSize = v;
 }
 
 static uint32_t parseSectionAttributes(StringRef s) {
   uint32_t ret = 0;
   for (char c : s.lower()) {
     switch (c) {
     case 'd':
       ret |= IMAGE_SCN_MEM_DISCARDABLE;
for (char c : s.lower()) {
     default:
       fatal("/section: invalid argument: " + s);
     }
   }
   return ret;
 }
 
 // Parses /section option argument.
-void parseSection(StringRef s) {
+void LinkerDriver::parseSection(StringRef s) {
   StringRef name, attrs;
   std::tie(name, attrs) = s.split(',');
   if (name.empty() || attrs.empty())
     fatal("/section: invalid argument: " + s);
-  config->section[name] = parseSectionAttributes(attrs);
+  ctx.config.section[name] = parseSectionAttributes(attrs);
 }
 
 // Parses /aligncomm option argument.
-void parseAligncomm(StringRef s) {
+void LinkerDriver::parseAligncomm(StringRef s) {
   StringRef name, align;
   std::tie(name, align) = s.split(',');
   if (name.empty() || align.empty()) {
     error("/aligncomm: invalid argument: " + s);
     return;
   }
   int v;
   if (align.getAsInteger(0, v)) {
     error("/aligncomm: invalid argument: " + s);
     return;
   }
-  config->alignComm[std::string(name)] =
-      std::max(config->alignComm[std::string(name)], 1 << v);
+  ctx.config.alignComm[std::string(name)] =
+      std::max(ctx.config.alignComm[std::string(name)], 1 << v);
 }
 
 // Parses /functionpadmin option argument.
-void parseFunctionPadMin(llvm::opt::Arg *a, llvm::COFF::MachineTypes machine) {
+void LinkerDriver::parseFunctionPadMin(llvm::opt::Arg *a) {
   StringRef arg = a->getNumValues() ? a->getValue() : "";
   if (!arg.empty()) {
     // Optional padding in bytes is given.
-    if (arg.getAsInteger(0, config->functionPadMin))
+    if (arg.getAsInteger(0, ctx.config.functionPadMin))
       error("/functionpadmin: invalid argument: " + arg);
     return;
   }
   // No optional argument given.
   // Set default padding based on machine, similar to link.exe.
   // There is no default padding for ARM platforms.
-  if (machine == I386) {
-    config->functionPadMin = 5;
-  } else if (machine == AMD64) {
-    config->functionPadMin = 6;
+  if (ctx.config.machine == I386) {
+    ctx.config.functionPadMin = 5;
+  } else if (ctx.config.machine == AMD64) {
+    ctx.config.functionPadMin = 6;
   } else {
     error("/functionpadmin: invalid argument for this machine: " + arg);
   }
 }
 
 // Parses a string in the form of "EMBED[,=<integer>]|NO".
-// Results are directly written to Config.
-void parseManifest(StringRef arg) {
+// Results are directly written to
+// Config.
+void LinkerDriver::parseManifest(StringRef arg) {
   if (arg.equals_insensitive("no")) {
-    config->manifest = Configuration::No;
+    ctx.config.manifest = Configuration::No;
     return;
   }
   if (!arg.startswith_insensitive("embed"))
     fatal("invalid option " + arg);
-  config->manifest = Configuration::Embed;
+  ctx.config.manifest = Configuration::Embed;
   arg = arg.substr(strlen("embed"));
   if (arg.empty())
     return;
   if (!arg.startswith_insensitive(",id="))
     fatal("invalid option " + arg);
   arg = arg.substr(strlen(",id="));
-  if (arg.getAsInteger(0, config->manifestID))
+  if (arg.getAsInteger(0, ctx.config.manifestID))
     fatal("invalid option " + arg);
 }
 
 // Parses a string in the form of "level=<string>|uiAccess=<string>|NO".
 // Results are directly written to Config.
-void parseManifestUAC(StringRef arg) {
+void LinkerDriver::parseManifestUAC(StringRef arg) {
   if (arg.equals_insensitive("no")) {
-    config->manifestUAC = false;
+    ctx.config.manifestUAC = false;
     return;
   }
   for (;;) {
     arg = arg.ltrim();
     if (arg.empty())
       return;
     if (arg.startswith_insensitive("level=")) {
       arg = arg.substr(strlen("level="));
-      std::tie(config->manifestLevel, arg) = arg.split(" ");
+      std::tie(ctx.config.manifestLevel, arg) = arg.split(" ");
       continue;
     }
     if (arg.startswith_insensitive("uiaccess=")) {
       arg = arg.substr(strlen("uiaccess="));
-      std::tie(config->manifestUIAccess, arg) = arg.split(" ");
+      std::tie(ctx.config.manifestUIAccess, arg) = arg.split(" ");
       continue;
     }
     fatal("invalid option " + arg);
   }
 }
 
 // Parses a string in the form of "cd|net[,(cd|net)]*"
 // Results are directly written to Config.
-void parseSwaprun(StringRef arg) {
+void LinkerDriver::parseSwaprun(StringRef arg) {
   do {
     StringRef swaprun, newArg;
     std::tie(swaprun, newArg) = arg.split(',');
     if (swaprun.equals_insensitive("cd"))
-      config->swaprunCD = true;
+      ctx.config.swaprunCD = true;
     else if (swaprun.equals_insensitive("net"))
-      config->swaprunNet = true;
+      ctx.config.swaprunNet = true;
     else if (swaprun.empty())
       error("/swaprun: missing argument");
     else
       error("/swaprun: invalid argument: " + swaprun);
     // To catch trailing commas, e.g. `/spawrun:cd,`
     if (newArg.empty() && arg.endswith(","))
       error("/swaprun: missing argument");
     arg = newArg;
return CHECK(MemoryBuffer::getFile(path, /*IsText=*/false,
                                        /*IsVolatile=*/true),
                  "could not open " + path);
   }
 
   std::string path;
 };
 }
 
-static std::string createDefaultXml() {
+std::string LinkerDriver::createDefaultXml() {
   std::string ret;
   raw_string_ostream os(ret);
 
   // Emit the XML. Note that we do *not* verify that the XML attributes are
   // syntactically correct. This is intentional for link.exe compatibility.
   os << "<?xml version=\"1.0\" standalone=\"yes\"?>\n"
      << "<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\"\n"
      << "          manifestVersion=\"1.0\">\n";
-  if (config->manifestUAC) {
+  if (ctx.config.manifestUAC) {
     os << "  <trustInfo>\n"
        << "    <security>\n"
        << "      <requestedPrivileges>\n"
-       << "         <requestedExecutionLevel level=" << config->manifestLevel
-       << " uiAccess=" << config->manifestUIAccess << "/>\n"
+       << "         <requestedExecutionLevel level=" << ctx.config.manifestLevel
+       << " uiAccess=" << ctx.config.manifestUIAccess << "/>\n"
        << "      </requestedPrivileges>\n"
        << "    </security>\n"
        << "  </trustInfo>\n";
   }
-  for (auto manifestDependency : config->manifestDependencies) {
+  for (auto manifestDependency : ctx.config.manifestDependencies) {
     os << "  <dependency>\n"
        << "    <dependentAssembly>\n"
        << "      <assemblyIdentity " << manifestDependency << " />\n"
        << "    </dependentAssembly>\n"
        << "  </dependency>\n";
   }
   os << "</assembly>\n";
   return os.str();
 }
 
-static std::string createManifestXmlWithInternalMt(StringRef defaultXml) {
+std::string
+LinkerDriver::createManifestXmlWithInternalMt(StringRef defaultXml) {
   std::unique_ptr<MemoryBuffer> defaultXmlCopy =
       MemoryBuffer::getMemBufferCopy(defaultXml);
 
   windows_manifest::WindowsManifestMerger merger;
   if (auto e = merger.merge(*defaultXmlCopy.get()))
     fatal("internal manifest tool failed on default xml: " +
           toString(std::move(e)));
 
-  for (StringRef filename : config->manifestInput) {
+  for (StringRef filename : ctx.config.manifestInput) {
     std::unique_ptr<MemoryBuffer> manifest =
         check(MemoryBuffer::getFile(filename));
     // Call takeBuffer to include in /reproduce: output if applicable.
-    if (auto e = merger.merge(driver->takeBuffer(std::move(manifest))))
+    if (auto e = merger.merge(takeBuffer(std::move(manifest))))
       fatal("internal manifest tool failed on file " + filename + ": " +
             toString(std::move(e)));
   }
 
   return std::string(merger.getMergedManifest().get()->getBuffer());
 }
 
-static std::string createManifestXmlWithExternalMt(StringRef defaultXml) {
+std::string
+LinkerDriver::createManifestXmlWithExternalMt(StringRef defaultXml) {
   // Create the default manifest file as a temporary file.
   TemporaryFile Default("defaultxml", "manifest");
   std::error_code ec;
   raw_fd_ostream os(Default.path, ec, sys::fs::OF_TextWithCRLF);
   if (ec)
     fatal("failed to open " + Default.path + ": " + ec.message());
   os << defaultXml;
   os.close();
 
   // Merge user-supplied manifests if they are given.  Since libxml2 is not
   // enabled, we must shell out to Microsoft's mt.exe tool.
   TemporaryFile user("user", "manifest");
 
   Executor e("mt.exe");
   e.add("/manifest");
   e.add(Default.path);
-  for (StringRef filename : config->manifestInput) {
+  for (StringRef filename : ctx.config.manifestInput) {
     e.add("/manifest");
     e.add(filename);
 
     // Manually add the file to the /reproduce: tar if needed.
-    if (driver->tar)
+    if (tar)
       if (auto mbOrErr = MemoryBuffer::getFile(filename))
-        driver->takeBuffer(std::move(*mbOrErr));
+        takeBuffer(std::move(*mbOrErr));
   }
   e.add("/nologo");
   e.add("/out:" + StringRef(user.path));
   e.run();
 
   return std::string(
       CHECK(MemoryBuffer::getFile(user.path), "could not open " + user.path)
           .get()
           ->getBuffer());
 }
 
-static std::string createManifestXml() {
+std::string LinkerDriver::createManifestXml() {
   std::string defaultXml = createDefaultXml();
-  if (config->manifestInput.empty())
+  if (ctx.config.manifestInput.empty())
     return defaultXml;
 
   if (windows_manifest::isAvailable())
     return createManifestXmlWithInternalMt(defaultXml);
 
   return createManifestXmlWithExternalMt(defaultXml);
 }
 
-static std::unique_ptr<WritableMemoryBuffer>
-createMemoryBufferForManifestRes(size_t manifestSize) {
+std::unique_ptr<WritableMemoryBuffer>
+LinkerDriver::createMemoryBufferForManifestRes(size_t manifestSize) {
   size_t resSize = alignTo(
       object::WIN_RES_MAGIC_SIZE + object::WIN_RES_NULL_ENTRY_SIZE +
           sizeof(object::WinResHeaderPrefix) + sizeof(object::WinResIDs) +
           sizeof(object::WinResHeaderSuffix) + manifestSize,
       object::WIN_RES_DATA_ALIGNMENT);
-  return WritableMemoryBuffer::getNewMemBuffer(resSize, config->outputFile +
+  return WritableMemoryBuffer::getNewMemBuffer(resSize, ctx.config.outputFile +
                                                             ".manifest.res");
 }
 
 static void writeResFileHeader(char *&buf) {
   memcpy(buf, COFF::WinResMagic, sizeof(COFF::WinResMagic));
   buf += sizeof(COFF::WinResMagic);
   memset(buf, 0, object::WIN_RES_NULL_ENTRY_SIZE);
   buf += object::WIN_RES_NULL_ENTRY_SIZE;
 }
 
-static void writeResEntryHeader(char *&buf, size_t manifestSize) {
+static void writeResEntryHeader(char *&buf, size_t manifestSize,
+                                int manifestID) {
   // Write the prefix.
   auto *prefix = reinterpret_cast<object::WinResHeaderPrefix *>(buf);
   prefix->DataSize = manifestSize;
   prefix->HeaderSize = sizeof(object::WinResHeaderPrefix) +
                        sizeof(object::WinResIDs) +
                        sizeof(object::WinResHeaderSuffix);
   buf += sizeof(object::WinResHeaderPrefix);
 
   // Write the Type/Name IDs.
   auto *iDs = reinterpret_cast<object::WinResIDs *>(buf);
   iDs->setType(RT_MANIFEST);
-  iDs->setName(config->manifestID);
+  iDs->setName(manifestID);
   buf += sizeof(object::WinResIDs);
 
   // Write the suffix.
   auto *suffix = reinterpret_cast<object::WinResHeaderSuffix *>(buf);
   suffix->DataVersion = 0;
   suffix->MemoryFlags = object::WIN_RES_PURE_MOVEABLE;
   suffix->Language = SUBLANG_ENGLISH_US;
   suffix->Version = 0;
   suffix->Characteristics = 0;
   buf += sizeof(object::WinResHeaderSuffix);
 }
 
 // Create a resource file containing a manifest XML.
-std::unique_ptr<MemoryBuffer> createManifestRes() {
+std::unique_ptr<MemoryBuffer> LinkerDriver::createManifestRes() {
   std::string manifest = createManifestXml();
 
   std::unique_ptr<WritableMemoryBuffer> res =
       createMemoryBufferForManifestRes(manifest.size());
 
   char *buf = res->getBufferStart();
   writeResFileHeader(buf);
-  writeResEntryHeader(buf, manifest.size());
+  writeResEntryHeader(buf, manifest.size(), ctx.config.manifestID);
 
   // Copy the manifest data into the .res file.
   std::copy(manifest.begin(), manifest.end(), buf);
   return std::move(res);
 }
 
-void createSideBySideManifest() {
-  std::string path = std::string(config->manifestFile);
+void LinkerDriver::createSideBySideManifest() {
+  std::string path = std::string(ctx.config.manifestFile);
   if (path == "")
-    path = config->outputFile + ".manifest";
+    path = ctx.config.outputFile + ".manifest";
   std::error_code ec;
   raw_fd_ostream out(path, ec, sys::fs::OF_TextWithCRLF);
   if (ec)
     fatal("failed to create manifest: " + ec.message());
   out << createManifestXml();
 }
 
 // Parse a string in the form of
 // "<name>[=<internalname>][,@ordinal[,NONAME]][,DATA][,PRIVATE]"
 // or "<name>=<dllname>.<name>".
 // Used for parsing /export arguments.
-Export parseExport(StringRef arg) {
+Export LinkerDriver::parseExport(StringRef arg) {
   Export e;
   StringRef rest;
   std::tie(e.name, rest) = arg.split(",");
   if (e.name.empty())
     goto err;
 
   if (e.name.contains('=')) {
     StringRef x, y;
while (!rest.empty()) {
     goto err;
   }
   return e;
 
 err:
   fatal("invalid /export: " + arg);
 }
 
-static StringRef undecorate(StringRef sym) {
-  if (config->machine != I386)
+static StringRef undecorate(COFFLinkerContext &ctx, StringRef sym) {
+  if (ctx.config.machine != I386)
     return sym;
   // In MSVC mode, a fully decorated stdcall function is exported
   // as-is with the leading underscore (with type IMPORT_NAME).
   // In MinGW mode, a decorated stdcall function gets the underscore
   // removed, just like normal cdecl functions.
-  if (sym.startswith("_") && sym.contains('@') && !config->mingw)
+  if (sym.startswith("_") && sym.contains('@') && !ctx.config.mingw)
     return sym;
   return sym.startswith("_") ? sym.substr(1) : sym;
 }
 
 // Convert stdcall/fastcall style symbols into unsuffixed symbols,
 // with or without a leading underscore. (MinGW specific.)
 static StringRef killAt(StringRef sym, bool prefix) {
   if (sym.empty())
static StringRef killAt(StringRef sym, bool prefix) {
   sym = sym.substr(1);
   if (prefix)
     sym = saver().save("_" + sym);
   return sym;
 }
 
 // Performs error checking on all /export arguments.
 // It also sets ordinals.
-void fixupExports() {
+void LinkerDriver::fixupExports() {
   // Symbol ordinals must be unique.
   std::set<uint16_t> ords;
-  for (Export &e : config->exports) {
+  for (Export &e : ctx.config.exports) {
     if (e.ordinal == 0)
       continue;
     if (!ords.insert(e.ordinal).second)
       fatal("duplicate export ordinal: " + e.name);
   }
 
-  for (Export &e : config->exports) {
+  for (Export &e : ctx.config.exports) {
     if (!e.forwardTo.empty()) {
-      e.exportName = undecorate(e.name);
+      e.exportName = undecorate(ctx, e.name);
     } else {
-      e.exportName = undecorate(e.extName.empty() ? e.name : e.extName);
+      e.exportName = undecorate(ctx, e.extName.empty() ? e.name : e.extName);
     }
   }
 
-  if (config->killAt && config->machine == I386) {
-    for (Export &e : config->exports) {
+  if (ctx.config.killAt && ctx.config.machine == I386) {
+    for (Export &e : ctx.config.exports) {
       e.name = killAt(e.name, true);
       e.exportName = killAt(e.exportName, false);
       e.extName = killAt(e.extName, true);
       e.symbolName = killAt(e.symbolName, true);
     }
   }
 
   // Uniquefy by name.
-  DenseMap<StringRef, Export *> map(config->exports.size());
+  DenseMap<StringRef, Export *> map(ctx.config.exports.size());
   std::vector<Export> v;
-  for (Export &e : config->exports) {
+  for (Export &e : ctx.config.exports) {
     auto pair = map.insert(std::make_pair(e.exportName, &e));
     bool inserted = pair.second;
     if (inserted) {
       v.push_back(e);
       continue;
     }
     Export *existing = pair.first->second;
     if (e == *existing || e.name != existing->name)
       continue;
     warn("duplicate /export option: " + e.name);
   }
-  config->exports = std::move(v);
+  ctx.config.exports = std::move(v);
 
   // Sort by name.
-  std::sort(config->exports.begin(), config->exports.end(),
+  std::sort(ctx.config.exports.begin(), ctx.config.exports.end(),
             [](const Export &a, const Export &b) {
               return a.exportName < b.exportName;
             });
 }
 
-void assignExportOrdinals() {
+void LinkerDriver::assignExportOrdinals() {
   // Assign unique ordinals if default (= 0).
   uint32_t max = 0;
-  for (Export &e : config->exports)
+  for (Export &e : ctx.config.exports)
     max = std::max(max, (uint32_t)e.ordinal);
-  for (Export &e : config->exports)
+  for (Export &e : ctx.config.exports)
     if (e.ordinal == 0)
       e.ordinal = ++max;
   if (max > std::numeric_limits<uint16_t>::max())
     fatal("too many exported symbols (max " +
           Twine(std::numeric_limits<uint16_t>::max()) + ")");
 }
 
 // Parses a string in the form of "key=value" and check
 // if value matches previous values for the same key.
-void checkFailIfMismatch(StringRef arg, InputFile *source) {
+void LinkerDriver::checkFailIfMismatch(StringRef arg, InputFile *source) {
   StringRef k, v;
   std::tie(k, v) = arg.split('=');
   if (k.empty() || v.empty())
     fatal("/failifmismatch: invalid argument: " + arg);
-  std::pair<StringRef, InputFile *> existing = config->mustMatch[k];
+  std::pair<StringRef, InputFile *> existing = ctx.config.mustMatch[k];
   if (!existing.first.empty() && v != existing.first) {
     std::string sourceStr = source ? toString(source) : "cmd-line";
     std::string existingStr =
         existing.second ? toString(existing.second) : "cmd-line";
     fatal("/failifmismatch: mismatch detected for '" + k + "':\n>>> " +
           existingStr + " has value " + existing.first + "\n>>> " + sourceStr +
           " has value " + v);
   }
-  config->mustMatch[k] = {v, source};
+  ctx.config.mustMatch[k] = {v, source};
 }
 
 // Convert Windows resource files (.res files) to a .obj file.
 // Does what cvtres.exe does, but in-process and cross-platform.
-MemoryBufferRef convertResToCOFF(ArrayRef<MemoryBufferRef> mbs,
+MemoryBufferRef LinkerDriver::convertResToCOFF(ArrayRef<MemoryBufferRef> mbs,
                                                ArrayRef<ObjFile *> objs) {
-  object::WindowsResourceParser parser(/* MinGW */ config->mingw);
+  object::WindowsResourceParser parser(/* MinGW */ ctx.config.mingw);
 
   std::vector<std::string> duplicates;
   for (MemoryBufferRef mb : mbs) {
     std::unique_ptr<object::Binary> bin = check(object::createBinary(mb));
     object::WindowsResource *rf = dyn_cast<object::WindowsResource>(bin.get());
     if (!rf)
       fatal("cannot compile non-resource file as resource");
 
     if (auto ec = parser.parse(rf, duplicates))
       fatal(toString(std::move(ec)));
   }
 
   // Note: This processes all .res files before all objs. Ideally they'd be
   // handled in the same order they were linked (to keep the right one, if
   // there are duplicates that are tolerated due to forceMultipleRes).
   for (ObjFile *f : objs) {
     object::ResourceSectionRef rsf;
     if (auto ec = rsf.load(f->getCOFFObj()))
       fatal(toString(f) + ": " + toString(std::move(ec)));
 
     if (auto ec = parser.parse(rsf, f->getName(), duplicates))
       fatal(toString(std::move(ec)));
   }
 
-  if (config->mingw)
+  if (ctx.config.mingw)
     parser.cleanUpManifests(duplicates);
 
   for (const auto &dupeDiag : duplicates)
-    if (config->forceMultipleRes)
+    if (ctx.config.forceMultipleRes)
       warn(dupeDiag);
     else
       error(dupeDiag);
 
   Expected<std::unique_ptr<MemoryBuffer>> e =
-      llvm::object::writeWindowsResourceCOFF(config->machine, parser,
-                                             config->timestamp);
+      llvm::object::writeWindowsResourceCOFF(ctx.config.machine, parser,
+                                             ctx.config.timestamp);
   if (!e)
     fatal("failed to write .res to COFF: " + toString(e.takeError()));
 
   MemoryBufferRef mbref = **e;
   make<std::unique_ptr<MemoryBuffer>>(std::move(*e)); // take ownership
   return mbref;
 }
 
#define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12)      \
   {X1, X2, X10,         X11,         OPT_##ID, llvm::opt::Option::KIND##Class, \
    X9, X8, OPT_##GROUP, OPT_##ALIAS, X7,       X12},
 #include "Options.inc"
 #undef OPTION
 };
 
 COFFOptTable::COFFOptTable() : OptTable(infoTable, true) {}
 
-COFFOptTable optTable;
-
 // Set color diagnostics according to --color-diagnostics={auto,always,never}
 // or --no-color-diagnostics flags.
 static void handleColorDiagnostics(opt::InputArgList &args) {
   auto *arg = args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq,
                               OPT_no_color_diagnostics);
   if (!arg)
     return;
   if (arg->getOption().getID() == OPT_color_diagnostics) {
if (auto *arg = args.getLastArg(OPT_rsp_quoting)) {
     if (s == "windows")
       return cl::TokenizeWindowsCommandLine;
     return cl::TokenizeGNUCommandLine;
   }
   // The COFF linker always defaults to Windows quoting.
   return cl::TokenizeWindowsCommandLine;
 }
 
+ArgParser::ArgParser(COFFLinkerContext &c) : ctx(c) {}
+
 // Parses a given list of options.
 opt::InputArgList ArgParser::parse(ArrayRef<const char *> argv) {
   // Make InputArgList from string vectors.
   unsigned missingIndex;
   unsigned missingCount;
 
   // We need to get the quoting style for response files before parsing all
   // options so we parse here before and ignore all the options but
   // --rsp-quoting and /lldignoreenv.
   // (This means --rsp-quoting can't be added through %LINK%.)
-  opt::InputArgList args = optTable.ParseArgs(argv, missingIndex, missingCount);
+  opt::InputArgList args =
+      ctx.optTable.ParseArgs(argv, missingIndex, missingCount);
 
   // Expand response files (arguments in the form of @<filename>) and insert
   // flags from %LINK% and %_LINK_%, and then parse the argument again.
   SmallVector<const char *, 256> expandedArgv(argv.data(),
                                               argv.data() + argv.size());
   if (!args.hasArg(OPT_lldignoreenv))
     addLINK(expandedArgv);
   cl::ExpandResponseFiles(saver(), getQuotingStyle(args), expandedArgv);
-  args = optTable.ParseArgs(makeArrayRef(expandedArgv).drop_front(),
+  args = ctx.optTable.ParseArgs(makeArrayRef(expandedArgv).drop_front(),
                                 missingIndex, missingCount);
 
   // Print the real command line if response files are expanded.
   if (args.hasArg(OPT_verbose) && argv.size() != expandedArgv.size()) {
     std::string msg = "Command line:";
     for (const char *s : expandedArgv)
       msg += " " + std::string(s);
     message(msg);
   }
 
   // Save the command line after response file expansion so we can write it to
   // the PDB if necessary.
-  config->argv = {expandedArgv.begin(), expandedArgv.end()};
+  ctx.config.argv = {expandedArgv.begin(), expandedArgv.end()};
 
   // Handle /WX early since it converts missing argument warnings to errors.
   errorHandler().fatalWarnings = args.hasFlag(OPT_WX, OPT_WX_no, false);
 
   if (missingCount)
     fatal(Twine(args.getArgString(missingIndex)) + ": missing argument");
 
   handleColorDiagnostics(args);
 
   for (opt::Arg *arg : args.filtered(OPT_UNKNOWN)) {
     std::string nearest;
-    if (optTable.findNearest(arg->getAsString(args), nearest) > 1)
+    if (ctx.optTable.findNearest(arg->getAsString(args), nearest) > 1)
       warn("ignoring unknown argument '" + arg->getAsString(args) + "'");
     else
       warn("ignoring unknown argument '" + arg->getAsString(args) +
            "', did you mean '" + nearest + "'");
   }
 
   if (args.hasArg(OPT_lib))
     warn("ignoring /lib since it's not the first argument");
else {
       rest.push_back(HasNul ? tok.data() : saver().save(tok).data());
     }
   }
 
   // Make InputArgList from unparsed string vectors.
   unsigned missingIndex;
   unsigned missingCount;
 
-  result.args = optTable.ParseArgs(rest, missingIndex, missingCount);
+  result.args = ctx.optTable.ParseArgs(rest, missingIndex, missingCount);
 
   if (missingCount)
     fatal(Twine(result.args.getArgString(missingIndex)) + ": missing argument");
   for (auto *arg : result.args.filtered(OPT_UNKNOWN))
     warn("ignoring unknown argument: " + arg->getAsString(result.args));
   return result;
 }
 

 }
 
 std::vector<const char *> ArgParser::tokenize(StringRef s) {
   SmallVector<const char *, 16> tokens;
   cl::TokenizeWindowsCommandLine(s, saver(), tokens);
   return std::vector<const char *>(tokens.begin(), tokens.end());
 }
 
-void printHelp(const char *argv0) {
-  optTable.printHelp(lld::outs(),
+void LinkerDriver::printHelp(const char *argv0) {
+  ctx.optTable.printHelp(lld::outs(),
                          (std::string(argv0) + " [options] file...").c_str(),
                          "LLVM Linker", false);
 }
 
 } // namespace coff
 } // namespace lld

lld/COFF/ICF.h

 //===- ICF.h --------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_ICF_H
 #define LLD_COFF_ICF_H
 
-#include "Config.h"
-#include "lld/Common/LLVM.h"
-#include "llvm/ADT/ArrayRef.h"
-
 namespace lld {
 namespace coff {
 
-class Chunk;
 class COFFLinkerContext;
 
-void doICF(COFFLinkerContext &ctx, ICFLevel);
+void doICF(COFFLinkerContext &ctx);
 
 } // namespace coff
 } // namespace lld
 
 #endif

lld/COFF/ICF.cpp

 
 using namespace llvm;
 
 namespace lld {
 namespace coff {
 
 class ICF {
 public:
-  ICF(COFFLinkerContext &c, ICFLevel icfLevel) : icfLevel(icfLevel), ctx(c){};
+  ICF(COFFLinkerContext &c) : ctx(c){};
   void run();
 
 private:
   void segregate(size_t begin, size_t end, bool constant);
 
   bool assocEquals(const SectionChunk *a, const SectionChunk *b);
 
   bool equalsConstant(const SectionChunk *a, const SectionChunk *b);
   bool equalsVariable(const SectionChunk *a, const SectionChunk *b);
 
   bool isEligible(SectionChunk *c);
 
   size_t findBoundary(size_t begin, size_t end);
 
   void forEachClassRange(size_t begin, size_t end,
                          std::function<void(size_t, size_t)> fn);
 
   void forEachClass(std::function<void(size_t, size_t)> fn);
 
   std::vector<SectionChunk *> chunks;
   int cnt = 0;
   std::atomic<bool> repeat = {false};
-  ICFLevel icfLevel = ICFLevel::All;
 
   COFFLinkerContext &ctx;
 };
 
 // Returns true if section S is subject of ICF.
 //
 // Microsoft's documentation
 // (https://msdn.microsoft.com/en-us/library/bxwfs976.aspx; visited April
 // 2017) says that /opt:icf folds both functions and read-only data.
 // Despite that, the MSVC linker folds only functions. We found
 // a few instances of programs that are not safe for data merging.
 // Therefore, we merge only functions just like the MSVC tool. However, we also
 // merge read-only sections in a couple of cases where the address of the
 // section is insignificant to the user program and the behaviour matches that
 // of the Visual C++ linker.
 bool ICF::isEligible(SectionChunk *c) {
   // Non-comdat chunks, dead chunks, and writable chunks are not eligible.
   bool writable = c->getOutputCharacteristics() & llvm::COFF::IMAGE_SCN_MEM_WRITE;
   if (!c->isCOMDAT() || !c->live || writable)
     return false;
 
   // Under regular (not safe) ICF, all code sections are eligible.
-  if ((icfLevel == ICFLevel::All) &&
+  if ((ctx.config.doICF == ICFLevel::All) &&
       c->getOutputCharacteristics() & llvm::COFF::IMAGE_SCN_MEM_EXECUTE)
     return true;
 
   // .pdata and .xdata unwind info sections are eligible.
   StringRef outSecName = c->getSectionName().split('$').first;
   if (outSecName == ".pdata" || outSecName == ".xdata")
     return true;
 
forEachClass([&](size_t begin, size_t end) {
     for (size_t i = begin + 1; i < end; ++i) {
       log("  Removed " + chunks[i]->getDebugName());
       chunks[begin]->replace(chunks[i]);
     }
   });
 }
 
 // Entry point to ICF.
-void doICF(COFFLinkerContext &ctx, ICFLevel icfLevel) {
-  ICF(ctx, icfLevel).run();
-}
+void doICF(COFFLinkerContext &ctx) { ICF(ctx).run(); }
 
 } // namespace coff
 } // namespace lld

lld/COFF/InputFiles.h

public:
   TpiSource *debugTypesObj = nullptr;
 };
 
 // This type represents import library members that contain DLL names
 // and symbols exported from the DLLs. See Microsoft PE/COFF spec. 7
 // for details about the format.
 class ImportFile : public InputFile {
 public:
-  explicit ImportFile(COFFLinkerContext &ctx, MemoryBufferRef m)
-      : InputFile(ctx, ImportKind, m) {}
+  explicit ImportFile(COFFLinkerContext &ctx, MemoryBufferRef m);
 
   static bool classof(const InputFile *f) { return f->kind() == ImportKind; }
 
   Symbol *impSym = nullptr;
   Symbol *thunkSym = nullptr;
   std::string dllName;
 
 private:
   void parse() override;
 
 public:
   StringRef externalName;
   const coff_import_header *hdr;
   Chunk *location = nullptr;
 
   // We want to eliminate dllimported symbols if no one actually refers to them.
   // These "Live" bits are used to keep track of which import library members
   // are actually in use.
   //
   // If the Live bit is turned off by MarkLive, Writer will ignore dllimported
   // symbols provided by this import library member. We also track whether the
   // imported symbol is used separately from whether the thunk is used in order
   // to avoid creating unnecessary thunks.
-  bool live = !config->doGC;
-  bool thunkLive = !config->doGC;
+  bool live;
+  bool thunkLive;
 };
 
 // Used for LTO.
 class BitcodeFile : public InputFile {
 public:
   explicit BitcodeFile(COFFLinkerContext &ctx, MemoryBufferRef mb,
                        StringRef archiveName, uint64_t offsetInArchive,
                        bool lazy);
private:
   std::unique_ptr<COFFObjectFile> coffObj;
   llvm::StringSet<> seen;
 };
 
 inline bool isBitcode(MemoryBufferRef mb) {
   return identify_magic(mb.getBuffer()) == llvm::file_magic::bitcode;
 }
 
-std::string replaceThinLTOSuffix(StringRef path);
+// Convenience class for initializing a coff_section with specific flags.
+class FakeSection {
+public:
+  FakeSection(int c) { section.Characteristics = c; }
+
+  coff_section section;
+};
+
+std::string replaceThinLTOSuffix(StringRef path, StringRef suffix,
+                                 StringRef repl);
 } // namespace coff
 
 std::string toString(const coff::InputFile *file);
 } // namespace lld
 
 #endif

lld/COFF/InputFiles.cpp

std::string lld::toString(const coff::InputFile *file) {
   return (getBasename(file->parentName) + "(" + getBasename(file->getName()) +
           ")")
       .str();
 }
 
 /// Checks that Source is compatible with being a weak alias to Target.
 /// If Source is Undefined and has no weak alias set, makes it a weak
 /// alias to Target.
-static void checkAndSetWeakAlias(SymbolTable *symtab, InputFile *f,
+static void checkAndSetWeakAlias(COFFLinkerContext &ctx, InputFile *f,
                                  Symbol *source, Symbol *target) {
   if (auto *u = dyn_cast<Undefined>(source)) {
     if (u->weakAlias && u->weakAlias != target) {
       // Weak aliases as produced by GCC are named in the form
       // .weak.<weaksymbol>.<othersymbol>, where <othersymbol> is the name
       // of another symbol emitted near the weak symbol.
       // Just use the definition from the first object file that defined
       // this weak symbol.
-      if (config->mingw)
+      if (ctx.config.mingw)
         return;
-      symtab->reportDuplicate(source, f);
+      ctx.symtab.reportDuplicate(source, f);
     }
     u->weakAlias = target;
   }
 }
 
 static bool ignoredSymbolName(StringRef name) {
   return name == "@feat.00" || name == "@comp.id";
 }
void ArchiveFile::parse() {
   for (const Archive::Symbol &sym : file->symbols())
     ctx.symtab.addLazyArchive(this, sym);
 }
 
 // Returns a buffer pointing to a member file containing a given symbol.
 void ArchiveFile::addMember(const Archive::Symbol &sym) {
   const Archive::Child &c =
       CHECK(sym.getMember(),
-            "could not get the member for symbol " + toCOFFString(sym));
+            "could not get the member for symbol " + ctx.toCOFFString(sym));
 
   // Return an empty buffer if we have already returned the same buffer.
   if (!seen.insert(c.getChildOffset()).second)
     return;
 
-  driver->enqueueArchiveMember(c, sym, getName());
+  ctx.driver.enqueueArchiveMember(c, sym, getName());
 }
 
 std::vector<MemoryBufferRef> lld::coff::getArchiveMembers(Archive *file) {
   std::vector<MemoryBufferRef> v;
   Error err = Error::success();
   for (const Archive::Child &c : file->children(err)) {
     MemoryBufferRef mbref =
         CHECK(c.getMemoryBufferRef(),
SectionChunk *ObjFile::readSection(uint32_t sectionNumber,
   // DWARF sections don't need any special handling from the perspective
   // of the linker; they are just a data section containing relocations.
   // We can just link them to complete debug info.
   //
   // CodeView needs linker support. We need to interpret debug info,
   // and then write it to a separate .pdb file.
 
   // Ignore DWARF debug info unless /debug is given.
-  if (!config->debug && name.startswith(".debug_"))
+  if (!ctx.config.debug && name.startswith(".debug_"))
     return nullptr;
 
   if (sec->Characteristics & llvm::COFF::IMAGE_SCN_LNK_REMOVE)
     return nullptr;
   auto *c = make<SectionChunk>(this, sec);
   if (def)
     c->checksum = def->CheckSum;
 
   // CodeView sections are stored to a different vector because they are not
   // linked in the regular manner.
   if (c->isCodeView())
     debugChunks.push_back(c);
   else if (name == ".gfids$y")
     guardFidChunks.push_back(c);
   else if (name == ".giats$y")
     guardIATChunks.push_back(c);
   else if (name == ".gljmp$y")
     guardLJmpChunks.push_back(c);
   else if (name == ".gehcont$y")
     guardEHContChunks.push_back(c);
   else if (name == ".sxdata")
     sxDataChunks.push_back(c);
-  else if (config->tailMerge && sec->NumberOfRelocations == 0 &&
+  else if (ctx.config.tailMerge && sec->NumberOfRelocations == 0 &&
            name == ".rdata" && leaderName.startswith("??_C@"))
     // COFF sections that look like string literal sections (i.e. no
     // relocations, in .rdata, leader symbol name matches the MSVC name mangling
     // for string literals) are subject to string tail merging.
     MergeChunk::addSection(ctx, c);
   else if (name == ".rsrc" || name.startswith(".rsrc$"))
     resourceChunks.push_back(c);
   else
if (sym.isExternal()) {
     if (sc)
       return ctx.symtab.addRegular(this, name, sym.getGeneric(), sc,
                                    sym.getValue());
     // For MinGW symbols named .weak.* that point to a discarded section,
     // don't create an Undefined symbol. If nothing ever refers to the symbol,
     // everything should be fine. If something actually refers to the symbol
     // (e.g. the undefined weak alias), linking will fail due to undefined
     // references at the end.
-    if (config->mingw && name.startswith(".weak."))
+    if (ctx.config.mingw && name.startswith(".weak."))
       return nullptr;
     return ctx.symtab.addUndefined(name, this, false);
   }
   if (sc)
     return make<DefinedRegular>(this, /*Name*/ "", /*IsCOMDAT*/ false,
                                 /*IsExternal*/ false, sym.getGeneric(), sc);
   return nullptr;
 }
if (coffSym.isUndefined()) {
       symbols[i] = createUndefined(coffSym);
     } else if (coffSym.isWeakExternal()) {
       symbols[i] = createUndefined(coffSym);
       uint32_t tagIndex = coffSym.getAux<coff_aux_weak_external>()->TagIndex;
       weakAliases.emplace_back(symbols[i], tagIndex);
     } else if (Optional<Symbol *> optSym =
                    createDefined(coffSym, comdatDefs, prevailingComdat)) {
       symbols[i] = *optSym;
-      if (config->mingw && prevailingComdat)
+      if (ctx.config.mingw && prevailingComdat)
         recordPrevailingSymbolForMingw(coffSym, prevailingSectionMap);
     } else {
       // createDefined() returns None if a symbol belongs to a section that
       // was pending at the point when the symbol was read. This can happen in
       // two cases:
       // 1) section definition symbol for a comdat leader;
       // 2) symbol belongs to a comdat section associated with another section.
       // In both of these cases, we can expect the section to be resolved by
       // the time we finish visiting the remaining symbols in the symbol
       // table. So we postpone the handling of this symbol until that time.
       pendingIndexes.push_back(i);
     }
     i += coffSym.getNumberOfAuxSymbols();
   }
 
   for (uint32_t i : pendingIndexes) {
     COFFSymbolRef sym = check(coffObj->getSymbol(i));
     if (const coff_aux_section_definition *def = sym.getSectionDefinition()) {
       if (def->Selection == IMAGE_COMDAT_SELECT_ASSOCIATIVE)
         readAssociativeDefinition(sym, def);
-      else if (config->mingw)
+      else if (ctx.config.mingw)
         maybeAssociateSEHForMingw(sym, def, prevailingSectionMap);
     }
     if (sparseChunks[sym.getSectionNumber()] == pendingComdat) {
       StringRef name = check(coffObj->getSymbolName(sym));
       log("comdat section " + name +
           " without leader and unassociated, discarding");
       continue;
     }
     symbols[i] = createRegular(sym);
   }
 
   for (auto &kv : weakAliases) {
     Symbol *sym = kv.first;
     uint32_t idx = kv.second;
-    checkAndSetWeakAlias(&ctx.symtab, this, sym, symbols[idx]);
+    checkAndSetWeakAlias(ctx, this, sym, symbols[idx]);
   }
 
   // Free the memory used by sparseChunks now that symbol loading is finished.
   decltype(sparseChunks)().swap(sparseChunks);
 }
 
 Symbol *ObjFile::createUndefined(COFFSymbolRef sym) {
   StringRef name = check(coffObj->getSymbolName(sym));
if ((selection == IMAGE_COMDAT_SELECT_ANY &&
     // compiled with each flag, "any" and "largest" are merged as "largest".
     leaderSelection = selection = IMAGE_COMDAT_SELECT_LARGEST;
   }
 
   // GCCs __declspec(selectany) doesn't actually pick "any" but "same size as".
   // Clang on the other hand picks "any". To be able to link two object files
   // with a __declspec(selectany) declaration, one compiled with gcc and the
   // other with clang, we merge them as proper "same size as"
-  if (config->mingw && ((selection == IMAGE_COMDAT_SELECT_ANY &&
+  if (ctx.config.mingw && ((selection == IMAGE_COMDAT_SELECT_ANY &&
                             leaderSelection == IMAGE_COMDAT_SELECT_SAME_SIZE) ||
                            (selection == IMAGE_COMDAT_SELECT_SAME_SIZE &&
                             leaderSelection == IMAGE_COMDAT_SELECT_ANY))) {
     leaderSelection = selection = IMAGE_COMDAT_SELECT_SAME_SIZE;
   }
 
   // Other than that, comdat selections must match.  This is a bit more
   // strict than link.exe which allows merging "any" and "largest" if "any"
   // is the first symbol the linker sees, and it allows merging "largest"
   // with everything (!) if "largest" is the first symbol the linker sees.
   // Making this symmetric independent of which selection is seen first
   // seems better though.
   // (This behavior matches ModuleLinker::getComdatResult().)
   if (selection != leaderSelection) {
-    log(("conflicting comdat type for " + toString(*leader) + ": " +
+    log(("conflicting comdat type for " + ctx.toString(*leader) + ": " +
          Twine((int)leaderSelection) + " in " + toString(leader->getFile()) +
          " and " + Twine((int)selection) + " in " + toString(this))
             .str());
     ctx.symtab.reportDuplicate(leader, this);
     return;
   }
 
   switch (selection) {
   case IMAGE_COMDAT_SELECT_NODUPLICATES:
     ctx.symtab.reportDuplicate(leader, this);
     break;
 
   case IMAGE_COMDAT_SELECT_ANY:
     // Nothing to do.
     break;
 
   case IMAGE_COMDAT_SELECT_SAME_SIZE:
     if (leaderChunk->getSize() != getSection(sym)->SizeOfRawData) {
-      if (!config->mingw) {
+      if (!ctx.config.mingw) {
         ctx.symtab.reportDuplicate(leader, this);
       } else {
         const coff_aux_section_definition *leaderDef = nullptr;
         if (leaderChunk->file)
           leaderDef = findSectionDef(leaderChunk->file->getCOFFObj(),
                                      leaderChunk->getSectionNumber());
         if (!leaderDef || leaderDef->Length != def->Length)
           ctx.symtab.reportDuplicate(leader, this);
if (sym.isAbsolute()) {
     if (name == "@feat.00")
       feat00Flags = sym.getValue();
     // Skip special symbols.
     if (ignoredSymbolName(name))
       return nullptr;
 
     if (sym.isExternal())
       return ctx.symtab.addAbsolute(name, sym);
-    return make<DefinedAbsolute>(name, sym);
+    return make<DefinedAbsolute>(ctx, name, sym);
   }
 
   int32_t sectionNumber = sym.getSectionNumber();
   if (sectionNumber == llvm::COFF::IMAGE_SYM_DEBUG)
     return nullptr;
 
   if (llvm::COFF::isReservedSectionNumber(sectionNumber))
     fatal(toString(this) + ": " + getName() +

 // Depending on the compilation flags, OBJs can refer to external files,
 // necessary to merge this OBJ into the final PDB. We currently support two
 // types of external files: Precomp/PCH OBJs, when compiling with /Yc and /Yu.
 // And PDB type servers, when compiling with /Zi. This function extracts these
 // dependencies and makes them available as a TpiSource interface (see
 // DebugTypes.h). Both cases only happen with cl.exe: clang-cl produces regular
 // output even with /Yc and /Yu and with /Zi.
 void ObjFile::initializeDependencies() {
-  if (!config->debug)
+  if (!ctx.config.debug)
     return;
 
   bool isPCH = false;
 
   ArrayRef<uint8_t> data = getDebugSection(".debug$P");
   if (!data.empty())
     isPCH = true;
   else

 // number for where the variable was defined.
 Optional<std::pair<StringRef, uint32_t>>
 ObjFile::getVariableLocation(StringRef var) {
   if (!dwarf) {
     dwarf = make<DWARFCache>(DWARFContext::create(*getCOFFObj()));
     if (!dwarf)
       return None;
   }
-  if (config->machine == I386)
+  if (ctx.config.machine == I386)
     var.consume_front("_");
   Optional<std::pair<std::string, unsigned>> ret = dwarf->getVariableLoc(var);
   if (!ret)
     return None;
   return std::make_pair(saver().save(ret->first), ret->second);
 }
 
 // Used only for DWARF debug info, which is not common (except in MinGW

 
 void ObjFile::enqueuePdbFile(StringRef path, ObjFile *fromFile) {
   auto p = findPdbPath(path.str(), fromFile);
   if (!p)
     return;
   auto it = ctx.pdbInputFileInstances.emplace(*p, nullptr);
   if (!it.second)
     return; // already scheduled for load
-  driver->enqueuePDB(*p);
+  ctx.driver.enqueuePDB(*p);
 }
 
+ImportFile::ImportFile(COFFLinkerContext &ctx, MemoryBufferRef m)
+    : InputFile(ctx, ImportKind, m), live(!ctx.config.doGC), thunkLive(live) {}
+
 void ImportFile::parse() {
   const char *buf = mb.getBufferStart();
   const auto *hdr = reinterpret_cast<const coff_import_header *>(buf);
 
   // Check if the total size is valid.
   if (mb.getBufferSize() != sizeof(*hdr) + hdr->SizeOfData)
     fatal("broken import library");
 
thunkSym = ctx.symtab.addImportThunk(
         name, cast_or_null<DefinedImportData>(impSym), hdr->Machine);
 }
 
 BitcodeFile::BitcodeFile(COFFLinkerContext &ctx, MemoryBufferRef mb,
                          StringRef archiveName, uint64_t offsetInArchive,
                          bool lazy)
     : InputFile(ctx, BitcodeKind, mb, lazy) {
   std::string path = mb.getBufferIdentifier().str();
-  if (config->thinLTOIndexOnly)
-    path = replaceThinLTOSuffix(mb.getBufferIdentifier());
+  if (ctx.config.thinLTOIndexOnly)
+    path = replaceThinLTOSuffix(mb.getBufferIdentifier(),
+                                ctx.config.thinLTOObjectSuffixReplace.first,
+                                ctx.config.thinLTOObjectSuffixReplace.second);
 
   // ThinLTO assumes that all MemoryBufferRefs given to it have a unique
   // name. If two archives define two members with the same name, this
   // causes a collision which result in only one of the objects being taken
   // into consideration at LTO time (which very likely causes undefined
   // symbols later in the link stage). So we append file offset to make
   // filename unique.
   MemoryBufferRef mbref(mb.getBuffer(),
                         saver().save(archiveName.empty()
                                          ? path
                                          : archiveName +
                                                sys::path::filename(path) +
                                                utostr(offsetInArchive)));
 
   obj = check(lto::InputFile::create(mbref));
 }
 
 BitcodeFile::~BitcodeFile() = default;
 
-namespace {
-// Convenience class for initializing a coff_section with specific flags.
-class FakeSection {
-public:
-  FakeSection(int c) { section.Characteristics = c; }
-
-  coff_section section;
-};
-
-// Convenience class for initializing a SectionChunk with specific flags.
-class FakeSectionChunk {
-public:
-  FakeSectionChunk(const coff_section *section) : chunk(nullptr, section) {
-    // Comdats from LTO files can't be fully treated as regular comdats
-    // at this point; we don't know what size or contents they are going to
-    // have, so we can't do proper checking of such aspects of them.
-    chunk.selection = IMAGE_COMDAT_SELECT_ANY;
-  }
-
-  SectionChunk chunk;
-};
-
-FakeSection ltoTextSection(IMAGE_SCN_MEM_EXECUTE);
-FakeSection ltoDataSection(IMAGE_SCN_CNT_INITIALIZED_DATA);
-FakeSectionChunk ltoTextSectionChunk(&ltoTextSection.section);
-FakeSectionChunk ltoDataSectionChunk(&ltoDataSection.section);
-} // namespace
-
 void BitcodeFile::parse() {
   llvm::StringSaver &saver = lld::saver();
+
   std::vector<std::pair<Symbol *, bool>> comdat(obj->getComdatTable().size());
   for (size_t i = 0; i != obj->getComdatTable().size(); ++i)
     // FIXME: Check nodeduplicate
     comdat[i] =
         ctx.symtab.addComdat(this, saver.save(obj->getComdatTable()[i].first));
   for (const lto::InputFile::Symbol &objSym : obj->symbols()) {
     StringRef symName = saver.save(objSym.getName());
     int comdatIndex = objSym.getComdatIndex();
     Symbol *sym;
     SectionChunk *fakeSC = nullptr;
     if (objSym.isExecutable())
-      fakeSC = &ltoTextSectionChunk.chunk;
+      fakeSC = &ctx.ltoTextSectionChunk->chunk;
     else
-      fakeSC = &ltoDataSectionChunk.chunk;
+      fakeSC = &ctx.ltoDataSectionChunk->chunk;
     if (objSym.isUndefined()) {
       sym = ctx.symtab.addUndefined(symName, this, false);
     } else if (objSym.isCommon()) {
       sym = ctx.symtab.addCommon(this, symName, objSym.getCommonSize());
     } else if (objSym.isWeak() && objSym.isIndirect()) {
       // Weak external.
       sym = ctx.symtab.addUndefined(symName, this, true);
       std::string fallback = std::string(objSym.getCOFFWeakExternalFallback());
       Symbol *alias = ctx.symtab.addUndefined(saver.save(fallback));
-      checkAndSetWeakAlias(&ctx.symtab, this, sym, alias);
+      checkAndSetWeakAlias(ctx, this, sym, alias);
     } else if (comdatIndex != -1) {
       if (symName == obj->getComdatTable()[comdatIndex].first) {
         sym = comdat[comdatIndex].first;
         if (cast<DefinedRegular>(sym)->data == nullptr)
           cast<DefinedRegular>(sym)->data = &fakeSC->repl;
       } else if (comdat[comdatIndex].second) {
         sym = ctx.symtab.addRegular(this, symName, nullptr, fakeSC);
       } else {
         sym = ctx.symtab.addUndefined(symName, this, false);
       }
     } else {
       sym = ctx.symtab.addRegular(this, symName, nullptr, fakeSC);
     }
     symbols.push_back(sym);
     if (objSym.isUsed())
-      config->gcroot.push_back(sym);
+      ctx.config.gcroot.push_back(sym);
   }
   directives = obj->getCOFFLinkerOpts();
 }
 
 void BitcodeFile::parseLazy() {
   for (const lto::InputFile::Symbol &sym : obj->symbols())
     if (!sym.isUndefined())
       ctx.symtab.addLazyObject(this, sym.getName());
case Triple::arm:
     return ARMNT;
   case Triple::aarch64:
     return ARM64;
   default:
     return IMAGE_FILE_MACHINE_UNKNOWN;
   }
 }
 
-std::string lld::coff::replaceThinLTOSuffix(StringRef path) {
-  StringRef suffix = config->thinLTOObjectSuffixReplace.first;
-  StringRef repl = config->thinLTOObjectSuffixReplace.second;
-
+std::string lld::coff::replaceThinLTOSuffix(StringRef path, StringRef suffix,
+                                            StringRef repl) {
   if (path.consume_back(suffix))
     return (path + repl).str();
   return std::string(path);
 }
 
 static bool isRVACode(COFFObjectFile *coffObj, uint64_t rva, InputFile *file) {
   for (size_t i = 1, e = coffObj->getNumberOfSections(); i <= e; i++) {
     const coff_section *sec = CHECK(coffObj->getSection(i), file);

lld/COFF/LLDMapFile.cpp

std::stable_sort(v.begin(), v.end(), [](DefinedRegular *a, DefinedRegular *b) {
       return a->getRVA() < b->getRVA();
     });
   }
   return ret;
 }
 
 // Construct a map from symbols to their stringified representations.
 static DenseMap<DefinedRegular *, std::string>
-getSymbolStrings(ArrayRef<DefinedRegular *> syms) {
+getSymbolStrings(const COFFLinkerContext &ctx,
+                 ArrayRef<DefinedRegular *> syms) {
   std::vector<std::string> str(syms.size());
   parallelForEachN((size_t)0, syms.size(), [&](size_t i) {
     raw_string_ostream os(str[i]);
     writeHeader(os, syms[i]->getRVA(), 0, 0);
-    os << indent16 << toString(*syms[i]);
+    os << indent16 << ctx.toString(*syms[i]);
   });
 
   DenseMap<DefinedRegular *, std::string> ret;
   for (size_t i = 0, e = syms.size(); i < e; ++i)
     ret[syms[i]] = std::move(str[i]);
   return ret;
 }
 
 void lld::coff::writeLLDMapFile(const COFFLinkerContext &ctx) {
-  if (config->lldmapFile.empty())
+  if (ctx.config.lldmapFile.empty())
     return;
 
   std::error_code ec;
-  raw_fd_ostream os(config->lldmapFile, ec, sys::fs::OF_None);
+  raw_fd_ostream os(ctx.config.lldmapFile, ec, sys::fs::OF_None);
   if (ec)
-    fatal("cannot open " + config->lldmapFile + ": " + ec.message());
+    fatal("cannot open " + ctx.config.lldmapFile + ": " + ec.message());
 
   // Collect symbol info that we want to print out.
   std::vector<DefinedRegular *> syms = getSymbols(ctx);
   SymbolMapTy sectionSyms = getSectionSyms(syms);
-  DenseMap<DefinedRegular *, std::string> symStr = getSymbolStrings(syms);
+  DenseMap<DefinedRegular *, std::string> symStr = getSymbolStrings(ctx, syms);
 
   // Print out the header line.
   os << "Address  Size     Align Out     In      Symbol\n";
 
   // Print out file contents.
   for (OutputSection *sec : ctx.outputSections) {
     writeHeader(os, sec->getRVA(), sec->getVirtualSize(), /*align=*/pageSize);
     os << sec->name << '\n';

lld/COFF/LTO.h

 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/raw_ostream.h"
 #include <memory>
 #include <vector>
 
 namespace llvm {
 namespace lto {
+struct Config;
 class LTO;
 }
 }
 
 namespace lld {
 namespace coff {
 
 class BitcodeFile;
 class InputFile;
 class COFFLinkerContext;
 
 class BitcodeCompiler {
 public:
-  BitcodeCompiler();
+  BitcodeCompiler(COFFLinkerContext &ctx);
   ~BitcodeCompiler();
 
   void add(BitcodeFile &f);
-  std::vector<InputFile *> compile(COFFLinkerContext &ctx);
+  std::vector<InputFile *> compile();
 
 private:
   std::unique_ptr<llvm::lto::LTO> ltoObj;
   std::vector<SmallString<0>> buf;
   std::vector<std::unique_ptr<MemoryBuffer>> files;
   std::unique_ptr<llvm::raw_fd_ostream> indexFile;
   llvm::DenseSet<StringRef> thinIndices;
+
+  std::string getThinLTOOutputFile(StringRef path);
+  llvm::lto::Config createConfig();
+
+  COFFLinkerContext &ctx;
 };
 }
 }
 
 #endif

lld/COFF/LTO.cpp

 //===- LTO.cpp ------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "LTO.h"
+#include "COFFLinkerContext.h"
 #include "Config.h"
 #include "InputFiles.h"
 #include "Symbols.h"
 #include "lld/Common/Args.h"
 #include "lld/Common/CommonLinkerContext.h"
 #include "lld/Common/Strings.h"
 #include "lld/Common/TargetOptionsCommandFlags.h"
 #include "llvm/ADT/STLExtras.h"
auto ret =
       std::make_unique<raw_fd_ostream>(file, ec, sys::fs::OpenFlags::OF_None);
   if (ec) {
     error("cannot open " + file + ": " + ec.message());
     return nullptr;
   }
   return ret;
 }
 
-static std::string getThinLTOOutputFile(StringRef path) {
+std::string BitcodeCompiler::getThinLTOOutputFile(StringRef path) {
   return lto::getThinLTOOutputFile(
-      std::string(path), std::string(config->thinLTOPrefixReplace.first),
-      std::string(config->thinLTOPrefixReplace.second));
+      std::string(path), std::string(ctx.config.thinLTOPrefixReplace.first),
+      std::string(ctx.config.thinLTOPrefixReplace.second));
 }
 
-static lto::Config createConfig() {
+lto::Config BitcodeCompiler::createConfig() {
   lto::Config c;
   c.Options = initTargetOptionsFromCodeGenFlags();
   c.Options.EmitAddrsig = true;
 
   // Always emit a section per function/datum with LTO. LLVM LTO should get most
   // of the benefit of linker GC, but there are still opportunities for ICF.
   c.Options.FunctionSections = true;
   c.Options.DataSections = true;
 
   // Use static reloc model on 32-bit x86 because it usually results in more
   // compact code, and because there are also known code generation bugs when
   // using the PIC model (see PR34306).
-  if (config->machine == COFF::IMAGE_FILE_MACHINE_I386)
+  if (ctx.config.machine == COFF::IMAGE_FILE_MACHINE_I386)
     c.RelocModel = Reloc::Static;
   else
     c.RelocModel = Reloc::PIC_;
   c.DisableVerify = true;
   c.DiagHandler = diagnosticHandler;
-  c.OptLevel = config->ltoo;
+  c.OptLevel = ctx.config.ltoo;
   c.CPU = getCPUStr();
   c.MAttrs = getMAttrs();
-  c.CGOptLevel = args::getCGOptLevel(config->ltoo);
-  c.AlwaysEmitRegularLTOObj = !config->ltoObjPath.empty();
-  c.UseNewPM = config->ltoNewPassManager;
-  c.DebugPassManager = config->ltoDebugPassManager;
-  c.CSIRProfile = std::string(config->ltoCSProfileFile);
-  c.RunCSIRInstr = config->ltoCSProfileGenerate;
-  c.PGOWarnMismatch = config->ltoPGOWarnMismatch;
+  c.CGOptLevel = args::getCGOptLevel(ctx.config.ltoo);
+  c.AlwaysEmitRegularLTOObj = !ctx.config.ltoObjPath.empty();
+  c.UseNewPM = ctx.config.ltoNewPassManager;
+  c.DebugPassManager = ctx.config.ltoDebugPassManager;
+  c.CSIRProfile = std::string(ctx.config.ltoCSProfileFile);
+  c.RunCSIRInstr = ctx.config.ltoCSProfileGenerate;
+  c.PGOWarnMismatch = ctx.config.ltoPGOWarnMismatch;
 
-  if (config->saveTemps)
-    checkError(c.addSaveTemps(std::string(config->outputFile) + ".",
+  if (ctx.config.saveTemps)
+    checkError(c.addSaveTemps(std::string(ctx.config.outputFile) + ".",
                               /*UseInputModulePath*/ true));
   return c;
 }
 
-BitcodeCompiler::BitcodeCompiler() {
+BitcodeCompiler::BitcodeCompiler(COFFLinkerContext &c) : ctx(c) {
   // Initialize indexFile.
-  if (!config->thinLTOIndexOnlyArg.empty())
-    indexFile = openFile(config->thinLTOIndexOnlyArg);
+  if (!ctx.config.thinLTOIndexOnlyArg.empty())
+    indexFile = openFile(ctx.config.thinLTOIndexOnlyArg);
 
   // Initialize ltoObj.
   lto::ThinBackend backend;
-  if (config->thinLTOIndexOnly) {
+  if (ctx.config.thinLTOIndexOnly) {
     auto OnIndexWrite = [&](StringRef S) { thinIndices.erase(S); };
     backend = lto::createWriteIndexesThinBackend(
-        std::string(config->thinLTOPrefixReplace.first),
-        std::string(config->thinLTOPrefixReplace.second),
-        config->thinLTOEmitImportsFiles, indexFile.get(), OnIndexWrite);
+        std::string(ctx.config.thinLTOPrefixReplace.first),
+        std::string(ctx.config.thinLTOPrefixReplace.second),
+        ctx.config.thinLTOEmitImportsFiles, indexFile.get(), OnIndexWrite);
   } else {
     backend = lto::createInProcessThinBackend(
-        llvm::heavyweight_hardware_concurrency(config->thinLTOJobs));
+        llvm::heavyweight_hardware_concurrency(ctx.config.thinLTOJobs));
   }
 
   ltoObj = std::make_unique<lto::LTO>(createConfig(), backend,
-                                       config->ltoPartitions);
+                                      ctx.config.ltoPartitions);
 }
 
 BitcodeCompiler::~BitcodeCompiler() = default;
 
 static void undefine(Symbol *s) { replaceSymbol<Undefined>(s, s->getName()); }
 
 void BitcodeCompiler::add(BitcodeFile &f) {
   lto::InputFile &obj = *f.obj;
   unsigned symNum = 0;
   std::vector<Symbol *> symBodies = f.getSymbols();
   std::vector<lto::SymbolResolution> resols(symBodies.size());
 
-  if (config->thinLTOIndexOnly)
+  if (ctx.config.thinLTOIndexOnly)
     thinIndices.insert(obj.getName());
 
   // Provide a resolution to the LTO API for each symbol.
   for (const lto::InputFile::Symbol &objSym : obj.symbols()) {
     Symbol *sym = symBodies[symNum];
     lto::SymbolResolution &r = resols[symNum];
     ++symNum;
 
for (const lto::InputFile::Symbol &objSym : obj.symbols()) {
     // their values are still not final.
     r.LinkerRedefined = !sym->canInline;
   }
   checkError(ltoObj->add(std::move(f.obj), resols));
 }
 
 // Merge all the bitcode files we have seen, codegen the result
 // and return the resulting objects.
-std::vector<InputFile *> BitcodeCompiler::compile(COFFLinkerContext &ctx) {
+std::vector<InputFile *> BitcodeCompiler::compile() {
   unsigned maxTasks = ltoObj->getMaxTasks();
   buf.resize(maxTasks);
   files.resize(maxTasks);
 
   // The /lldltocache option specifies the path to a directory in which to cache
   // native object files for ThinLTO incremental builds. If a path was
   // specified, configure LTO to use it as the cache directory.
   FileCache cache;
-  if (!config->ltoCache.empty())
+  if (!ctx.config.ltoCache.empty())
     cache =
-        check(localCache("ThinLTO", "Thin", config->ltoCache,
+        check(localCache("ThinLTO", "Thin", ctx.config.ltoCache,
                          [&](size_t task, std::unique_ptr<MemoryBuffer> mb) {
                            files[task] = std::move(mb);
                          }));
 
   checkError(ltoObj->run(
       [&](size_t task) {
         return std::make_unique<CachedFileStream>(
             std::make_unique<raw_svector_ostream>(buf[task]));
       },
       cache));
 
   // Emit empty index files for non-indexed files
   for (StringRef s : thinIndices) {
     std::string path = getThinLTOOutputFile(s);
     openFile(path + ".thinlto.bc");
-    if (config->thinLTOEmitImportsFiles)
+    if (ctx.config.thinLTOEmitImportsFiles)
       openFile(path + ".imports");
   }
 
   // ThinLTO with index only option is required to generate only the index
   // files. After that, we exit from linker and ThinLTO backend runs in a
   // distributed environment.
-  if (config->thinLTOIndexOnly) {
-    if (!config->ltoObjPath.empty())
-      saveBuffer(buf[0], config->ltoObjPath);
+  if (ctx.config.thinLTOIndexOnly) {
+    if (!ctx.config.ltoObjPath.empty())
+      saveBuffer(buf[0], ctx.config.ltoObjPath);
     if (indexFile)
       indexFile->close();
     return {};
   }
 
-  if (!config->ltoCache.empty())
-    pruneCache(config->ltoCache, config->ltoCachePolicy);
+  if (!ctx.config.ltoCache.empty())
+    pruneCache(ctx.config.ltoCache, ctx.config.ltoCachePolicy);
 
   std::vector<InputFile *> ret;
   for (unsigned i = 0; i != maxTasks; ++i) {
     // Assign unique names to LTO objects. This ensures they have unique names
     // in the PDB if one is produced. The names should look like:
     // - foo.exe.lto.obj
     // - foo.exe.lto.1.obj
     // - ...
     StringRef ltoObjName =
-        saver().save(Twine(config->outputFile) + ".lto" +
+        saver().save(Twine(ctx.config.outputFile) + ".lto" +
                      (i == 0 ? Twine("") : Twine('.') + Twine(i)) + ".obj");
 
     // Get the native object contents either from the cache or from memory.  Do
     // not use the cached MemoryBuffer directly, or the PDB will not be
     // deterministic.
     StringRef objBuf;
     if (files[i])
       objBuf = files[i]->getBuffer();
     else
       objBuf = buf[i];
     if (objBuf.empty())
       continue;
 
-    if (config->saveTemps)
+    if (ctx.config.saveTemps)
       saveBuffer(buf[i], ltoObjName);
     ret.push_back(make<ObjFile>(ctx, MemoryBufferRef(objBuf, ltoObjName)));
   }
 
   return ret;
 }

lld/COFF/MapFile.cpp

constexpr const char *const months[12] = {"Jan", "Feb", "Mar", "Apr",
                                             "May", "Jun", "Jul", "Aug",
                                             "Sep", "Oct", "Nov", "Dec"};
   tm *time = localtime(&tds);
   os << format("%s %s %2d %02d:%02d:%02d %d", days[time->tm_wday],
                months[time->tm_mon], time->tm_mday, time->tm_hour, time->tm_min,
                time->tm_sec, time->tm_year + 1900);
 }
 
-static void sortUniqueSymbols(std::vector<Defined *> &syms) {
+static void sortUniqueSymbols(std::vector<Defined *> &syms,
+                              uint64_t imageBase) {
   // Build helper vector
   using SortEntry = std::pair<Defined *, size_t>;
   std::vector<SortEntry> v;
   v.resize(syms.size());
   for (size_t i = 0, e = syms.size(); i < e; ++i)
     v[i] = SortEntry(syms[i], i);
 
   // Remove duplicate symbol pointers
   parallelSort(v, std::less<SortEntry>());
   auto end = std::unique(v.begin(), v.end(),
                          [](const SortEntry &a, const SortEntry &b) {
                            return a.first == b.first;
                          });
   v.erase(end, v.end());
 
   // Sort by RVA then original order
-  parallelSort(v, [](const SortEntry &a, const SortEntry &b) {
-    // Add config->imageBase to avoid comparing "negative" RVAs.
+  parallelSort(v, [imageBase](const SortEntry &a, const SortEntry &b) {
+    // Add config.imageBase to avoid comparing "negative" RVAs.
     // This can happen with symbols of Absolute kind
-    uint64_t rvaa = config->imageBase + a.first->getRVA();
-    uint64_t rvab = config->imageBase + b.first->getRVA();
+    uint64_t rvaa = imageBase + a.first->getRVA();
+    uint64_t rvab = imageBase + b.first->getRVA();
     return rvaa < rvab || (rvaa == rvab && a.second < b.second);
   });
 
   syms.resize(v.size());
   for (size_t i = 0, e = v.size(); i < e; ++i)
     syms[i] = v[i].first;
 }
 
for (ImportFile *file : ctx.importFileInstances) {
 
     if (auto *thunkSym = dyn_cast<Defined>(file->thunkSym))
       syms.push_back(thunkSym);
 
     if (auto *impSym = dyn_cast_or_null<Defined>(file->impSym))
       syms.push_back(impSym);
   }
 
-  sortUniqueSymbols(syms);
-  sortUniqueSymbols(staticSyms);
+  sortUniqueSymbols(syms, ctx.config.imageBase);
+  sortUniqueSymbols(staticSyms, ctx.config.imageBase);
 }
 
 // Construct a map from symbols to their stringified representations.
 static DenseMap<Defined *, std::string>
 getSymbolStrings(const COFFLinkerContext &ctx, ArrayRef<Defined *> syms) {
   std::vector<std::string> str(syms.size());
   parallelForEachN((size_t)0, syms.size(), [&](size_t i) {
     raw_string_ostream os(str[i]);
if (auto *absSym = dyn_cast<DefinedAbsolute>(sym)) {
         }
         fileDescr += sys::path::filename(file->getName());
       }
     }
     writeHeader(os, sectionIdx, address);
     os << "       ";
     os << left_justify(sym->getName(), 26);
     os << " ";
-    os << format_hex_no_prefix((config->imageBase + sym->getRVA()), 16);
+    os << format_hex_no_prefix((ctx.config.imageBase + sym->getRVA()), 16);
     if (!fileDescr.empty()) {
       os << "     "; // FIXME : Handle "f" and "i" flags sometimes generated
                      // by link.exe in those spaces
       os << fileDescr;
     }
   });
 
   DenseMap<Defined *, std::string> ret;
   for (size_t i = 0, e = syms.size(); i < e; ++i)
     ret[syms[i]] = std::move(str[i]);
   return ret;
 }
 
 void lld::coff::writeMapFile(COFFLinkerContext &ctx) {
-  if (config->mapFile.empty())
+  if (ctx.config.mapFile.empty())
     return;
 
   std::error_code ec;
-  raw_fd_ostream os(config->mapFile, ec, sys::fs::OF_None);
+  raw_fd_ostream os(ctx.config.mapFile, ec, sys::fs::OF_None);
   if (ec)
-    fatal("cannot open " + config->mapFile + ": " + ec.message());
+    fatal("cannot open " + ctx.config.mapFile + ": " + ec.message());
 
   ScopedTimer t1(ctx.totalMapTimer);
 
   // Collect symbol info that we want to print out.
   ScopedTimer t2(ctx.symbolGatherTimer);
   std::vector<Defined *> syms;
   std::vector<Defined *> staticSyms;
   getSymbols(ctx, syms, staticSyms);
   t2.stop();
 
   ScopedTimer t3(ctx.symbolStringsTimer);
   DenseMap<Defined *, std::string> symStr = getSymbolStrings(ctx, syms);
   DenseMap<Defined *, std::string> staticSymStr =
       getSymbolStrings(ctx, staticSyms);
   t3.stop();
 
   ScopedTimer t4(ctx.writeTimer);
-  SmallString<128> AppName = sys::path::filename(config->outputFile);
+  SmallString<128> AppName = sys::path::filename(ctx.config.outputFile);
   sys::path::replace_extension(AppName, "");
 
   // Print out the file header
   os << " " << AppName << "\n";
   os << "\n";
 
-  os << " Timestamp is " << format_hex_no_prefix(config->timestamp, 8) << " (";
-  if (config->repro) {
+  os << " Timestamp is " << format_hex_no_prefix(ctx.config.timestamp, 8)
+     << " (";
+  if (ctx.config.repro) {
     os << "Repro mode";
   } else {
-    writeFormattedTimestamp(os, config->timestamp);
+    writeFormattedTimestamp(os, ctx.config.timestamp);
   }
   os << ")\n";
 
   os << "\n";
   os << " Preferred load address is "
-     << format_hex_no_prefix(config->imageBase, 16) << "\n";
+     << format_hex_no_prefix(ctx.config.imageBase, 16) << "\n";
   os << "\n";
 
   // Print out section table.
   os << " Start         Length     Name                   Class\n";
 
   for (OutputSection *sec : ctx.outputSections) {
     // Merge display of chunks with same sectionName
     std::vector<std::pair<SectionChunk *, SectionChunk *>> ChunkRanges;
for (Defined *sym : syms)
     os << symStr[sym] << '\n';
 
   // Print out the entry point.
   os << "\n";
 
   uint16_t entrySecIndex = 0;
   uint64_t entryAddress = 0;
 
-  if (!config->noEntry) {
-    Defined *entry = dyn_cast_or_null<Defined>(config->entry);
+  if (!ctx.config.noEntry) {
+    Defined *entry = dyn_cast_or_null<Defined>(ctx.config.entry);
     if (entry) {
       Chunk *chunk = entry->getChunk();
       entrySecIndex = chunk->getOutputSectionIdx();
       entryAddress =
           entry->getRVA() - ctx.getOutputSection(chunk)->header.VirtualAddress;
     }
   }
   os << " entry point at         ";

lld/COFF/MarkLive.cpp

if (auto *sym = dyn_cast<DefinedRegular>(b))
       enqueue(sym->getChunk());
     else if (auto *sym = dyn_cast<DefinedImportData>(b))
       sym->file->live = true;
     else if (auto *sym = dyn_cast<DefinedImportThunk>(b))
       sym->wrappedSym->file->live = sym->wrappedSym->file->thunkLive = true;
   };
 
   // Add GC root chunks.
-  for (Symbol *b : config->gcroot)
+  for (Symbol *b : ctx.config.gcroot)
     addSym(b);
 
   while (!worklist.empty()) {
     SectionChunk *sc = worklist.pop_back_val();
     assert(sc->live && "We mark as live when pushing onto the worklist!");
 
     // Mark all symbols listed in the relocation table for this section.
     for (Symbol *b : sc->symbols())

lld/COFF/MinGW.h

 namespace lld {
 namespace coff {
 class COFFLinkerContext;
 
 // Logic for deciding what symbols to export, when exporting all
 // symbols for MinGW.
 class AutoExporter {
 public:
-  AutoExporter();
+  AutoExporter(COFFLinkerContext &ctx);
 
   void addWholeArchive(StringRef path);
 
   llvm::StringSet<> excludeSymbols;
   llvm::StringSet<> excludeSymbolPrefixes;
   llvm::StringSet<> excludeSymbolSuffixes;
   llvm::StringSet<> excludeLibs;
   llvm::StringSet<> excludeObjects;
 
-  bool shouldExport(const COFFLinkerContext &ctx, Defined *sym) const;
+  bool shouldExport(Defined *sym) const;
+
+private:
+  COFFLinkerContext &ctx;
 };
 
-void writeDefFile(StringRef name);
+void writeDefFile(StringRef name, const std::vector<Export> &exports);
 
 // The -wrap option is a feature to rename symbols so that you can write
 // wrappers for existing functions. If you pass `-wrap:foo`, all
 // occurrences of symbol `foo` are resolved to `__wrap_foo` (so, you are
 // expected to write `__wrap_foo` function as a wrapper). The original
 // symbol becomes accessible as `__real_foo`, so you can call that from your
 // wrapper.
 //

lld/COFF/MinGW.cpp

 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::COFF;
 using namespace lld;
 using namespace lld::coff;
 
-AutoExporter::AutoExporter() {
+AutoExporter::AutoExporter(COFFLinkerContext &c) : ctx(c) {
   excludeLibs = {
       "libgcc",
       "libgcc_s",
       "libstdc++",
       "libmingw32",
       "libmingwex",
       "libg2c",
       "libsupc++",
excludeSymbolPrefixes = {
       "__profvp_",
   };
 
   excludeSymbolSuffixes = {
       "_iname",
       "_NULL_THUNK_DATA",
   };
 
-  if (config->machine == I386) {
+  if (ctx.config.machine == I386) {
     excludeSymbols = {
         "__NULL_IMPORT_DESCRIPTOR",
         "__pei386_runtime_relocator",
         "_do_pseudo_reloc",
         "_impure_ptr",
         "__impure_ptr",
         "__fmode",
         "_environ",

 
 void AutoExporter::addWholeArchive(StringRef path) {
   StringRef libName = sys::path::filename(path);
   // Drop the file extension, to match the processing below.
   libName = libName.substr(0, libName.rfind('.'));
   excludeLibs.erase(libName);
 }
 
-bool AutoExporter::shouldExport(const COFFLinkerContext &ctx,
-                                Defined *sym) const {
+bool AutoExporter::shouldExport(Defined *sym) const {
   if (!sym || !sym->getChunk())
     return false;
 
   // Only allow the symbol kinds that make sense to export; in particular,
   // disallow import symbols.
   if (!isa<DefinedRegular>(sym) && !isa<DefinedCommon>(sym))
     return false;
   if (excludeSymbols.count(sym->getName()))
bool AutoExporter::shouldExport(Defined *sym) const {
   libName = libName.substr(0, libName.rfind('.'));
   if (!libName.empty())
     return !excludeLibs.count(libName);
 
   StringRef fileName = sys::path::filename(sym->getFile()->getName());
   return !excludeObjects.count(fileName);
 }
 
-void lld::coff::writeDefFile(StringRef name) {
+void lld::coff::writeDefFile(StringRef name,
+                             const std::vector<Export> &exports) {
   std::error_code ec;
   raw_fd_ostream os(name, ec, sys::fs::OF_None);
   if (ec)
     fatal("cannot open " + name + ": " + ec.message());
 
   os << "EXPORTS\n";
-  for (Export &e : config->exports) {
+  for (const Export &e : exports) {
     os << "    " << e.exportName << " "
        << "@" << e.ordinal;
     if (auto *def = dyn_cast_or_null<Defined>(e.sym)) {
       if (def && def->getChunk() &&
           !(def->getChunk()->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE))
         os << " DATA";
     }
     os << "\n";
   }
 }
 
-static StringRef mangle(Twine sym) {
-  assert(config->machine != IMAGE_FILE_MACHINE_UNKNOWN);
-  if (config->machine == I386)
+static StringRef mangle(Twine sym, MachineTypes machine) {
+  assert(machine != IMAGE_FILE_MACHINE_UNKNOWN);
+  if (machine == I386)
     return saver().save("_" + sym);
   return saver().save(sym);
 }
 
 // Handles -wrap option.
 //
 // This function instantiates wrapper symbols. At this point, they seem
 // like they are not being used at all, so we explicitly set some flags so
 // that LTO won't eliminate them.
 std::vector<WrappedSymbol>
 lld::coff::addWrappedSymbols(COFFLinkerContext &ctx, opt::InputArgList &args) {
   std::vector<WrappedSymbol> v;
   DenseSet<StringRef> seen;
 
   for (auto *arg : args.filtered(OPT_wrap)) {
     StringRef name = arg->getValue();
     if (!seen.insert(name).second)
       continue;
 
     Symbol *sym = ctx.symtab.findUnderscore(name);
     if (!sym)
       continue;
 
-    Symbol *real = ctx.symtab.addUndefined(mangle("__real_" + name));
-    Symbol *wrap = ctx.symtab.addUndefined(mangle("__wrap_" + name));
+    Symbol *real =
+        ctx.symtab.addUndefined(mangle("__real_" + name, ctx.config.machine));
+    Symbol *wrap =
+        ctx.symtab.addUndefined(mangle("__wrap_" + name, ctx.config.machine));
     v.push_back({sym, real, wrap});
 
     // These symbols may seem undefined initially, but don't bail out
     // at symtab.reportUnresolvable() due to them, but let wrapSymbols
     // below sort things out before checking finally with
     // symtab.resolveRemainingUndefines().
     sym->deferUndefined = true;
     real->deferUndefined = true;
for (const WrappedSymbol &w : wrapped) {
     if (Defined *d = dyn_cast<Defined>(w.wrap)) {
       Symbol *imp = ctx.symtab.find(("__imp_" + w.sym->getName()).str());
       // Create a new defined local import for the wrap symbol. If
       // no imp prefixed symbol existed, there's no need for it.
       // (We can't easily distinguish whether any object file actually
       // referenced it or not, though.)
       if (imp) {
         DefinedLocalImport *wrapimp = make<DefinedLocalImport>(
-            saver().save("__imp_" + w.wrap->getName()), d);
+            ctx, saver().save("__imp_" + w.wrap->getName()), d);
         ctx.symtab.localImportChunks.push_back(wrapimp->getChunk());
         map[imp] = wrapimp;
       }
     }
   }
 
   // Update pointers in input files.
   parallelForEach(ctx.objFileInstances, [&](ObjFile *file) {
     MutableArrayRef<Symbol *> syms = file->getMutableSymbols();
     for (size_t i = 0, e = syms.size(); i != e; ++i)
       if (Symbol *s = map.lookup(syms[i]))
         syms[i] = s;
   });
 }

lld/COFF/PDB.cpp

public:
 
   /// Write the PDB to disk and store the Guid generated for it in *Guid.
   void commit(codeview::GUID *guid);
 
   // Print statistics regarding the final PDB
   void printStats();
 
 private:
+  void pdbMakeAbsolute(SmallVectorImpl<char> &fileName);
+  void translateIdSymbols(MutableArrayRef<uint8_t> &recordData,
+                          TpiSource *source);
+  void addCommonLinkerModuleSymbols(StringRef path,
+                                    pdb::DbiModuleDescriptorBuilder &mod);
 
   pdb::PDBFileBuilder builder;
 
   TypeMerger tMerger;
 
   COFFLinkerContext &ctx;
 
   /// PDBs use a single global string table for filenames in the file checksum
public:
 
   void finish();
 };
 }
 
 // Visual Studio's debugger requires absolute paths in various places in the
 // PDB to work without additional configuration:
 // https://docs.microsoft.com/en-us/visualstudio/debugger/debug-source-files-common-properties-solution-property-pages-dialog-box
-static void pdbMakeAbsolute(SmallVectorImpl<char> &fileName) {
+void PDBLinker::pdbMakeAbsolute(SmallVectorImpl<char> &fileName) {
   // The default behavior is to produce paths that are valid within the context
   // of the machine that you perform the link on.  If the linker is running on
   // a POSIX system, we will output absolute POSIX paths.  If the linker is
   // running on a Windows system, we will output absolute Windows paths.  If the
   // user desires any other kind of behavior, they should explicitly pass
   // /pdbsourcepath, in which case we will treat the exact string the user
   // passed in as the gospel and not normalize, canonicalize it.
   if (sys::path::is_absolute(fileName, sys::path::Style::windows) ||
       sys::path::is_absolute(fileName, sys::path::Style::posix))
     return;
 
   // It's not absolute in any path syntax.  Relative paths necessarily refer to
   // the local file system, so we can make it native without ending up with a
   // nonsensical path.
-  if (config->pdbSourcePath.empty()) {
+  if (ctx.config.pdbSourcePath.empty()) {
     sys::path::native(fileName);
     sys::fs::make_absolute(fileName);
     sys::path::remove_dots(fileName, true);
     return;
   }
 
   // Try to guess whether /PDBSOURCEPATH is a unix path or a windows path.
   // Since PDB's are more of a Windows thing, we make this conservative and only
   // decide that it's a unix path if we're fairly certain.  Specifically, if
   // it starts with a forward slash.
-  SmallString<128> absoluteFileName = config->pdbSourcePath;
+  SmallString<128> absoluteFileName = ctx.config.pdbSourcePath;
   sys::path::Style guessedStyle = absoluteFileName.startswith("/")
                                       ? sys::path::Style::posix
                                       : sys::path::Style::windows;
   sys::path::append(absoluteFileName, guessedStyle, fileName);
   sys::path::native(absoluteFileName, guessedStyle);
   sys::path::remove_dots(absoluteFileName, true, guessedStyle);
 
   fileName = std::move(absoluteFileName);

 
 static SymbolKind symbolKind(ArrayRef<uint8_t> recordData) {
   const RecordPrefix *prefix =
       reinterpret_cast<const RecordPrefix *>(recordData.data());
   return static_cast<SymbolKind>(uint16_t(prefix->RecordKind));
 }
 
 /// MSVC translates S_PROC_ID_END to S_END, and S_[LG]PROC32_ID to S_[LG]PROC32
-static void translateIdSymbols(MutableArrayRef<uint8_t> &recordData,
-                               TypeMerger &tMerger, TpiSource *source) {
+void PDBLinker::translateIdSymbols(MutableArrayRef<uint8_t> &recordData,
+                                   TpiSource *source) {
   RecordPrefix *prefix = reinterpret_cast<RecordPrefix *>(recordData.data());
 
   SymbolKind kind = symbolKind(recordData);
 
   if (kind == SymbolKind::S_PROC_ID_END) {
     prefix->RecordKind = SymbolKind::S_END;
     return;
   }
if (kind == SymbolKind::S_GPROC32_ID || kind == SymbolKind::S_LPROC32_ID) {
     TypeIndex *ti =
         reinterpret_cast<TypeIndex *>(content.data() + refs[0].Offset);
     // `ti` is the index of a FuncIdRecord or MemberFuncIdRecord which lives in
     // the IPI stream, whose `FunctionType` member refers to the TPI stream.
     // Note that LF_FUNC_ID and LF_MFUNC_ID have the same record layout, and
     // in both cases we just need the second type index.
     if (!ti->isSimple() && !ti->isNoneType()) {
       TypeIndex newType = TypeIndex(SimpleTypeKind::NotTranslated);
-      if (config->debugGHashes) {
+      if (ctx.config.debugGHashes) {
         auto idToType = tMerger.funcIdToType.find(*ti);
         if (idToType != tMerger.funcIdToType.end())
           newType = idToType->second;
       } else {
         if (tMerger.getIDTable().contains(*ti)) {
           CVType funcIdData = tMerger.getIDTable().getType(*ti);
           if (funcIdData.length() >= 8 && (funcIdData.kind() == LF_FUNC_ID ||
                                            funcIdData.kind() == LF_MFUNC_ID)) {
void PDBLinker::writeSymbolRecord(SectionChunk *debugChunk,
   TpiSource *source = debugChunk->file->debugTypesObj;
   if (!source->remapTypesInSymbolRecord(recordBytes)) {
     log("ignoring unknown symbol record with kind 0x" + utohexstr(sym.kind()));
     replaceWithSkipRecord(recordBytes);
   }
 
   // An object file may have S_xxx_ID symbols, but these get converted to
   // "real" symbols in a PDB.
-  translateIdSymbols(recordBytes, tMerger, source);
+  translateIdSymbols(recordBytes, source);
 }
 
 void PDBLinker::analyzeSymbolSubsection(
     SectionChunk *debugChunk, uint32_t &moduleSymOffset,
     uint32_t &nextRelocIndex, std::vector<StringTableFixup> &stringTableFixups,
     BinaryStreamRef symData) {
   ObjFile *file = debugChunk->file;
   uint32_t moduleSymStart = moduleSymOffset;
void DebugSHandler::finish() {
   // checksum table, so we have to do this after looping over all the
   // subsections. The new checksum table must have the exact same layout and
   // size as the original. Otherwise, the file references in the line and
   // inlinee line tables will be incorrect.
   auto newChecksums = std::make_unique<DebugChecksumsSubsection>(linker.pdbStrTab);
   for (const FileChecksumEntry &fc : checksums) {
     SmallString<128> filename =
         exitOnErr(cvStrTab.getString(fc.FileNameOffset));
-    pdbMakeAbsolute(filename);
+    linker.pdbMakeAbsolute(filename);
     exitOnErr(dbiBuilder.addModuleSourceFile(*file.moduleDBI, filename));
     newChecksums->addChecksum(filename, fc.Kind, fc.Checksum);
   }
   assert(checksums.getArray().getUnderlyingStream().getLength() ==
              newChecksums->calculateSerializedSize() &&
          "file checksum table must have same layout");
 
   file.moduleDBI->addDebugSubsection(std::move(newChecksums));
 }
 
-static void warnUnusable(InputFile *f, Error e) {
-  if (!config->warnDebugInfoUnusable) {
+static void warnUnusable(InputFile *f, Error e, bool shouldWarn) {
+  if (!shouldWarn) {
     consumeError(std::move(e));
     return;
   }
   auto msg = "Cannot use debug info for '" + toString(f) + "' [LNK4099]";
   if (e)
     warn(msg + "\n>>> failed to load reference " + toString(std::move(e)));
   else
     warn(msg);

 }
 
 void PDBLinker::addDebug(TpiSource *source) {
   // Before we can process symbol substreams from .debug$S, we need to process
   // type information, file checksums, and the string table. Add type info to
   // the PDB first, so that we can get the map from object file type and item
   // indices to PDB type and item indices.  If we are using ghashes, types have
   // already been merged.
-  if (!config->debugGHashes) {
+  if (!ctx.config.debugGHashes) {
     ScopedTimer t(ctx.typeMergingTimer);
     if (Error e = source->mergeDebugT(&tMerger)) {
       // If type merging failed, ignore the symbols.
-      warnUnusable(source->file, std::move(e));
+      warnUnusable(source->file, std::move(e),
+                   ctx.config.warnDebugInfoUnusable);
       return;
     }
   }
 
   // If type merging failed, ignore the symbols.
   Error typeError = std::move(source->typeMergingError);
   if (typeError) {
-    warnUnusable(source->file, std::move(typeError));
+    warnUnusable(source->file, std::move(typeError),
+                 ctx.config.warnDebugInfoUnusable);
     return;
   }
 
   addDebugSymbols(source);
 }
 
 static pdb::BulkPublic createPublic(COFFLinkerContext &ctx, Defined *def) {
   pdb::BulkPublic pub;
void PDBLinker::addObjectsToPDB() {
 
   // Create module descriptors
   for_each(ctx.objFileInstances, [&](ObjFile *obj) { createModuleDBI(obj); });
 
   // Reorder dependency type sources to come first.
   tMerger.sortDependencies();
 
   // Merge type information from input files using global type hashing.
-  if (config->debugGHashes)
+  if (ctx.config.debugGHashes)
     tMerger.mergeTypesWithGHash();
 
   // Merge dependencies and then regular objects.
   for_each(tMerger.dependencySources,
            [&](TpiSource *source) { addDebug(source); });
   for_each(tMerger.objectSources, [&](TpiSource *source) { addDebug(source); });
 
   builder.getStringTableBuilder().setStrings(pdbStrTab);
   t1.stop();
 
   // Construct TPI and IPI stream contents.
   ScopedTimer t2(ctx.tpiStreamLayoutTimer);
+
   // Collect all the merged types.
-  if (config->debugGHashes) {
+  if (ctx.config.debugGHashes) {
     addGHashTypeInfo(ctx, builder);
   } else {
     addTypeInfo(builder.getTpiBuilder(), tMerger.getTypeTable());
     addTypeInfo(builder.getIpiBuilder(), tMerger.getIDTable());
   }
   t2.stop();
 
-  if (config->showSummary) {
+  if (ctx.config.showSummary) {
     for_each(ctx.tpiSourceList, [&](TpiSource *source) {
       nbTypeRecords += source->nbTypeRecords;
       nbTypeRecordsBytes += source->nbTypeRecordsBytes;
     });
   }
 }
 
 void PDBLinker::addPublicsToPDB() {
if (def && def->isLive() && def->getChunk()) {
       // coverage (and PGO) create a __profd_ and __profc_ symbol for every
       // function. C++ mangled names are long, and tend to dominate symbol size.
       // Including these names triples the size of the public stream, which
       // results in bloated PDB files. These symbols generally are not helpful
       // for debugging, so suppress them.
       StringRef name = def->getName();
       if (name.data()[0] == '_' && name.data()[1] == '_') {
         // Drop the '_' prefix for x86.
-        if (config->machine == I386)
+        if (ctx.config.machine == I386)
           name = name.drop_front(1);
         if (name.startswith("__profd_") || name.startswith("__profc_") ||
             name.startswith("__covrec_")) {
           return;
         }
       }
       publics.push_back(createPublic(ctx, def));
     }
   });
 
   if (!publics.empty()) {
     publicSymbols = publics.size();
     gsiBuilder.addPublicSymbols(std::move(publics));
   }
 }
 
 void PDBLinker::printStats() {
-  if (!config->showSummary)
+  if (!ctx.config.showSummary)
     return;
 
   SmallString<256> buffer;
   raw_svector_ostream stream(buffer);
 
   stream << center_justify("Summary", 80) << '\n'
          << std::string(80, '-') << '\n';
 
if (!tsis.empty()) {
                           tsi.dupCount, tsi.typeSize);
         if (++i >= 10)
           break;
       }
       stream
           << "Run llvm-pdbutil to print details about a particular record:\n";
       stream << formatv("llvm-pdbutil dump -{0}s -{0}-index {1:X} {2}\n",
                         (name == "TPI" ? "type" : "id"),
-                        tsis.back().typeIndex.getIndex(), config->pdbPath);
+                        tsis.back().typeIndex.getIndex(), ctx.config.pdbPath);
     }
   };
 
-  if (!config->debugGHashes) {
+  if (!ctx.config.debugGHashes) {
     // FIXME: Reimplement for ghash.
     printLargeInputTypeRecs("TPI", tMerger.tpiCounts, tMerger.getTypeTable());
     printLargeInputTypeRecs("IPI", tMerger.ipiCounts, tMerger.getIDTable());
   }
 
   message(buffer);
 }
 
 void PDBLinker::addNatvisFiles() {
-  for (StringRef file : config->natvisFiles) {
+  for (StringRef file : ctx.config.natvisFiles) {
     ErrorOr<std::unique_ptr<MemoryBuffer>> dataOrErr =
         MemoryBuffer::getFile(file);
     if (!dataOrErr) {
       warn("Cannot open input file: " + file);
       continue;
     }
     std::unique_ptr<MemoryBuffer> data = std::move(*dataOrErr);
 
     // Can't use takeBuffer() here since addInjectedSource() takes ownership.
-    if (driver->tar)
-      driver->tar->append(relativeToRoot(data->getBufferIdentifier()),
+    if (ctx.driver.tar)
+      ctx.driver.tar->append(relativeToRoot(data->getBufferIdentifier()),
                              data->getBuffer());
 
     builder.addInjectedSource(file, std::move(data));
   }
 }
 
 void PDBLinker::addNamedStreams() {
-  for (const auto &streamFile : config->namedStreams) {
+  for (const auto &streamFile : ctx.config.namedStreams) {
     const StringRef stream = streamFile.getKey(), file = streamFile.getValue();
     ErrorOr<std::unique_ptr<MemoryBuffer>> dataOrErr =
         MemoryBuffer::getFile(file);
     if (!dataOrErr) {
       warn("Cannot open input file: " + file);
       continue;
     }
     std::unique_ptr<MemoryBuffer> data = std::move(*dataOrErr);
     exitOnErr(builder.addNamedStream(stream, data->getBuffer()));
-    driver->takeBuffer(std::move(data));
+    ctx.driver.takeBuffer(std::move(data));
   }
 }
 
 static codeview::CPUType toCodeViewMachine(COFF::MachineTypes machine) {
   switch (machine) {
   case COFF::IMAGE_FILE_MACHINE_AMD64:
     return codeview::CPUType::X64;
   case COFF::IMAGE_FILE_MACHINE_ARM:
if (hasQ) {
       r.append(std::string(a));
     }
     if (hasWS || hasQ)
       r.push_back('"');
   }
   return r;
 }
 
-static void fillLinkerVerRecord(Compile3Sym &cs) {
-  cs.Machine = toCodeViewMachine(config->machine);
+static void fillLinkerVerRecord(Compile3Sym &cs, MachineTypes machine) {
+  cs.Machine = toCodeViewMachine(machine);
   // Interestingly, if we set the string to 0.0.0.0, then when trying to view
   // local variables WinDbg emits an error that private symbols are not present.
   // By setting this to a valid MSVC linker version string, local variables are
   // displayed properly.   As such, even though it is not representative of
   // LLVM's version information, we need this for compatibility.
   cs.Flags = CompileSym3Flags::None;
   cs.VersionBackendBuild = 25019;
   cs.VersionBackendMajor = 14;
   cs.VersionBackendMinor = 10;
   cs.VersionBackendQFE = 0;
 
   // MSVC also sets the frontend to 0.0.0.0 since this is specifically for the
   // linker module (which is by definition a backend), so we don't need to do
   // anything here.  Also, it seems we can use "LLVM Linker" for the linker name
   // without any problems.  Only the backend version has to be hardcoded to a
   // magic number.
   cs.VersionFrontendBuild = 0;
   cs.VersionFrontendMajor = 0;
   cs.VersionFrontendMinor = 0;
   cs.VersionFrontendQFE = 0;
   cs.Version = "LLVM Linker";
   cs.setLanguage(SourceLanguage::Link);
 }
 
-static void addCommonLinkerModuleSymbols(StringRef path,
-                                         pdb::DbiModuleDescriptorBuilder &mod) {
+void PDBLinker::addCommonLinkerModuleSymbols(
+    StringRef path, pdb::DbiModuleDescriptorBuilder &mod) {
   ObjNameSym ons(SymbolRecordKind::ObjNameSym);
   EnvBlockSym ebs(SymbolRecordKind::EnvBlockSym);
   Compile3Sym cs(SymbolRecordKind::Compile3Sym);
-  fillLinkerVerRecord(cs);
+  fillLinkerVerRecord(cs, ctx.config.machine);
 
   ons.Name = "* Linker *";
   ons.Signature = 0;
 
-  ArrayRef<StringRef> args = makeArrayRef(config->argv).drop_front();
+  ArrayRef<StringRef> args = makeArrayRef(ctx.config.argv).drop_front();
   std::string argStr = quote(args);
   ebs.Fields.push_back("cwd");
   SmallString<64> cwd;
-  if (config->pdbSourcePath.empty())
+  if (ctx.config.pdbSourcePath.empty())
     sys::fs::current_path(cwd);
   else
-    cwd = config->pdbSourcePath;
+    cwd = ctx.config.pdbSourcePath;
   ebs.Fields.push_back(cwd);
   ebs.Fields.push_back("exe");
-  SmallString<64> exe = config->argv[0];
+  SmallString<64> exe = ctx.config.argv[0];
   pdbMakeAbsolute(exe);
   ebs.Fields.push_back(exe);
   ebs.Fields.push_back("pdb");
   ebs.Fields.push_back(path);
   ebs.Fields.push_back("cmd");
   ebs.Fields.push_back(argStr);
   llvm::BumpPtrAllocator &bAlloc = lld::bAlloc();
   mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
static void addLinkerModuleCoffGroup(PartialSection *sec,
   if (cgs.Name.startswith(".idata"))
     cgs.Characteristics |= llvm::COFF::IMAGE_SCN_MEM_WRITE;
 
   mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
       cgs, bAlloc(), CodeViewContainer::Pdb));
 }
 
 static void addLinkerModuleSectionSymbol(pdb::DbiModuleDescriptorBuilder &mod,
-                                         OutputSection &os) {
+                                         OutputSection &os, bool isMinGW) {
   SectionSym sym(SymbolRecordKind::SectionSym);
   sym.Alignment = 12; // 2^12 = 4KB
   sym.Characteristics = os.header.Characteristics;
   sym.Length = os.getVirtualSize();
   sym.Name = os.name;
   sym.Rva = os.getRVA();
   sym.SectionNumber = os.sectionIndex;
   mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
       sym, bAlloc(), CodeViewContainer::Pdb));
 
   // Skip COFF groups in MinGW because it adds a significant footprint to the
   // PDB, due to each function being in its own section
-  if (config->mingw)
+  if (isMinGW)
     return;
 
   // Output COFF groups for individual chunks of this section.
   for (PartialSection *sec : os.contribSections) {
     addLinkerModuleCoffGroup(sec, mod, os);
   }
 }
 
for (ImportFile *file : ctx.importFileInstances) {
     ObjNameSym ons(SymbolRecordKind::ObjNameSym);
     Compile3Sym cs(SymbolRecordKind::Compile3Sym);
     Thunk32Sym ts(SymbolRecordKind::Thunk32Sym);
     ScopeEndSym es(SymbolRecordKind::ScopeEndSym);
 
     ons.Name = file->dllName;
     ons.Signature = 0;
 
-    fillLinkerVerRecord(cs);
+    fillLinkerVerRecord(cs, ctx.config.machine);
 
     ts.Name = thunk->getName();
     ts.Parent = 0;
     ts.End = 0;
     ts.Next = 0;
     ts.Thunk = ThunkOrdinal::Standard;
     ts.Length = thunkChunk->getSize();
     ts.Segment = thunkOS->sectionIndex;
void lld::coff::createPDB(COFFLinkerContext &ctx,
   memcpy(&buildId->PDB70.Signature, &guid, 16);
 
   t2.stop();
   t1.stop();
   pdb.printStats();
 }
 
 void PDBLinker::initialize(llvm::codeview::DebugInfo *buildId) {
-  exitOnErr(builder.initialize(config->pdbPageSize));
+  exitOnErr(builder.initialize(ctx.config.pdbPageSize));
 
   buildId->Signature.CVSignature = OMF::Signature::PDB70;
   // Signature is set to a hash of the PDB contents when the PDB is done.
   memset(buildId->PDB70.Signature, 0, 16);
   buildId->PDB70.Age = 1;
 
   // Create streams in MSF for predefined streams, namely
   // PDB, TPI, DBI and IPI.
   for (int i = 0; i < (int)pdb::kSpecialStreamCount; ++i)
     exitOnErr(builder.getMsfBuilder().addStream(0));
 
   // Add an Info stream.
   auto &infoBuilder = builder.getInfoBuilder();
   infoBuilder.setVersion(pdb::PdbRaw_ImplVer::PdbImplVC70);
   infoBuilder.setHashPDBContentsToGUID(true);
 
   // Add an empty DBI stream.
   pdb::DbiStreamBuilder &dbiBuilder = builder.getDbiBuilder();
   dbiBuilder.setAge(buildId->PDB70.Age);
   dbiBuilder.setVersionHeader(pdb::PdbDbiV70);
-  dbiBuilder.setMachineType(config->machine);
+  dbiBuilder.setMachineType(ctx.config.machine);
   // Technically we are not link.exe 14.11, but there are known cases where
   // debugging tools on Windows expect Microsoft-specific version numbers or
   // they fail to work at all.  Since we know we produce PDBs that are
   // compatible with LINK 14.11, we set that version number here.
   dbiBuilder.setBuildNumber(14, 11);
 }
 
 void PDBLinker::addSections(ArrayRef<uint8_t> sectionTable) {
   // It's not entirely clear what this is, but the * Linker * module uses it.
   pdb::DbiStreamBuilder &dbiBuilder = builder.getDbiBuilder();
-  nativePath = config->pdbPath;
+  nativePath = ctx.config.pdbPath;
   pdbMakeAbsolute(nativePath);
   uint32_t pdbFilePathNI = dbiBuilder.addECName(nativePath);
   auto &linkerModule = exitOnErr(dbiBuilder.addModuleInfo("* Linker *"));
   linkerModule.setPdbFilePathNI(pdbFilePathNI);
   addCommonLinkerModuleSymbols(nativePath, linkerModule);
 
   // Add section contributions. They must be ordered by ascending RVA.
   for (OutputSection *os : ctx.outputSections) {
-    addLinkerModuleSectionSymbol(linkerModule, *os);
+    addLinkerModuleSectionSymbol(linkerModule, *os, ctx.config.mingw);
     for (Chunk *c : os->chunks) {
       pdb::SectionContrib sc =
           createSectionContrib(ctx, c, linkerModule.getModuleIndex());
       builder.getDbiBuilder().addSectionContrib(sc);
     }
   }
 
   // The * Linker * first section contrib is only used along with /INCREMENTAL,
void PDBLinker::addSections(ArrayRef<uint8_t> sectionTable) {
   exitOnErr(
       dbiBuilder.addDbgStream(pdb::DbgHeaderType::SectionHdr, sectionTable));
 }
 
 void PDBLinker::commit(codeview::GUID *guid) {
   // Print an error and continue if PDB writing fails. This is done mainly so
   // the user can see the output of /time and /summary, which is very helpful
   // when trying to figure out why a PDB file is too large.
-  if (Error e = builder.commit(config->pdbPath, guid)) {
+  if (Error e = builder.commit(ctx.config.pdbPath, guid)) {
     checkError(std::move(e));
-    error("failed to write PDB file " + Twine(config->pdbPath));
+    error("failed to write PDB file " + Twine(ctx.config.pdbPath));
   }
 }
 
-static uint32_t getSecrelReloc() {
-  switch (config->machine) {
+static uint32_t getSecrelReloc(llvm::COFF::MachineTypes machine) {
+  switch (machine) {
   case AMD64:
     return COFF::IMAGE_REL_AMD64_SECREL;
   case I386:
     return COFF::IMAGE_REL_I386_SECREL;
   case ARMNT:
     return COFF::IMAGE_REL_ARM_SECREL;
   case ARM64:
     return COFF::IMAGE_REL_ARM64_SECREL;
   default:
     llvm_unreachable("unknown machine type");
   }
 }
 
 // Try to find a line table for the given offset Addr into the given chunk C.
 // If a line table was found, the line table, the string and checksum tables
 // that are used to interpret the line table, and the offset of Addr in the line
 // table are stored in the output arguments. Returns whether a line table was
 // found.
 static bool findLineTable(const SectionChunk *c, uint32_t addr,
                           DebugStringTableSubsectionRef &cvStrTab,
                           DebugChecksumsSubsectionRef &checksums,
                           DebugLinesSubsectionRef &lines,
                           uint32_t &offsetInLinetable) {
   ExitOnError exitOnErr;
-  uint32_t secrelReloc = getSecrelReloc();
+  const uint32_t secrelReloc = getSecrelReloc(c->file->ctx.config.machine);
 
   for (SectionChunk *dbgC : c->file->getDebugChunks()) {
     if (dbgC->getSectionName() != ".debug$S")
       continue;
 
     // Build a mapping of SECREL relocations in dbgC that refer to `c`.
     DenseMap<uint32_t, uint32_t> secrels;
     for (const coff_relocation &r : dbgC->getRelocs()) {

lld/COFF/SymbolTable.h

 // conflicts. For example, obviously, a defined symbol is better than
 // an undefined symbol. Or, if there's a conflict between a lazy and a
 // undefined, it'll read an archive member to read a real definition
 // to replace the lazy symbol. The logic is implemented in the
 // add*() functions, which are called by input files as they are parsed.
 // There is one add* function per symbol type.
 class SymbolTable {
 public:
-  SymbolTable(COFFLinkerContext &ctx) : ctx(ctx) {}
+  SymbolTable(COFFLinkerContext &c) : ctx(c) {}
 
   void addFile(InputFile *file);
 
   // Emit errors for symbols that cannot be resolved.
   void reportUnresolvable();
 
   // Try to resolve any undefined symbols and update the symbol table
   // accordingly, then print an error message for any remaining undefined

lld/COFF/SymbolTable.cpp

if (file->lazy) {
     } else if (auto *f = dyn_cast<BitcodeFile>(file)) {
       ctx.bitcodeFileInstances.push_back(f);
     } else if (auto *f = dyn_cast<ImportFile>(file)) {
       ctx.importFileInstances.push_back(f);
     }
   }
 
   MachineTypes mt = file->getMachineType();
-  if (config->machine == IMAGE_FILE_MACHINE_UNKNOWN) {
-    config->machine = mt;
-  } else if (mt != IMAGE_FILE_MACHINE_UNKNOWN && config->machine != mt) {
+  if (ctx.config.machine == IMAGE_FILE_MACHINE_UNKNOWN) {
+    ctx.config.machine = mt;
+  } else if (mt != IMAGE_FILE_MACHINE_UNKNOWN && ctx.config.machine != mt) {
     error(toString(file) + ": machine type " + machineToStr(mt) +
-          " conflicts with " + machineToStr(config->machine));
+          " conflicts with " + machineToStr(ctx.config.machine));
     return;
   }
 
-  driver->parseDirectives(file);
+  ctx.driver.parseDirectives(file);
 }
 
-static void errorOrWarn(const Twine &s) {
-  if (config->forceUnresolved)
+static void errorOrWarn(const Twine &s, bool forceUnresolved) {
+  if (forceUnresolved)
     warn(s);
   else
     error(s);
 }
 
 // Causes the file associated with a lazy symbol to be linked in.
 static void forceLazy(Symbol *s) {
   s->pendingArchiveLoad = true;

 }
 
 static Optional<std::pair<StringRef, uint32_t>>
 getFileLine(const SectionChunk *c, uint32_t addr) {
   // MinGW can optionally use codeview, even if the default is dwarf.
   Optional<std::pair<StringRef, uint32_t>> fileLine =
       getFileLineCodeView(c, addr);
   // If codeview didn't yield any result, check dwarf in MinGW mode.
-  if (!fileLine && config->mingw)
+  if (!fileLine && c->file->ctx.config.mingw)
     fileLine = getFileLineDwarf(c, addr);
   return fileLine;
 }
 
 // Given a file and the index of a symbol in that file, returns a description
 // of all references to that symbol from that file. If no debug information is
 // available, returns just the name of the file, else one string per actual
 // reference as described in the debug info.
getSymbolLocations(ObjFile *file, uint32_t symIndex, size_t maxStrings) {
   for (Location loc : locations) {
     llvm::raw_string_ostream os(symbolLocations[i++]);
     os << "\n>>> referenced by ";
     if (!loc.fileLine.first.empty())
       os << loc.fileLine.first << ":" << loc.fileLine.second
          << "\n>>>               ";
     os << toString(file);
     if (loc.sym)
-      os << ":(" << toString(*loc.sym) << ')';
+      os << ":(" << file->ctx.toString(*loc.sym) << ')';
   }
   return std::make_pair(symbolLocations, numLocations);
 }
 
 std::vector<std::string> getSymbolLocations(ObjFile *file, uint32_t symIndex) {
   return getSymbolLocations(file, symIndex, SIZE_MAX).first;
 }
 
struct UndefinedDiag {
   Symbol *sym;
   struct File {
     InputFile *file;
     uint32_t symIndex;
   };
   std::vector<File> files;
 };
 
-static void reportUndefinedSymbol(const UndefinedDiag &undefDiag) {
+static void reportUndefinedSymbol(const COFFLinkerContext &ctx,
+                                  const UndefinedDiag &undefDiag) {
   std::string out;
   llvm::raw_string_ostream os(out);
-  os << "undefined symbol: " << toString(*undefDiag.sym);
+  os << "undefined symbol: " << ctx.toString(*undefDiag.sym);
 
   const size_t maxUndefReferences = 3;
   size_t numDisplayedRefs = 0, numRefs = 0;
   for (const UndefinedDiag::File &ref : undefDiag.files) {
     std::vector<std::string> symbolLocations;
     size_t totalLocations = 0;
     std::tie(symbolLocations, totalLocations) = getSymbolLocations(
         ref.file, ref.symIndex, maxUndefReferences - numDisplayedRefs);
 
     numRefs += totalLocations;
     numDisplayedRefs += symbolLocations.size();
     for (const std::string &s : symbolLocations) {
       os << s;
     }
   }
   if (numDisplayedRefs < numRefs)
     os << "\n>>> referenced " << numRefs - numDisplayedRefs << " more times";
-  errorOrWarn(os.str());
+  errorOrWarn(os.str(), ctx.config.forceUnresolved);
 }
 
 void SymbolTable::loadMinGWSymbols() {
   for (auto &i : symMap) {
     Symbol *sym = i.second;
     auto *undef = dyn_cast<Undefined>(sym);
     if (!undef)
       continue;
     if (undef->getWeakAlias())
       continue;
 
     StringRef name = undef->getName();
 
-    if (config->machine == I386 && config->stdcallFixup) {
+    if (ctx.config.machine == I386 && ctx.config.stdcallFixup) {
       // Check if we can resolve an undefined decorated symbol by finding
       // the intended target as an undecorated symbol (only with a leading
       // underscore).
       StringRef origName = name;
       StringRef baseName = name;
       // Trim down stdcall/fastcall/vectorcall symbols to the base name.
       baseName = ltrim1(baseName, "_@");
       baseName = baseName.substr(0, baseName.find('@'));
       // Add a leading underscore, as it would be in cdecl form.
       std::string newName = ("_" + baseName).str();
       Symbol *l;
       if (newName != origName && (l = find(newName)) != nullptr) {
         // If we found a symbol and it is lazy; load it.
         if (l->isLazy() && !l->pendingArchiveLoad) {
           log("Loading lazy " + l->getName() + " from " +
               l->getFile()->getName() + " for stdcall fixup");
           forceLazy(l);
         }
         // If it's lazy or already defined, hook it up as weak alias.
         if (l->isLazy() || isa<Defined>(l)) {
-          if (config->warnStdcallFixup)
+          if (ctx.config.warnStdcallFixup)
             warn("Resolving " + origName + " by linking to " + newName);
           else
             log("Resolving " + origName + " by linking to " + newName);
           undef->weakAlias = l;
           continue;
         }
       }
     }
 
-    if (config->autoImport) {
+    if (ctx.config.autoImport) {
       if (name.startswith("__imp_"))
         continue;
       // If we have an undefined symbol, but we have a lazy symbol we could
       // load, load it.
       Symbol *l = find(("__imp_" + name).str());
       if (!l || l->pendingArchiveLoad || !l->isLazy())
         continue;
 
bool SymbolTable::handleMinGWAutomaticImport(Symbol *sym, StringRef name) {
 
   // There may exist symbols named .refptr.<name> which only consist
   // of a single pointer to <name>. If it turns out <name> is
   // automatically imported, we don't need to keep the .refptr.<name>
   // pointer at all, but redirect all accesses to it to the IAT entry
   // for __imp_<name> instead, and drop the whole .refptr.<name> chunk.
   DefinedRegular *refptr =
       dyn_cast_or_null<DefinedRegular>(find((".refptr." + name).str()));
-  if (refptr && refptr->getChunk()->getSize() == config->wordsize) {
+  if (refptr && refptr->getChunk()->getSize() == ctx.config.wordsize) {
     SectionChunk *sc = dyn_cast_or_null<SectionChunk>(refptr->getChunk());
     if (sc && sc->getRelocs().size() == 1 && *sc->symbols().begin() == sym) {
       log("Replacing .refptr." + name + " with " + imp->getName());
       refptr->getChunk()->live = false;
       refptr->replaceKeepingName(imp, impSize);
     }
   }
   return true;
 }
 
 /// Helper function for reportUnresolvable and resolveRemainingUndefines.
 /// This function emits an "undefined symbol" diagnostic for each symbol in
 /// undefs. If localImports is not nullptr, it also emits a "locally
 /// defined symbol imported" diagnostic for symbols in localImports.
 /// objFiles and bitcodeFiles (if not nullptr) are used to report where
 /// undefined symbols are referenced.
 static void reportProblemSymbols(
     const COFFLinkerContext &ctx, const SmallPtrSetImpl<Symbol *> &undefs,
     const DenseMap<Symbol *, Symbol *> *localImports, bool needBitcodeFiles) {
   // Return early if there is nothing to report (which should be
   // the common case).
   if (undefs.empty() && (!localImports || localImports->empty()))
     return;
 
-  for (Symbol *b : config->gcroot) {
+  for (Symbol *b : ctx.config.gcroot) {
     if (undefs.count(b))
-      errorOrWarn("<root>: undefined symbol: " + toString(*b));
+      errorOrWarn("<root>: undefined symbol: " + ctx.toString(*b),
+                  ctx.config.forceUnresolved);
     if (localImports)
       if (Symbol *imp = localImports->lookup(b))
-        warn("<root>: locally defined symbol imported: " + toString(*imp) +
+        warn("<root>: locally defined symbol imported: " + ctx.toString(*imp) +
              " (defined in " + toString(imp->getFile()) + ") [LNK4217]");
   }
 
   std::vector<UndefinedDiag> undefDiags;
   DenseMap<Symbol *, int> firstDiag;
 
   auto processFile = [&](InputFile *file, ArrayRef<Symbol *> symbols) {
     uint32_t symIndex = (uint32_t)-1;
     for (Symbol *sym : symbols) {
       ++symIndex;
       if (!sym)
         continue;
       if (undefs.count(sym)) {
         auto it = firstDiag.find(sym);
         if (it == firstDiag.end()) {
           firstDiag[sym] = undefDiags.size();
           undefDiags.push_back({sym, {{file, symIndex}}});
         } else {
           undefDiags[it->second].files.push_back({file, symIndex});
         }
       }
       if (localImports)
         if (Symbol *imp = localImports->lookup(sym))
           warn(toString(file) +
-               ": locally defined symbol imported: " + toString(*imp) +
+               ": locally defined symbol imported: " + ctx.toString(*imp) +
                " (defined in " + toString(imp->getFile()) + ") [LNK4217]");
     }
   };
 
   for (ObjFile *file : ctx.objFileInstances)
     processFile(file, file->getSymbols());
 
   if (needBitcodeFiles)
     for (BitcodeFile *file : ctx.bitcodeFileInstances)
       processFile(file, file->getSymbols());
 
   for (const UndefinedDiag &undefDiag : undefDiags)
-    reportUndefinedSymbol(undefDiag);
+    reportUndefinedSymbol(ctx, undefDiag);
 }
 
 void SymbolTable::reportUnresolvable() {
   SmallPtrSet<Symbol *, 8> undefs;
   for (auto &i : symMap) {
     Symbol *sym = i.second;
     auto *undef = dyn_cast<Undefined>(sym);
     if (!undef || sym->deferUndefined)
       continue;
     if (undef->getWeakAlias())
       continue;
     StringRef name = undef->getName();
     if (name.startswith("__imp_")) {
       Symbol *imp = find(name.substr(strlen("__imp_")));
       if (imp && isa<Defined>(imp))
         continue;
     }
     if (name.contains("_PchSym_"))
       continue;
-    if (config->autoImport && impSymbol(name))
+    if (ctx.config.autoImport && impSymbol(name))
       continue;
     undefs.insert(sym);
   }
 
   reportProblemSymbols(ctx, undefs,
                        /* localImports */ nullptr, true);
 }
 
for (auto &i : symMap) {
     }
 
     // If we can resolve a symbol by removing __imp_ prefix, do that.
     // This odd rule is for compatibility with MSVC linker.
     if (name.startswith("__imp_")) {
       Symbol *imp = find(name.substr(strlen("__imp_")));
       if (imp && isa<Defined>(imp)) {
         auto *d = cast<Defined>(imp);
-        replaceSymbol<DefinedLocalImport>(sym, name, d);
+        replaceSymbol<DefinedLocalImport>(sym, ctx, name, d);
         localImportChunks.push_back(cast<DefinedLocalImport>(sym)->getChunk());
         localImports[sym] = d;
         continue;
       }
     }
 
     // We don't want to report missing Microsoft precompiled headers symbols.
     // A proper message will be emitted instead in PDBLinker::aquirePrecompObj
     if (name.contains("_PchSym_"))
       continue;
 
-    if (config->autoImport && handleMinGWAutomaticImport(sym, name))
+    if (ctx.config.autoImport && handleMinGWAutomaticImport(sym, name))
       continue;
 
     // Remaining undefined symbols are not fatal if /force is specified.
     // They are replaced with dummy defined symbols.
-    if (config->forceUnresolved)
-      replaceSymbol<DefinedAbsolute>(sym, name, 0);
+    if (ctx.config.forceUnresolved)
+      replaceSymbol<DefinedAbsolute>(sym, ctx, name, 0);
     undefs.insert(sym);
   }
 
   reportProblemSymbols(
-      ctx, undefs, config->warnLocallyDefinedImported ? &localImports : nullptr,
-      false);
+      ctx, undefs,
+      ctx.config.warnLocallyDefinedImported ? &localImports : nullptr, false);
 }
 
 std::pair<Symbol *, bool> SymbolTable::insert(StringRef name) {
   bool inserted = false;
   Symbol *&sym = symMap[CachedHashStringRef(name)];
   if (!sym) {
     sym = reinterpret_cast<Symbol *>(make<SymbolUnion>());
     sym->isUsedInRegularObj = false;

 //   >>>            bar.o
 //   >>> defined at baz.c:563
 //   >>>            baz.o
 void SymbolTable::reportDuplicate(Symbol *existing, InputFile *newFile,
                                   SectionChunk *newSc,
                                   uint32_t newSectionOffset) {
   std::string msg;
   llvm::raw_string_ostream os(msg);
-  os << "duplicate symbol: " << toString(*existing);
+  os << "duplicate symbol: " << ctx.toString(*existing);
 
   DefinedRegular *d = dyn_cast<DefinedRegular>(existing);
   if (d && isa<ObjFile>(d->getFile())) {
     os << getSourceLocation(d->getFile(), d->getChunk(), d->getValue(),
                             existing->getName());
   } else {
     os << getSourceLocation(existing->getFile(), nullptr, 0, "");
   }
   os << getSourceLocation(newFile, newSc, newSectionOffset,
                           existing->getName());
 
-  if (config->forceMultiple)
+  if (ctx.config.forceMultiple)
     warn(os.str());
   else
     error(os.str());
 }
 
 Symbol *SymbolTable::addAbsolute(StringRef n, COFFSymbolRef sym) {
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(n, nullptr);
   s->isUsedInRegularObj = true;
   if (wasInserted || isa<Undefined>(s) || s->isLazy())
-    replaceSymbol<DefinedAbsolute>(s, n, sym);
+    replaceSymbol<DefinedAbsolute>(s, ctx, n, sym);
   else if (auto *da = dyn_cast<DefinedAbsolute>(s)) {
     if (da->getVA() != sym.getValue())
       reportDuplicate(s, nullptr);
   } else if (!isa<DefinedCOFF>(s))
     reportDuplicate(s, nullptr);
   return s;
 }
 
 Symbol *SymbolTable::addAbsolute(StringRef n, uint64_t va) {
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(n, nullptr);
   s->isUsedInRegularObj = true;
   if (wasInserted || isa<Undefined>(s) || s->isLazy())
-    replaceSymbol<DefinedAbsolute>(s, n, va);
+    replaceSymbol<DefinedAbsolute>(s, ctx, n, va);
   else if (auto *da = dyn_cast<DefinedAbsolute>(s)) {
     if (da->getVA() != va)
       reportDuplicate(s, nullptr);
   } else if (!isa<DefinedCOFF>(s))
     reportDuplicate(s, nullptr);
   return s;
 }
 

 
 Symbol *SymbolTable::addImportThunk(StringRef name, DefinedImportData *id,
                                     uint16_t machine) {
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(name, nullptr);
   s->isUsedInRegularObj = true;
   if (wasInserted || isa<Undefined>(s) || s->isLazy()) {
-    replaceSymbol<DefinedImportThunk>(s, name, id, machine);
+    replaceSymbol<DefinedImportThunk>(s, ctx, name, id, machine);
     return s;
   }
 
   reportDuplicate(s, id->file);
   return nullptr;
 }
 
 void SymbolTable::addLibcall(StringRef name) {
std::vector<Chunk *> SymbolTable::getChunks() const {
   return res;
 }
 
 Symbol *SymbolTable::find(StringRef name) const {
   return symMap.lookup(CachedHashStringRef(name));
 }
 
 Symbol *SymbolTable::findUnderscore(StringRef name) const {
-  if (config->machine == I386)
+  if (ctx.config.machine == I386)
     return find(("_" + name).str());
   return find(name);
 }
 
 // Return all symbols that start with Prefix, possibly ignoring the first
 // character of Prefix or the first character symbol.
 std::vector<Symbol *> SymbolTable::getSymsWithPrefix(StringRef prefix) {
   std::vector<Symbol *> syms;
auto findByPrefix = [&syms](const Twine &t) -> Symbol * {
     std::string prefix = t.str();
     for (auto *s : syms)
       if (s->getName().startswith(prefix))
         return s;
     return nullptr;
   };
 
   // For non-x86, just look for C++ functions.
-  if (config->machine != I386)
+  if (ctx.config.machine != I386)
     return findByPrefix("?" + name + "@@Y");
 
   if (!name.startswith("_"))
     return nullptr;
   // Search for x86 stdcall function.
   if (Symbol *s = findByPrefix(name + "@"))
     return s;
   // Search for x86 fastcall function.
Symbol *SymbolTable::addUndefined(StringRef name) {
   return addUndefined(name, nullptr, false);
 }
 
 void SymbolTable::compileBitcodeFiles() {
   if (ctx.bitcodeFileInstances.empty())
     return;
 
   ScopedTimer t(ctx.ltoTimer);
-  lto.reset(new BitcodeCompiler());
+  lto.reset(new BitcodeCompiler(ctx));
   for (BitcodeFile *f : ctx.bitcodeFileInstances)
     lto->add(*f);
-  for (InputFile *newObj : lto->compile(ctx)) {
+  for (InputFile *newObj : lto->compile()) {
     ObjFile *obj = cast<ObjFile>(newObj);
     obj->parse();
     ctx.objFileInstances.push_back(obj);
   }
 }
 
 } // namespace coff
 } // namespace lld

lld/COFF/Symbols.h

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include <atomic>
 #include <memory>
 #include <vector>
 
 namespace lld {
 
-std::string toString(coff::Symbol &b);
-
-// There are two different ways to convert an Archive::Symbol to a string:
-// One for Microsoft name mangling and one for Itanium name mangling.
-// Call the functions toCOFFString and toELFString, not just toString.
-std::string toCOFFString(const coff::Archive::Symbol &b);
-
 namespace coff {
 
 using llvm::object::Archive;
 using llvm::object::COFFSymbolRef;
 using llvm::object::coff_import_header;
 using llvm::object::coff_symbol_generic;
 
 class ArchiveFile;
+class COFFLinkerContext;
 class InputFile;
 class ObjFile;
 class SymbolTable;
 
 // The base class for real symbol classes.
 class Symbol {
 public:
   enum Kind {
private:
   uint64_t getSize() const { return size; }
   CommonChunk *data;
   uint64_t size;
 };
 
 // Absolute symbols.
 class DefinedAbsolute : public Defined {
 public:
-  DefinedAbsolute(StringRef n, COFFSymbolRef s)
-      : Defined(DefinedAbsoluteKind, n), va(s.getValue()) {
+  DefinedAbsolute(const COFFLinkerContext &c, StringRef n, COFFSymbolRef s)
+      : Defined(DefinedAbsoluteKind, n), va(s.getValue()), ctx(c) {
     isExternal = s.isExternal();
   }
 
-  DefinedAbsolute(StringRef n, uint64_t v)
-      : Defined(DefinedAbsoluteKind, n), va(v) {}
+  DefinedAbsolute(const COFFLinkerContext &c, StringRef n, uint64_t v)
+      : Defined(DefinedAbsoluteKind, n), va(v), ctx(c) {}
 
   static bool classof(const Symbol *s) {
     return s->kind() == DefinedAbsoluteKind;
   }
 
-  uint64_t getRVA() { return va - config->imageBase; }
+  uint64_t getRVA();
   void setVA(uint64_t v) { va = v; }
   uint64_t getVA() const { return va; }
 
-  // Section index relocations against absolute symbols resolve to
-  // this 16 bit number, and it is the largest valid section index
-  // plus one. This variable keeps it.
-  static uint16_t numOutputSections;
-
 private:
   uint64_t va;
+  const COFFLinkerContext &ctx;
 };
 
 // This symbol is used for linker-synthesized symbols like __ImageBase and
 // __safe_se_handler_table.
 class DefinedSynthetic : public Defined {
 public:
   explicit DefinedSynthetic(StringRef name, Chunk *c)
       : Defined(DefinedSyntheticKind, name), c(c) {}

 
 // This class represents a symbol for a jump table entry which jumps
 // to a function in a DLL. Linker are supposed to create such symbols
 // without "__imp_" prefix for all function symbols exported from
 // DLLs, so that you can call DLL functions as regular functions with
 // a regular name. A function pointer is given as a DefinedImportData.
 class DefinedImportThunk : public Defined {
 public:
-  DefinedImportThunk(StringRef name, DefinedImportData *s, uint16_t machine);
+  DefinedImportThunk(COFFLinkerContext &ctx, StringRef name,
+                     DefinedImportData *s, uint16_t machine);
 
   static bool classof(const Symbol *s) {
     return s->kind() == DefinedImportThunkKind;
   }
 
   uint64_t getRVA() { return data->getRVA(); }
   Chunk *getChunk() { return data; }
 
   DefinedImportData *wrappedSym;
 
 private:
   Chunk *data;
 };
 
 // If you have a symbol "foo" in your object file, a symbol name
 // "__imp_foo" becomes automatically available as a pointer to "foo".
 // This class is for such automatically-created symbols.
 // Yes, this is an odd feature. We didn't intend to implement that.
 // This is here just for compatibility with MSVC.
 class DefinedLocalImport : public Defined {
 public:
-  DefinedLocalImport(StringRef n, Defined *s)
-      : Defined(DefinedLocalImportKind, n), data(make<LocalImportChunk>(s)) {}
+  DefinedLocalImport(COFFLinkerContext &ctx, StringRef n, Defined *s)
+      : Defined(DefinedLocalImportKind, n),
+        data(make<LocalImportChunk>(ctx, s)) {}
 
   static bool classof(const Symbol *s) {
     return s->kind() == DefinedLocalImportKind;
   }
 
   uint64_t getRVA() { return data->getRVA(); }
   Chunk *getChunk() { return data; }
 

lld/COFF/Symbols.cpp

 //===- Symbols.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Symbols.h"
+#include "COFFLinkerContext.h"
 #include "InputFiles.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::object;
 
 using namespace lld::coff;
 
 namespace lld {
 
 static_assert(sizeof(SymbolUnion) <= 48,
               "symbols should be optimized for memory usage");
 
-// Returns a symbol name for an error message.
-static std::string maybeDemangleSymbol(StringRef symName) {
-  if (config->demangle) {
-    std::string prefix;
-    StringRef prefixless = symName;
-    if (prefixless.consume_front("__imp_"))
-      prefix = "__declspec(dllimport) ";
-    StringRef demangleInput = prefixless;
-    if (config->machine == I386)
-      demangleInput.consume_front("_");
-    std::string demangled = demangle(demangleInput, true);
-    if (demangled != demangleInput)
-      return prefix + demangle(demangleInput, true);
-    return (prefix + prefixless).str();
-  }
-  return std::string(symName);
-}
-std::string toString(coff::Symbol &b) {
-  return maybeDemangleSymbol(b.getName());
-}
-std::string toCOFFString(const Archive::Symbol &b) {
-  return maybeDemangleSymbol(b.getName());
-}
-
 namespace coff {
 
 void Symbol::computeName() {
   assert(nameData == nullptr &&
          "should only compute the name once for DefinedCOFF symbols");
   auto *d = cast<DefinedCOFF>(this);
   StringRef nameStr =
       check(cast<ObjFile>(d->file)->getCOFFObj()->getSymbolName(d->sym));

 COFFSymbolRef DefinedCOFF::getCOFFSymbol() {
   size_t symSize = cast<ObjFile>(file)->getCOFFObj()->getSymbolTableEntrySize();
   if (symSize == sizeof(coff_symbol16))
     return COFFSymbolRef(reinterpret_cast<const coff_symbol16 *>(sym));
   assert(symSize == sizeof(coff_symbol32));
   return COFFSymbolRef(reinterpret_cast<const coff_symbol32 *>(sym));
 }
 
-uint16_t DefinedAbsolute::numOutputSections;
+uint64_t DefinedAbsolute::getRVA() { return va - ctx.config.imageBase; }
 
-static Chunk *makeImportThunk(DefinedImportData *s, uint16_t machine) {
+static Chunk *makeImportThunk(COFFLinkerContext &ctx, DefinedImportData *s,
+                              uint16_t machine) {
   if (machine == AMD64)
-    return make<ImportThunkChunkX64>(s);
+    return make<ImportThunkChunkX64>(ctx, s);
   if (machine == I386)
-    return make<ImportThunkChunkX86>(s);
+    return make<ImportThunkChunkX86>(ctx, s);
   if (machine == ARM64)
-    return make<ImportThunkChunkARM64>(s);
+    return make<ImportThunkChunkARM64>(ctx, s);
   assert(machine == ARMNT);
-  return make<ImportThunkChunkARM>(s);
+  return make<ImportThunkChunkARM>(ctx, s);
 }
 
-DefinedImportThunk::DefinedImportThunk(StringRef name, DefinedImportData *s,
-                                       uint16_t machine)
+DefinedImportThunk::DefinedImportThunk(COFFLinkerContext &ctx, StringRef name,
+                                       DefinedImportData *s, uint16_t machine)
     : Defined(DefinedImportThunkKind, name), wrappedSym(s),
-      data(makeImportThunk(s, machine)) {}
+      data(makeImportThunk(ctx, s, machine)) {}
 
 Defined *Undefined::getWeakAlias() {
   // A weak alias may be a weak alias to another symbol, so check recursively.
   for (Symbol *a = weakAlias; a; a = cast<Undefined>(a)->weakAlias)
     if (auto *d = dyn_cast<Defined>(a))
       return d;
   return nullptr;
 }
 
 MemoryBufferRef LazyArchive::getMemberBuffer() {
   Archive::Child c =
-    CHECK(sym.getMember(),
-          "could not get the member for symbol " + toCOFFString(sym));
+      CHECK(sym.getMember(), "could not get the member for symbol " +
+                                 file->ctx.toCOFFString(sym));
   return CHECK(c.getMemoryBufferRef(),
                "could not get the buffer for the member defining symbol " +
-      toCOFFString(sym));
+                   file->ctx.toCOFFString(sym));
 }
 } // namespace coff
 } // namespace lld

lld/COFF/TypeMerger.h

 class TypeMerger {
 public:
   TypeMerger(COFFLinkerContext &ctx, llvm::BumpPtrAllocator &alloc);
 
   ~TypeMerger();
 
   /// Get the type table or the global type table if /DEBUG:GHASH is enabled.
   inline llvm::codeview::TypeCollection &getTypeTable() {
-    assert(!config->debugGHashes);
+    assert(!ctx.config.debugGHashes);
     return typeTable;
   }
 
   /// Get the ID table or the global ID table if /DEBUG:GHASH is enabled.
   inline llvm::codeview::TypeCollection &getIDTable() {
-    assert(!config->debugGHashes);
+    assert(!ctx.config.debugGHashes);
     return idTable;
   }
 
   /// Use global hashes to eliminate duplicate types and identify unique type
   /// indices in each TpiSource.
   void mergeTypesWithGHash();
 
   /// Map from PDB function id type indexes to PDB function type indexes.

lld/COFF/Writer.h

 public:
   OutputSection(llvm::StringRef n, uint32_t chars) : name(n) {
     header.Characteristics = chars;
   }
   void addChunk(Chunk *c);
   void insertChunkAtStart(Chunk *c);
   void merge(OutputSection *other);
   void setPermissions(uint32_t c);
-  uint64_t getRVA() { return header.VirtualAddress; }
-  uint64_t getFileOff() { return header.PointerToRawData; }
-  void writeHeaderTo(uint8_t *buf);
+  uint64_t getRVA() const { return header.VirtualAddress; }
+  uint64_t getFileOff() const { return header.PointerToRawData; }
+  void writeHeaderTo(uint8_t *buf, bool isDebug);
   void addContributingPartialSection(PartialSection *sec);
 
   // Returns the size of this section in an executable memory image.
   // This may be smaller than the raw size (the raw size is multiple
   // of disk sector size, so there may be padding at end), or may be
   // larger (if that's the case, the loader reserves spaces after end
   // of raw data).
   uint64_t getVirtualSize() { return header.VirtualSize; }

lld/COFF/Writer.cpp

 static_assert(dosStubSize % 8 == 0, "DOSStub size must be multiple of 8");
 
 static const int numberOfDataDirectory = 16;
 
 namespace {
 
 class DebugDirectoryChunk : public NonSectionChunk {
 public:
-  DebugDirectoryChunk(COFFLinkerContext &c,
+  DebugDirectoryChunk(const COFFLinkerContext &c,
                       const std::vector<std::pair<COFF::DebugType, Chunk *>> &r,
                       bool writeRepro)
       : records(r), writeRepro(writeRepro), ctx(c) {}
 
   size_t getSize() const override {
     return (records.size() + int(writeRepro)) * sizeof(debug_directory);
   }
 
   void writeTo(uint8_t *b) const override {
     auto *d = reinterpret_cast<debug_directory *>(b);
 
     for (const std::pair<COFF::DebugType, Chunk *>& record : records) {
       Chunk *c = record.second;
-      OutputSection *os = ctx.getOutputSection(c);
+      const OutputSection *os = ctx.getOutputSection(c);
       uint64_t offs = os->getFileOff() + (c->getRVA() - os->getRVA());
       fillEntry(d, record.first, c->getSize(), c->getRVA(), offs);
       ++d;
     }
 
     if (writeRepro) {
       // FIXME: The COFF spec allows either a 0-sized entry to just say
       // "the timestamp field is really a hash", or a 4-byte size field
void fillEntry(debug_directory *d, COFF::DebugType debugType, size_t size,
     d->PointerToRawData = offs;
 
     timeDateStamps.push_back(&d->TimeDateStamp);
   }
 
   mutable std::vector<support::ulittle32_t *> timeDateStamps;
   const std::vector<std::pair<COFF::DebugType, Chunk *>> &records;
   bool writeRepro;
-
-  COFFLinkerContext &ctx;
+  const COFFLinkerContext &ctx;
 };
 
 class CVDebugRecordChunk : public NonSectionChunk {
 public:
+  CVDebugRecordChunk(const COFFLinkerContext &c) : ctx(c) {}
+
   size_t getSize() const override {
-    return sizeof(codeview::DebugInfo) + config->pdbAltPath.size() + 1;
+    return sizeof(codeview::DebugInfo) + ctx.config.pdbAltPath.size() + 1;
   }
 
   void writeTo(uint8_t *b) const override {
     // Save off the DebugInfo entry to backfill the file signature (build id)
     // in Writer::writeBuildId
     buildId = reinterpret_cast<codeview::DebugInfo *>(b);
 
     // variable sized field (PDB Path)
     char *p = reinterpret_cast<char *>(b + sizeof(*buildId));
-    if (!config->pdbAltPath.empty())
-      memcpy(p, config->pdbAltPath.data(), config->pdbAltPath.size());
-    p[config->pdbAltPath.size()] = '\0';
+    if (!ctx.config.pdbAltPath.empty())
+      memcpy(p, ctx.config.pdbAltPath.data(), ctx.config.pdbAltPath.size());
+    p[ctx.config.pdbAltPath.size()] = '\0';
   }
 
   mutable codeview::DebugInfo *buildId = nullptr;
+
+private:
+  const COFFLinkerContext &ctx;
 };
 
 class ExtendedDllCharacteristicsChunk : public NonSectionChunk {
 public:
   ExtendedDllCharacteristicsChunk(uint32_t c) : characteristics(c) {}
 
   size_t getSize() const override { return 4; }
 
if (c == 0)
       return characteristics < other.characteristics;
     return true;
   }
 };
 
 // The writer writes a SymbolTable result to a file.
 class Writer {
 public:
-  Writer(COFFLinkerContext &c) : buffer(errorHandler().outputBuffer), ctx(c) {}
+  Writer(COFFLinkerContext &c)
+      : buffer(errorHandler().outputBuffer), delayIdata(c), edata(c), ctx(c) {}
   void run();
 
 private:
   void createSections();
   void createMiscChunks();
   void createImportTables();
   void appendImportThunks();
   void locateImportTables();
   void createExportTable();
   void mergeSections();
   void removeUnusedSections();
   void assignAddresses();
+  bool isInRange(uint16_t relType, uint64_t s, uint64_t p, int margin);
+  std::pair<Defined *, bool> getThunk(DenseMap<uint64_t, Defined *> &lastThunks,
+                                      Defined *target, uint64_t p,
+                                      uint16_t type, int margin);
+  bool createThunks(OutputSection *os, int margin);
+  bool verifyRanges(const std::vector<Chunk *> chunks);
   void finalizeAddresses();
   void removeEmptySections();
   void assignOutputSectionIndices();
   void createSymbolAndStringTable();
   void openFile(StringRef outputPath);
   template <typename PEHeaderTy> void writeHeader();
   void createSEHTable();
   void createRuntimePseudoRelocs();
   void insertCtorDtorSymbols();
+  void markSymbolsWithRelocations(ObjFile *file, SymbolRVASet &usedSymbols);
   void createGuardCFTables();
   void markSymbolsForRVATable(ObjFile *file,
                               ArrayRef<SectionChunk *> symIdxChunks,
                               SymbolRVASet &tableSymbols);
   void getSymbolsFromSections(ObjFile *file,
                               ArrayRef<SectionChunk *> symIdxChunks,
                               std::vector<Symbol *> &symbols);
   void maybeAddRVATable(SymbolRVASet tableSymbols, StringRef tableSym,
                         StringRef countSym, bool hasFlag=false);
   void setSectionPermissions();
   void writeSections();
   void writeBuildId();
   void sortSections();
   void sortExceptionTable();
   void sortCRTSectionChunks(std::vector<Chunk *> &chunks);
   void addSyntheticIdata();
+  void sortBySectionOrder(std::vector<Chunk *> &chunks);
   void fixPartialSectionChars(StringRef name, uint32_t chars);
   bool fixGnuImportChunks();
   void fixTlsAlignment();
   PartialSection *createPartialSection(StringRef name, uint32_t outChars);
   PartialSection *findPartialSection(StringRef name, uint32_t outChars);
 
   llvm::Optional<coff_symbol16> createSymbol(Defined *d);
   size_t addEntryToStringTable(StringRef str);
void OutputSection::merge(OutputSection *other) {
   chunks.insert(chunks.end(), other->chunks.begin(), other->chunks.end());
   other->chunks.clear();
   contribSections.insert(contribSections.end(), other->contribSections.begin(),
                          other->contribSections.end());
   other->contribSections.clear();
 }
 
 // Write the section header to a given buffer.
-void OutputSection::writeHeaderTo(uint8_t *buf) {
+void OutputSection::writeHeaderTo(uint8_t *buf, bool isDebug) {
   auto *hdr = reinterpret_cast<coff_section *>(buf);
   *hdr = header;
   if (stringTableOff) {
     // If name is too long, write offset into the string table as a name.
     sprintf(hdr->Name, "/%d", stringTableOff);
   } else {
-    assert(!config->debug || name.size() <= COFF::NameSize ||
+    assert(!isDebug || name.size() <= COFF::NameSize ||
            (hdr->Characteristics & IMAGE_SCN_MEM_DISCARDABLE) == 0);
     strncpy(hdr->Name, name.data(),
             std::min(name.size(), (size_t)COFF::NameSize));
   }
 }
 
 void OutputSection::addContributingPartialSection(PartialSection *sec) {
   contribSections.push_back(sec);
 }
 
 // Check whether the target address S is in range from a relocation
 // of type relType at address P.
-static bool isInRange(uint16_t relType, uint64_t s, uint64_t p, int margin) {
-  if (config->machine == ARMNT) {
+bool Writer::isInRange(uint16_t relType, uint64_t s, uint64_t p, int margin) {
+  if (ctx.config.machine == ARMNT) {
     int64_t diff = AbsoluteDifference(s, p + 4) + margin;
     switch (relType) {
     case IMAGE_REL_ARM_BRANCH20T:
       return isInt<21>(diff);
     case IMAGE_REL_ARM_BRANCH24T:
     case IMAGE_REL_ARM_BLX23T:
       return isInt<25>(diff);
     default:
       return true;
     }
-  } else if (config->machine == ARM64) {
+  } else if (ctx.config.machine == ARM64) {
     int64_t diff = AbsoluteDifference(s, p) + margin;
     switch (relType) {
     case IMAGE_REL_ARM64_BRANCH26:
       return isInt<28>(diff);
     case IMAGE_REL_ARM64_BRANCH19:
       return isInt<21>(diff);
     case IMAGE_REL_ARM64_BRANCH14:
       return isInt<16>(diff);
     default:
       return true;
     }
   } else {
     llvm_unreachable("Unexpected architecture");
   }
 }
 
 // Return the last thunk for the given target if it is in range,
 // or create a new one.
-static std::pair<Defined *, bool>
-getThunk(DenseMap<uint64_t, Defined *> &lastThunks, Defined *target, uint64_t p,
-         uint16_t type, int margin) {
+std::pair<Defined *, bool>
+Writer::getThunk(DenseMap<uint64_t, Defined *> &lastThunks, Defined *target,
+                 uint64_t p, uint16_t type, int margin) {
   Defined *&lastThunk = lastThunks[target->getRVA()];
   if (lastThunk && isInRange(type, lastThunk->getRVA(), p, margin))
     return {lastThunk, false};
   Chunk *c;
-  switch (config->machine) {
+  switch (ctx.config.machine) {
   case ARMNT:
-    c = make<RangeExtensionThunkARM>(target);
+    c = make<RangeExtensionThunkARM>(ctx, target);
     break;
   case ARM64:
-    c = make<RangeExtensionThunkARM64>(target);
+    c = make<RangeExtensionThunkARM64>(ctx, target);
     break;
   default:
     llvm_unreachable("Unexpected architecture");
   }
   Defined *d = make<DefinedSynthetic>("", c);
   lastThunk = d;
   return {d, true};
 }
 
 // This checks all relocations, and for any relocation which isn't in range
 // it adds a thunk after the section chunk that contains the relocation.
 // If the latest thunk for the specific target is in range, that is used
 // instead of creating a new thunk. All range checks are done with the
 // specified margin, to make sure that relocations that originally are in
 // range, but only barely, also get thunks - in case other added thunks makes
 // the target go out of range.
 //
 // After adding thunks, we verify that all relocations are in range (with
 // no extra margin requirements). If this failed, we restart (throwing away
 // the previously created thunks) and retry with a wider margin.
-static bool createThunks(OutputSection *os, int margin) {
+bool Writer::createThunks(OutputSection *os, int margin) {
   bool addressesChanged = false;
   DenseMap<uint64_t, Defined *> lastThunks;
   DenseMap<std::pair<ObjFile *, Defined *>, uint32_t> thunkSymtabIndices;
   size_t thunksSize = 0;
   // Recheck Chunks.size() each iteration, since we can insert more
   // elements into it.
   for (size_t i = 0; i != os->chunks.size(); ++i) {
     SectionChunk *sc = dyn_cast_or_null<SectionChunk>(os->chunks[i]);
for (size_t i = 0; i != os->chunks.size(); ++i) {
     }
 
     sc->setRelocs(newRelocs);
   }
   return addressesChanged;
 }
 
 // Verify that all relocations are in range, with no extra margin requirements.
-static bool verifyRanges(const std::vector<Chunk *> chunks) {
+bool Writer::verifyRanges(const std::vector<Chunk *> chunks) {
   for (Chunk *c : chunks) {
     SectionChunk *sc = dyn_cast_or_null<SectionChunk>(c);
     if (!sc)
       continue;
 
     ArrayRef<coff_relocation> relocs = sc->getRelocs();
     for (size_t j = 0, e = relocs.size(); j < e; ++j) {
       const coff_relocation &rel = relocs[j];
for (Chunk *c : chunks) {
     }
   }
   return true;
 }
 
 // Assign addresses and add thunks if necessary.
 void Writer::finalizeAddresses() {
   assignAddresses();
-  if (config->machine != ARMNT && config->machine != ARM64)
+  if (ctx.config.machine != ARMNT && ctx.config.machine != ARM64)
     return;
 
   size_t origNumChunks = 0;
   for (OutputSection *sec : ctx.outputSections) {
     sec->origChunks = sec->chunks;
     origNumChunks += sec->chunks.size();
   }
 
void Writer::run() {
   assignOutputSectionIndices();
   setSectionPermissions();
   createSymbolAndStringTable();
 
   if (fileSize > UINT32_MAX)
     fatal("image size (" + Twine(fileSize) + ") " +
         "exceeds maximum allowable size (" + Twine(UINT32_MAX) + ")");
 
-  openFile(config->outputFile);
-  if (config->is64()) {
+  openFile(ctx.config.outputFile);
+  if (ctx.config.is64()) {
     writeHeader<pe32plus_header>();
   } else {
     writeHeader<pe32_header>();
   }
   writeSections();
   sortExceptionTable();
 
   // Fix up the alignment in the TLS Directory's characteristic field,
   // if a specific alignment value is needed
   if (tlsAlignment)
     fixTlsAlignment();
 
   t1.stop();
 
-  if (!config->pdbPath.empty() && config->debug) {
+  if (!ctx.config.pdbPath.empty() && ctx.config.debug) {
     assert(buildId);
     createPDB(ctx, sectionTable, buildId->buildId);
   }
   writeBuildId();
 
   writeLLDMapFile(ctx);
   writeMapFile(ctx);
 
static StringRef getOutputSectionName(StringRef name) {
   StringRef s = name.split('$').first;
 
   // Treat a later period as a separator for MinGW, for sections like
   // ".ctors.01234".
   return s.substr(0, s.find('.', 1));
 }
 
 // For /order.
-static void sortBySectionOrder(std::vector<Chunk *> &chunks) {
-  auto getPriority = [](const Chunk *c) {
+void Writer::sortBySectionOrder(std::vector<Chunk *> &chunks) {
+  auto getPriority = [&ctx = ctx](const Chunk *c) {
     if (auto *sec = dyn_cast<SectionChunk>(c))
       if (sec->sym)
-        return config->order.lookup(sec->sym->getName());
+        return ctx.config.order.lookup(sec->sym->getName());
     return 0;
   };
 
   llvm::stable_sort(chunks, [=](const Chunk *a, const Chunk *b) {
     return getPriority(a) < getPriority(b);
   });
 }
 
bool Writer::fixGnuImportChunks() {
   }
   return hasIdata;
 }
 
 // Add generated idata chunks, for imported symbols and DLLs, and a
 // terminator in .idata$2.
 void Writer::addSyntheticIdata() {
   uint32_t rdata = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
-  idata.create();
+  idata.create(ctx);
 
   // Add the .idata content in the right section groups, to allow
   // chunks from other linked in object files to be grouped together.
   // See Microsoft PE/COFF spec 5.4 for details.
   auto add = [&](StringRef n, std::vector<Chunk *> &v) {
     PartialSection *pSec = createPartialSection(n, rdata);
     pSec->chunks.insert(pSec->chunks.end(), v.begin(), v.end());
   };
if (PartialSection *importAddresses = findPartialSection(".idata$5", rdata)) {
     for (Chunk *c : importAddresses->chunks)
       iatSize += c->getSize();
   }
 }
 
 // Return whether a SectionChunk's suffix (the dollar and any trailing
 // suffix) should be removed and sorted into the main suffixless
 // PartialSection.
-static bool shouldStripSectionSuffix(SectionChunk *sc, StringRef name) {
+static bool shouldStripSectionSuffix(SectionChunk *sc, StringRef name,
+                                     bool isMinGW) {
   // On MinGW, comdat groups are formed by putting the comdat group name
   // after the '$' in the section name. For .eh_frame$<symbol>, that must
   // still be sorted before the .eh_frame trailer from crtend.o, thus just
   // strip the section name trailer. For other sections, such as
   // .tls$$<symbol> (where non-comdat .tls symbols are otherwise stored in
   // ".tls$"), they must be strictly sorted after .tls. And for the
   // hypothetical case of comdat .CRT$XCU, we definitely need to keep the
   // suffix for sorting. Thus, to play it safe, only strip the suffix for
   // the standard sections.
-  if (!config->mingw)
+  if (!isMinGW)
     return false;
   if (!sc || !sc->isCOMDAT())
     return false;
   return name.startswith(".text$") || name.startswith(".data$") ||
          name.startswith(".rdata$") || name.startswith(".pdata$") ||
          name.startswith(".xdata$") || name.startswith(".eh_frame$");
 }
 
 void Writer::sortSections() {
-  if (!config->callGraphProfile.empty()) {
+  if (!ctx.config.callGraphProfile.empty()) {
     DenseMap<const SectionChunk *, int> order =
         computeCallGraphProfileOrder(ctx);
     for (auto it : order) {
       if (DefinedRegular *sym = it.first->sym)
-        config->order[sym->getName()] = it.second;
+        ctx.config.order[sym->getName()] = it.second;
     }
   }
-  if (!config->order.empty())
+  if (!ctx.config.order.empty())
     for (auto it : partialSections)
       sortBySectionOrder(it.second->chunks);
 }
 
 // Create output section objects and add them to OutputSections.
 void Writer::createSections() {
   // First, create the builtin sections.
   const uint32_t data = IMAGE_SCN_CNT_INITIALIZED_DATA;
void Writer::createSections() {
   relocSec = createSection(".reloc", data | discardable | r);
   ctorsSec = createSection(".ctors", data | r | w);
   dtorsSec = createSection(".dtors", data | r | w);
 
   // Then bin chunks by name and output characteristics.
   for (Chunk *c : ctx.symtab.getChunks()) {
     auto *sc = dyn_cast<SectionChunk>(c);
     if (sc && !sc->live) {
-      if (config->verbose)
+      if (ctx.config.verbose)
         sc->printDiscardedMessage();
       continue;
     }
     StringRef name = c->getSectionName();
-    if (shouldStripSectionSuffix(sc, name))
+    if (shouldStripSectionSuffix(sc, name, ctx.config.mingw))
       name = name.split('$').first;
 
     if (name.startswith(".tls"))
       tlsAlignment = std::max(tlsAlignment, c->getAlignment());
 
     PartialSection *pSec = createPartialSection(name,
                                                 c->getOutputCharacteristics());
     pSec->chunks.push_back(c);
void Writer::createMiscChunks() {
   }
 
   // Create thunks for locally-dllimported symbols.
   if (!ctx.symtab.localImportChunks.empty()) {
     for (Chunk *c : ctx.symtab.localImportChunks)
       rdataSec->addChunk(c);
   }
 
   // Create Debug Information Chunks
-  OutputSection *debugInfoSec = config->mingw ? buildidSec : rdataSec;
-  if (config->debug || config->repro || config->cetCompat) {
+  OutputSection *debugInfoSec = ctx.config.mingw ? buildidSec : rdataSec;
+  if (ctx.config.debug || ctx.config.repro || ctx.config.cetCompat) {
     debugDirectory =
-        make<DebugDirectoryChunk>(ctx, debugRecords, config->repro);
+        make<DebugDirectoryChunk>(ctx, debugRecords, ctx.config.repro);
     debugDirectory->setAlignment(4);
     debugInfoSec->addChunk(debugDirectory);
   }
 
-  if (config->debug) {
+  if (ctx.config.debug) {
     // Make a CVDebugRecordChunk even when /DEBUG:CV is not specified.  We
     // output a PDB no matter what, and this chunk provides the only means of
     // allowing a debugger to match a PDB and an executable.  So we need it even
     // if we're ultimately not going to write CodeView data to the PDB.
-    buildId = make<CVDebugRecordChunk>();
+    buildId = make<CVDebugRecordChunk>(ctx);
     debugRecords.push_back({COFF::IMAGE_DEBUG_TYPE_CODEVIEW, buildId});
   }
 
-  if (config->cetCompat) {
+  if (ctx.config.cetCompat) {
     debugRecords.push_back({COFF::IMAGE_DEBUG_TYPE_EX_DLLCHARACTERISTICS,
                             make<ExtendedDllCharacteristicsChunk>(
                                 IMAGE_DLL_CHARACTERISTICS_EX_CET_COMPAT)});
   }
 
   // Align and add each chunk referenced by the debug data directory.
   for (std::pair<COFF::DebugType, Chunk *> r : debugRecords) {
     r.second->setAlignment(4);
     debugInfoSec->addChunk(r.second);
   }
 
   // Create SEH table. x86-only.
-  if (config->safeSEH)
+  if (ctx.config.safeSEH)
     createSEHTable();
 
   // Create /guard:cf tables if requested.
-  if (config->guardCF != GuardCFLevel::Off)
+  if (ctx.config.guardCF != GuardCFLevel::Off)
     createGuardCFTables();
 
-  if (config->autoImport)
+  if (ctx.config.autoImport)
     createRuntimePseudoRelocs();
 
-  if (config->mingw)
+  if (ctx.config.mingw)
     insertCtorDtorSymbols();
 }
 
 // Create .idata section for the DLL-imported symbol table.
 // The format of this section is inherently Windows-specific.
 // IdataContents class abstracted away the details for us,
 // so we just let it create chunks and add them to the section.
 void Writer::createImportTables() {
   // Initialize DLLOrder so that import entries are ordered in
   // the same order as in the command line. (That affects DLL
   // initialization order, and this ordering is MSVC-compatible.)
   for (ImportFile *file : ctx.importFileInstances) {
     if (!file->live)
       continue;
 
     std::string dll = StringRef(file->dllName).lower();
-    if (config->dllOrder.count(dll) == 0)
-      config->dllOrder[dll] = config->dllOrder.size();
+    if (ctx.config.dllOrder.count(dll) == 0)
+      ctx.config.dllOrder[dll] = ctx.config.dllOrder.size();
 
     if (file->impSym && !isa<DefinedImportData>(file->impSym))
-      fatal(toString(*file->impSym) + " was replaced");
+      fatal(ctx.toString(*file->impSym) + " was replaced");
     DefinedImportData *impSym = cast_or_null<DefinedImportData>(file->impSym);
-    if (config->delayLoads.count(StringRef(file->dllName).lower())) {
+    if (ctx.config.delayLoads.count(StringRef(file->dllName).lower())) {
       if (!file->thunkSym)
         fatal("cannot delay-load " + toString(file) +
-              " due to import of data: " + toString(*impSym));
+              " due to import of data: " + ctx.toString(*impSym));
       delayIdata.add(impSym);
     } else {
       idata.add(impSym);
     }
   }
 }
 
 void Writer::appendImportThunks() {
   if (ctx.importFileInstances.empty())
     return;
 
   for (ImportFile *file : ctx.importFileInstances) {
     if (!file->live)
       continue;
 
     if (!file->thunkSym)
       continue;
 
     if (!isa<DefinedImportThunk>(file->thunkSym))
-      fatal(toString(*file->thunkSym) + " was replaced");
+      fatal(ctx.toString(*file->thunkSym) + " was replaced");
     DefinedImportThunk *thunk = cast<DefinedImportThunk>(file->thunkSym);
     if (file->thunkLive)
       textSec->addChunk(thunk->getChunk());
   }
 
   if (!delayIdata.empty()) {
-    Defined *helper = cast<Defined>(config->delayLoadHelper);
-    delayIdata.create(ctx, helper);
+    Defined *helper = cast<Defined>(ctx.config.delayLoadHelper);
+    delayIdata.create(helper);
     for (Chunk *c : delayIdata.getChunks())
       didatSec->addChunk(c);
     for (Chunk *c : delayIdata.getDataChunks())
       dataSec->addChunk(c);
     for (Chunk *c : delayIdata.getCodeChunks())
       textSec->addChunk(c);
   }
 }
 
 void Writer::createExportTable() {
   if (!edataSec->chunks.empty()) {
     // Allow using a custom built export table from input object files, instead
     // of having the linker synthesize the tables.
-    if (config->hadExplicitExports)
+    if (ctx.config.hadExplicitExports)
       warn("literal .edata sections override exports");
-  } else if (!config->exports.empty()) {
+  } else if (!ctx.config.exports.empty()) {
     for (Chunk *c : edata.chunks)
       edataSec->addChunk(c);
   }
   if (!edataSec->chunks.empty()) {
     edataStart = edataSec->chunks.front();
     edataEnd = edataSec->chunks.back();
   }
   // Warn on exported deleting destructor.
-  for (auto e : config->exports)
+  for (auto e : ctx.config.exports)
     if (e.sym && e.sym->getName().startswith("??_G"))
-      warn("export of deleting dtor: " + toString(*e.sym));
+      warn("export of deleting dtor: " + ctx.toString(*e.sym));
 }
 
 void Writer::removeUnusedSections() {
   // Remove sections that we can be sure won't get content, to avoid
   // allocating space for their section headers.
   auto isUnused = [this](OutputSection *s) {
     if (s == relocSec)
       return false; // This section is populated later.
void Writer::createSymbolAndStringTable() {
   // solution where discardable sections have long names preserved and
   // non-discardable sections have their names truncated, to ensure that any
   // section which is mapped at runtime also has its name mapped at runtime.
   for (OutputSection *sec : ctx.outputSections) {
     if (sec->name.size() <= COFF::NameSize)
       continue;
     if ((sec->header.Characteristics & IMAGE_SCN_MEM_DISCARDABLE) == 0)
       continue;
-    if (config->warnLongSectionNames) {
+    if (ctx.config.warnLongSectionNames) {
       warn("section name " + sec->name +
            " is longer than 8 characters and will use a non-standard string "
            "table");
     }
     sec->setStringTableOff(addEntryToStringTable(sec->name));
   }
 
-  if (config->debugDwarf || config->debugSymtab) {
+  if (ctx.config.debugDwarf || ctx.config.debugSymtab) {
     for (ObjFile *file : ctx.objFileInstances) {
       for (Symbol *b : file->getSymbols()) {
         auto *d = dyn_cast_or_null<Defined>(b);
         if (!d || d->writtenToSymtab)
           continue;
         d->writtenToSymtab = true;
         if (auto *dc = dyn_cast_or_null<DefinedCOFF>(d)) {
           COFFSymbolRef symRef = dc->getCOFFSymbol();
void Writer::createSymbolAndStringTable() {
   if (outputSymtab.empty() && strtab.empty())
     return;
 
   // We position the symbol table to be adjacent to the end of the last section.
   uint64_t fileOff = fileSize;
   pointerToSymbolTable = fileOff;
   fileOff += outputSymtab.size() * sizeof(coff_symbol16);
   fileOff += 4 + strtab.size();
-  fileSize = alignTo(fileOff, config->fileAlign);
+  fileSize = alignTo(fileOff, ctx.config.fileAlign);
 }
 
 void Writer::mergeSections() {
   if (!pdataSec->chunks.empty()) {
     firstPdata = pdataSec->chunks.front();
     lastPdata = pdataSec->chunks.back();
   }
 
-  for (auto &p : config->merge) {
+  for (auto &p : ctx.config.merge) {
     StringRef toName = p.second;
     if (p.first == toName)
       continue;
     StringSet<> names;
     while (true) {
       if (!names.insert(toName).second)
         fatal("/merge: cycle found for section '" + p.first + "'");
-      auto i = config->merge.find(toName);
-      if (i == config->merge.end())
+      auto i = ctx.config.merge.find(toName);
+      if (i == ctx.config.merge.end())
         break;
       toName = i->second;
     }
     OutputSection *from = findSection(p.first);
     OutputSection *to = findSection(toName);
     if (!from)
       continue;
     if (!to) {
       from->name = toName;
       continue;
     }
     to->merge(from);
   }
 }
 
 // Visits all sections to assign incremental, non-overlapping RVAs and
 // file offsets.
 void Writer::assignAddresses() {
   sizeOfHeaders = dosStubSize + sizeof(PEMagic) + sizeof(coff_file_header) +
                   sizeof(data_directory) * numberOfDataDirectory +
                   sizeof(coff_section) * ctx.outputSections.size();
   sizeOfHeaders +=
-      config->is64() ? sizeof(pe32plus_header) : sizeof(pe32_header);
-  sizeOfHeaders = alignTo(sizeOfHeaders, config->fileAlign);
+      ctx.config.is64() ? sizeof(pe32plus_header) : sizeof(pe32_header);
+  sizeOfHeaders = alignTo(sizeOfHeaders, ctx.config.fileAlign);
   fileSize = sizeOfHeaders;
 
   // The first page is kept unmapped.
-  uint64_t rva = alignTo(sizeOfHeaders, config->align);
+  uint64_t rva = alignTo(sizeOfHeaders, ctx.config.align);
 
   for (OutputSection *sec : ctx.outputSections) {
     if (sec == relocSec)
       addBaserels();
     uint64_t rawSize = 0, virtualSize = 0;
     sec->header.VirtualAddress = rva;
 
     // If /FUNCTIONPADMIN is used, functions are padded in order to create a
     // hotpatchable image.
     const bool isCodeSection =
         (sec->header.Characteristics & IMAGE_SCN_CNT_CODE) &&
         (sec->header.Characteristics & IMAGE_SCN_MEM_READ) &&
         (sec->header.Characteristics & IMAGE_SCN_MEM_EXECUTE);
-    uint32_t padding = isCodeSection ? config->functionPadMin : 0;
+    uint32_t padding = isCodeSection ? ctx.config.functionPadMin : 0;
 
     for (Chunk *c : sec->chunks) {
       if (padding && c->isHotPatchable())
         virtualSize += padding;
       virtualSize = alignTo(virtualSize, c->getAlignment());
       c->setRVA(rva + virtualSize);
       virtualSize += c->getSize();
       if (c->hasData)
-        rawSize = alignTo(virtualSize, config->fileAlign);
+        rawSize = alignTo(virtualSize, ctx.config.fileAlign);
     }
     if (virtualSize > UINT32_MAX)
       error("section larger than 4 GiB: " + sec->name);
     sec->header.VirtualSize = virtualSize;
     sec->header.SizeOfRawData = rawSize;
     if (rawSize != 0)
       sec->header.PointerToRawData = fileSize;
-    rva += alignTo(virtualSize, config->align);
-    fileSize += alignTo(rawSize, config->fileAlign);
+    rva += alignTo(virtualSize, ctx.config.align);
+    fileSize += alignTo(rawSize, ctx.config.fileAlign);
   }
-  sizeOfImage = alignTo(rva, config->align);
+  sizeOfImage = alignTo(rva, ctx.config.align);
 
   // Assign addresses to sections in MergeChunks.
   for (MergeChunk *mc : ctx.mergeChunkInstances)
     if (mc)
       mc->assignSubsectionRVAs();
 }
 
 template <typename PEHeaderTy> void Writer::writeHeader() {
template <typename PEHeaderTy> void Writer::writeHeader() {
   // Write DOS program.
   memcpy(buf, dosProgram, sizeof(dosProgram));
   buf += sizeof(dosProgram);
 
   // Write PE magic
   memcpy(buf, PEMagic, sizeof(PEMagic));
   buf += sizeof(PEMagic);
 
   // Write COFF header
   auto *coff = reinterpret_cast<coff_file_header *>(buf);
   buf += sizeof(*coff);
-  coff->Machine = config->machine;
+  coff->Machine = ctx.config.machine;
   coff->NumberOfSections = ctx.outputSections.size();
   coff->Characteristics = IMAGE_FILE_EXECUTABLE_IMAGE;
-  if (config->largeAddressAware)
+  if (ctx.config.largeAddressAware)
     coff->Characteristics |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
-  if (!config->is64())
+  if (!ctx.config.is64())
     coff->Characteristics |= IMAGE_FILE_32BIT_MACHINE;
-  if (config->dll)
+  if (ctx.config.dll)
     coff->Characteristics |= IMAGE_FILE_DLL;
-  if (config->driverUponly)
+  if (ctx.config.driverUponly)
     coff->Characteristics |= IMAGE_FILE_UP_SYSTEM_ONLY;
-  if (!config->relocatable)
+  if (!ctx.config.relocatable)
     coff->Characteristics |= IMAGE_FILE_RELOCS_STRIPPED;
-  if (config->swaprunCD)
+  if (ctx.config.swaprunCD)
     coff->Characteristics |= IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP;
-  if (config->swaprunNet)
+  if (ctx.config.swaprunNet)
     coff->Characteristics |= IMAGE_FILE_NET_RUN_FROM_SWAP;
   coff->SizeOfOptionalHeader =
       sizeof(PEHeaderTy) + sizeof(data_directory) * numberOfDataDirectory;
 
   // Write PE header
   auto *pe = reinterpret_cast<PEHeaderTy *>(buf);
   buf += sizeof(*pe);
-  pe->Magic = config->is64() ? PE32Header::PE32_PLUS : PE32Header::PE32;
+  pe->Magic = ctx.config.is64() ? PE32Header::PE32_PLUS : PE32Header::PE32;
 
   // If {Major,Minor}LinkerVersion is left at 0.0, then for some
   // reason signing the resulting PE file with Authenticode produces a
   // signature that fails to validate on Windows 7 (but is OK on 10).
   // Set it to 14.0, which is what VS2015 outputs, and which avoids
   // that problem.
   pe->MajorLinkerVersion = 14;
   pe->MinorLinkerVersion = 0;
 
-  pe->ImageBase = config->imageBase;
-  pe->SectionAlignment = config->align;
-  pe->FileAlignment = config->fileAlign;
-  pe->MajorImageVersion = config->majorImageVersion;
-  pe->MinorImageVersion = config->minorImageVersion;
-  pe->MajorOperatingSystemVersion = config->majorOSVersion;
-  pe->MinorOperatingSystemVersion = config->minorOSVersion;
-  pe->MajorSubsystemVersion = config->majorSubsystemVersion;
-  pe->MinorSubsystemVersion = config->minorSubsystemVersion;
-  pe->Subsystem = config->subsystem;
+  pe->ImageBase = ctx.config.imageBase;
+  pe->SectionAlignment = ctx.config.align;
+  pe->FileAlignment = ctx.config.fileAlign;
+  pe->MajorImageVersion = ctx.config.majorImageVersion;
+  pe->MinorImageVersion = ctx.config.minorImageVersion;
+  pe->MajorOperatingSystemVersion = ctx.config.majorOSVersion;
+  pe->MinorOperatingSystemVersion = ctx.config.minorOSVersion;
+  pe->MajorSubsystemVersion = ctx.config.majorSubsystemVersion;
+  pe->MinorSubsystemVersion = ctx.config.minorSubsystemVersion;
+  pe->Subsystem = ctx.config.subsystem;
   pe->SizeOfImage = sizeOfImage;
   pe->SizeOfHeaders = sizeOfHeaders;
-  if (!config->noEntry) {
-    Defined *entry = cast<Defined>(config->entry);
+  if (!ctx.config.noEntry) {
+    Defined *entry = cast<Defined>(ctx.config.entry);
     pe->AddressOfEntryPoint = entry->getRVA();
     // Pointer to thumb code must have the LSB set, so adjust it.
-    if (config->machine == ARMNT)
+    if (ctx.config.machine == ARMNT)
       pe->AddressOfEntryPoint |= 1;
   }
-  pe->SizeOfStackReserve = config->stackReserve;
-  pe->SizeOfStackCommit = config->stackCommit;
-  pe->SizeOfHeapReserve = config->heapReserve;
-  pe->SizeOfHeapCommit = config->heapCommit;
-  if (config->appContainer)
+  pe->SizeOfStackReserve = ctx.config.stackReserve;
+  pe->SizeOfStackCommit = ctx.config.stackCommit;
+  pe->SizeOfHeapReserve = ctx.config.heapReserve;
+  pe->SizeOfHeapCommit = ctx.config.heapCommit;
+  if (ctx.config.appContainer)
     pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_APPCONTAINER;
-  if (config->driverWdm)
+  if (ctx.config.driverWdm)
     pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_WDM_DRIVER;
-  if (config->dynamicBase)
+  if (ctx.config.dynamicBase)
     pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE;
-  if (config->highEntropyVA)
+  if (ctx.config.highEntropyVA)
     pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA;
-  if (!config->allowBind)
+  if (!ctx.config.allowBind)
     pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_NO_BIND;
-  if (config->nxCompat)
+  if (ctx.config.nxCompat)
     pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_NX_COMPAT;
-  if (!config->allowIsolation)
+  if (!ctx.config.allowIsolation)
     pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_NO_ISOLATION;
-  if (config->guardCF != GuardCFLevel::Off)
+  if (ctx.config.guardCF != GuardCFLevel::Off)
     pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_GUARD_CF;
-  if (config->integrityCheck)
+  if (ctx.config.integrityCheck)
     pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY;
-  if (setNoSEHCharacteristic || config->noSEH)
+  if (setNoSEHCharacteristic || ctx.config.noSEH)
     pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_NO_SEH;
-  if (config->terminalServerAware)
+  if (ctx.config.terminalServerAware)
     pe->DLLCharacteristics |= IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE;
   pe->NumberOfRvaAndSize = numberOfDataDirectory;
   if (textSec->getVirtualSize()) {
     pe->BaseOfCode = textSec->getRVA();
     pe->SizeOfCode = textSec->getRawSize();
   }
   pe->SizeOfInitializedData = getSizeOfInitializedData();
 
template <typename PEHeaderTy> void Writer::writeHeader() {
   }
   if (relocSec->getVirtualSize()) {
     dir[BASE_RELOCATION_TABLE].RelativeVirtualAddress = relocSec->getRVA();
     dir[BASE_RELOCATION_TABLE].Size = relocSec->getVirtualSize();
   }
   if (Symbol *sym = ctx.symtab.findUnderscore("_tls_used")) {
     if (Defined *b = dyn_cast<Defined>(sym)) {
       dir[TLS_TABLE].RelativeVirtualAddress = b->getRVA();
-      dir[TLS_TABLE].Size = config->is64()
+      dir[TLS_TABLE].Size = ctx.config.is64()
                                 ? sizeof(object::coff_tls_directory64)
                                 : sizeof(object::coff_tls_directory32);
     }
   }
   if (debugDirectory) {
     dir[DEBUG_DIRECTORY].RelativeVirtualAddress = debugDirectory->getRVA();
     dir[DEBUG_DIRECTORY].Size = debugDirectory->getSize();
   }
template <typename PEHeaderTy> void Writer::writeHeader() {
   if (!delayIdata.empty()) {
     dir[DELAY_IMPORT_DESCRIPTOR].RelativeVirtualAddress =
         delayIdata.getDirRVA();
     dir[DELAY_IMPORT_DESCRIPTOR].Size = delayIdata.getDirSize();
   }
 
   // Write section table
   for (OutputSection *sec : ctx.outputSections) {
-    sec->writeHeaderTo(buf);
+    sec->writeHeaderTo(buf, ctx.config.debug);
     buf += sizeof(coff_section);
   }
   sectionTable = ArrayRef<uint8_t>(
       buf - ctx.outputSections.size() * sizeof(coff_section), buf);
 
   if (outputSymtab.empty() && strtab.empty())
     return;
 
case Symbol::DefinedRegularKind: {
     }
     break;
   }
   }
 }
 
 // Visit all relocations from all section contributions of this object file and
 // mark the relocation target as address-taken.
-static void markSymbolsWithRelocations(ObjFile *file,
+void Writer::markSymbolsWithRelocations(ObjFile *file,
                                         SymbolRVASet &usedSymbols) {
   for (Chunk *c : file->getChunks()) {
     // We only care about live section chunks. Common chunks and other chunks
     // don't generally contain relocations.
     SectionChunk *sc = dyn_cast<SectionChunk>(c);
     if (!sc || !sc->live)
       continue;
 
     for (const coff_relocation &reloc : sc->getRelocs()) {
-      if (config->machine == I386 && reloc.Type == COFF::IMAGE_REL_I386_REL32)
+      if (ctx.config.machine == I386 &&
+          reloc.Type == COFF::IMAGE_REL_I386_REL32)
         // Ignore relative relocations on x86. On x86_64 they can't be ignored
         // since they're also used to compute absolute addresses.
         continue;
 
       Symbol *ref = sc->file->getSymbol(reloc.SymbolTableIndex);
       maybeAddAddressTakenFunction(usedSymbols, ref);
     }
   }
if (file->hasGuardCF()) {
       markSymbolsForRVATable(file, file->getGuardLJmpChunks(), longJmpTargets);
       markSymbolsForRVATable(file, file->getGuardEHContChunks(), ehContTargets);
     } else {
       markSymbolsWithRelocations(file, addressTakenSyms);
     }
   }
 
   // Mark the image entry as address-taken.
-  if (config->entry)
-    maybeAddAddressTakenFunction(addressTakenSyms, config->entry);
+  if (ctx.config.entry)
+    maybeAddAddressTakenFunction(addressTakenSyms, ctx.config.entry);
 
   // Mark exported symbols in executable sections as address-taken.
-  for (Export &e : config->exports)
+  for (Export &e : ctx.config.exports)
     maybeAddAddressTakenFunction(addressTakenSyms, e.sym);
 
   // For each entry in the .giats table, check if it has a corresponding load
   // thunk (e.g. because the DLL that defines it will be delay-loaded) and, if
   // so, add the load thunk to the address taken (.gfids) table.
   for (Symbol *s : giatsSymbols) {
     if (auto *di = dyn_cast<DefinedImportData>(s)) {
       if (di->loadThunkSym)
         addSymbolToRVASet(addressTakenSyms, di->loadThunkSym);
     }
   }
 
   // Ensure sections referenced in the gfid table are 16-byte aligned.
   for (const ChunkAndOffset &c : addressTakenSyms)
     if (c.inputChunk->getAlignment() < 16)
       c.inputChunk->setAlignment(16);
 
   maybeAddRVATable(std::move(addressTakenSyms), "__guard_fids_table",
                    "__guard_fids_count");
 
   // Add the Guard Address Taken IAT Entry Table (.giats).
   maybeAddRVATable(std::move(giatsRVASet), "__guard_iat_table",
                    "__guard_iat_count");
 
   // Add the longjmp target table unless the user told us not to.
-  if (config->guardCF & GuardCFLevel::LongJmp)
+  if (ctx.config.guardCF & GuardCFLevel::LongJmp)
     maybeAddRVATable(std::move(longJmpTargets), "__guard_longjmp_table",
                      "__guard_longjmp_count");
 
   // Add the ehcont target table unless the user told us not to.
-  if (config->guardCF & GuardCFLevel::EHCont)
+  if (ctx.config.guardCF & GuardCFLevel::EHCont)
     maybeAddRVATable(std::move(ehContTargets), "__guard_eh_cont_table",
                      "__guard_eh_cont_count", true);
 
   // Set __guard_flags, which will be used in the load config to indicate that
   // /guard:cf was enabled.
   uint32_t guardFlags = uint32_t(coff_guard_flags::CFInstrumented) |
                         uint32_t(coff_guard_flags::HasFidTable);
-  if (config->guardCF & GuardCFLevel::LongJmp)
+  if (ctx.config.guardCF & GuardCFLevel::LongJmp)
     guardFlags |= uint32_t(coff_guard_flags::HasLongJmpTable);
-  if (config->guardCF & GuardCFLevel::EHCont)
+  if (ctx.config.guardCF & GuardCFLevel::EHCont)
     guardFlags |= uint32_t(coff_guard_flags::HasEHContTable);
   Symbol *flagSym = ctx.symtab.findUnderscore("__guard_flags");
   cast<DefinedAbsolute>(flagSym)->setVA(guardFlags);
 }
 
 // Take a list of input sections containing symbol table indices and add those
 // symbols to a vector. The challenge is that symbol RVAs are not known and
 // depend on the table size, so we can't directly build a set of integers.
void Writer::createRuntimePseudoRelocs() {
 
   for (Chunk *c : ctx.symtab.getChunks()) {
     auto *sc = dyn_cast<SectionChunk>(c);
     if (!sc || !sc->live)
       continue;
     sc->getRuntimePseudoRelocs(rels);
   }
 
-  if (!config->pseudoRelocs) {
+  if (!ctx.config.pseudoRelocs) {
     // Not writing any pseudo relocs; if some were needed, error out and
     // indicate what required them.
     for (const RuntimePseudoReloc &rpr : rels)
       error("automatic dllimport of " + rpr.sym->getName() + " in " +
             toString(rpr.target->file) + " requires pseudo relocations");
     return;
   }
 

 }
 
 // MinGW specific.
 // The MinGW .ctors and .dtors lists have sentinels at each end;
 // a (uintptr_t)-1 at the start and a (uintptr_t)0 at the end.
 // There's a symbol pointing to the start sentinel pointer, __CTOR_LIST__
 // and __DTOR_LIST__ respectively.
 void Writer::insertCtorDtorSymbols() {
-  AbsolutePointerChunk *ctorListHead = make<AbsolutePointerChunk>(-1);
-  AbsolutePointerChunk *ctorListEnd = make<AbsolutePointerChunk>(0);
-  AbsolutePointerChunk *dtorListHead = make<AbsolutePointerChunk>(-1);
-  AbsolutePointerChunk *dtorListEnd = make<AbsolutePointerChunk>(0);
+  AbsolutePointerChunk *ctorListHead = make<AbsolutePointerChunk>(ctx, -1);
+  AbsolutePointerChunk *ctorListEnd = make<AbsolutePointerChunk>(ctx, 0);
+  AbsolutePointerChunk *dtorListHead = make<AbsolutePointerChunk>(ctx, -1);
+  AbsolutePointerChunk *dtorListEnd = make<AbsolutePointerChunk>(ctx, 0);
   ctorsSec->insertChunkAtStart(ctorListHead);
   ctorsSec->addChunk(ctorListEnd);
   dtorsSec->insertChunkAtStart(dtorListHead);
   dtorsSec->addChunk(dtorListEnd);
 
   Symbol *ctorListSym = ctx.symtab.findUnderscore("__CTOR_LIST__");
   Symbol *dtorListSym = ctx.symtab.findUnderscore("__DTOR_LIST__");
   replaceSymbol<DefinedSynthetic>(ctorListSym, ctorListSym->getName(),
                                   ctorListHead);
   replaceSymbol<DefinedSynthetic>(dtorListSym, dtorListSym->getName(),
                                   dtorListHead);
 }
 
 // Handles /section options to allow users to overwrite
 // section attributes.
 void Writer::setSectionPermissions() {
-  for (auto &p : config->section) {
+  for (auto &p : ctx.config.section) {
     StringRef name = p.first;
     uint32_t perm = p.second;
     for (OutputSection *sec : ctx.outputSections)
       if (sec->name == name)
         sec->setPermissions(perm);
   }
 }
 
 // Write section contents to a mmap'ed file.
 void Writer::writeSections() {
-  // Record the number of sections to apply section index relocations
-  // against absolute symbols. See applySecIdx in Chunks.cpp..
-  DefinedAbsolute::numOutputSections = ctx.outputSections.size();
-
   uint8_t *buf = buffer->getBufferStart();
   for (OutputSection *sec : ctx.outputSections) {
     uint8_t *secBuf = buf + sec->getFileOff();
     // Fill gaps between functions in .text with INT3 instructions
     // instead of leaving as NUL bytes (which can be interpreted as
     // ADD instructions).
     if (sec->header.Characteristics & IMAGE_SCN_CNT_CODE)
       memset(secBuf, 0xCC, sec->getRawSize());
     parallelForEach(sec->chunks, [&](Chunk *c) {
       c->writeTo(secBuf + c->getRVA() - sec->getRVA());
     });
   }
 }
 
 void Writer::writeBuildId() {
   // There are two important parts to the build ID.
   // 1) If building with debug info, the COFF debug directory contains a
   //    timestamp as well as a Guid and Age of the PDB.
   // 2) In all cases, the PE COFF file header also contains a timestamp.
   // For reproducibility, instead of a timestamp we want to use a hash of the
   // PE contents.
-  if (config->debug) {
+  if (ctx.config.debug) {
     assert(buildId && "BuildId is not set!");
     // BuildId->BuildId was filled in when the PDB was written.
   }
 
   // At this point the only fields in the COFF file which remain unset are the
   // "timestamp" in the COFF file header, and the ones in the coff debug
   // directory.  Now we can hash the file and write that hash to the various
   // timestamp fields in the file.
   StringRef outputFileData(
       reinterpret_cast<const char *>(buffer->getBufferStart()),
       buffer->getBufferSize());
 
-  uint32_t timestamp = config->timestamp;
+  uint32_t timestamp = ctx.config.timestamp;
   uint64_t hash = 0;
   bool generateSyntheticBuildId =
-      config->mingw && config->debug && config->pdbPath.empty();
+      ctx.config.mingw && ctx.config.debug && ctx.config.pdbPath.empty();
 
-  if (config->repro || generateSyntheticBuildId)
+  if (ctx.config.repro || generateSyntheticBuildId)
     hash = xxHash64(outputFileData);
 
-  if (config->repro)
+  if (ctx.config.repro)
     timestamp = static_cast<uint32_t>(hash);
 
   if (generateSyntheticBuildId) {
     // For MinGW builds without a PDB file, we still generate a build id
     // to allow associating a crash dump to the executable.
     buildId->buildId->PDB70.CVSignature = OMF::Signature::PDB70;
     buildId->buildId->PDB70.Age = 1;
     memcpy(buildId->buildId->PDB70.Signature, &hash, 8);
void Writer::sortExceptionTable() {
   // We assume .pdata contains function table entries only.
   auto bufAddr = [&](Chunk *c) {
     OutputSection *os = ctx.getOutputSection(c);
     return buffer->getBufferStart() + os->getFileOff() + c->getRVA() -
            os->getRVA();
   };
   uint8_t *begin = bufAddr(firstPdata);
   uint8_t *end = bufAddr(lastPdata) + lastPdata->getSize();
-  if (config->machine == AMD64) {
+  if (ctx.config.machine == AMD64) {
     struct Entry { ulittle32_t begin, end, unwind; };
     if ((end - begin) % sizeof(Entry) != 0) {
       fatal("unexpected .pdata size: " + Twine(end - begin) +
             " is not a multiple of " + Twine(sizeof(Entry)));
     }
     parallelSort(
         MutableArrayRef<Entry>((Entry *)begin, (Entry *)end),
         [](const Entry &a, const Entry &b) { return a.begin < b.begin; });
     return;
   }
-  if (config->machine == ARMNT || config->machine == ARM64) {
+  if (ctx.config.machine == ARMNT || ctx.config.machine == ARM64) {
     struct Entry { ulittle32_t begin, unwind; };
     if ((end - begin) % sizeof(Entry) != 0) {
       fatal("unexpected .pdata size: " + Twine(end - begin) +
             " is not a multiple of " + Twine(sizeof(Entry)));
     }
     parallelSort(
         MutableArrayRef<Entry>((Entry *)begin, (Entry *)end),
         [](const Entry &a, const Entry &b) { return a.begin < b.begin; });
auto sectionChunkOrder = [](const Chunk *a, const Chunk *b) {
 
     StringRef sAObj = sa->file->mb.getBufferIdentifier();
     StringRef sBObj = sb->file->mb.getBufferIdentifier();
 
     return sAObj == sBObj && sa->getSectionNumber() < sb->getSectionNumber();
   };
   llvm::stable_sort(chunks, sectionChunkOrder);
 
-  if (config->verbose) {
+  if (ctx.config.verbose) {
     for (auto &c : chunks) {
       auto sc = dyn_cast<SectionChunk>(c);
       log("  " + sc->file->mb.getBufferIdentifier().str() +
           ", SectionID: " + Twine(sc->getSectionNumber()));
     }
   }
 }
 
uint32_t Writer::getSizeOfInitializedData() {
   for (OutputSection *s : ctx.outputSections)
     if (s->header.Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
       res += s->getRawSize();
   return res;
 }
 
 // Add base relocations to .reloc section.
 void Writer::addBaserels() {
-  if (!config->relocatable)
+  if (!ctx.config.relocatable)
     return;
   relocSec->chunks.clear();
   std::vector<Baserel> v;
   for (OutputSection *sec : ctx.outputSections) {
     if (sec->header.Characteristics & IMAGE_SCN_MEM_DISCARDABLE)
       continue;
     // Collect all locations for base relocations.
     for (Chunk *c : sec->chunks)
if (!tlsSym)
     return;
 
   OutputSection *sec = ctx.getOutputSection(tlsSym->getChunk());
   assert(sec && tlsSym->getRVA() >= sec->getRVA() &&
          "no output section for _tls_used");
 
   uint8_t *secBuf = buffer->getBufferStart() + sec->getFileOff();
   uint64_t tlsOffset = tlsSym->getRVA() - sec->getRVA();
-  uint64_t directorySize = config->is64()
+  uint64_t directorySize = ctx.config.is64()
                                ? sizeof(object::coff_tls_directory64)
                                : sizeof(object::coff_tls_directory32);
 
   if (tlsOffset + directorySize > sec->getRawSize())
     fatal("_tls_used sym is malformed");
 
-  if (config->is64()) {
+  if (ctx.config.is64()) {
     object::coff_tls_directory64 *tlsDir =
         reinterpret_cast<object::coff_tls_directory64 *>(&secBuf[tlsOffset]);
     tlsDir->setAlignment(tlsAlignment);
   } else {
     object::coff_tls_directory32 *tlsDir =
         reinterpret_cast<object::coff_tls_directory32 *>(&secBuf[tlsOffset]);
     tlsDir->setAlignment(tlsAlignment);
   }
 }