[LLD] [COFF] Support MinGW automatic dllimport of data

[mstorsjo]

Summary

Normally, in order to reference exported data symbols from a different DLL, the declarations need to have the dllimport attribute, in order to use the __imp_<var> symbol (which contains an address to the actual variable) instead of the variable itself directly. This isn't an issue in the same way for functions, since any reference to the function without the dllimport attribute will end up as a reference to a thunk which loads the actual target function from the import address table (IAT).

GNU ld, in MinGW environments, supports automatically importing data symbols from DLLs, even if the references didn't have the appropriate dllimport attribute. Since the PE/COFF format doesn't support the kind of relocations that this would require, the MinGW's CRT startup code has an custom framework of their own for manually fixing the missing relocations once module is loaded and the target addresses in the IAT are known.

For this to work, the linker (originall in GNU ld) creates a list of remaining references needing fixup, which the runtime processes on startup before handing over control to user code.

While this feature is rather controversial, it's one of the main features allowing unix style libraries to be used on windows without any extra porting effort.

Some sort of automatic fixing of data imports is also necessary for the itanium C++ ABI on windows (as clang implements it right now) for importing vtable pointers in certain cases, see D43184 for some discussion on that.

The runtime pseudo relocation handler supports 8/16/32/64 bit addresses, either PC relative references (like IMAGE_REL_*_REL32*) or absolute references (IMAGE_REL_AMD64_ADDR32, IMAGE_REL_AMD64_ADDR32, IMAGE_REL_I386_DIR32). On linking, the relocation is handled as a relocation against the corresponding IAT slot. For the absolute references, a normal base relocation is created, to update the embedded address in case the image is loaded at a different address.

The list of runtime pseudo relocations contains the RVA of the imported symbol (the IAT slot), the RVA of the location the relocation should be applied to, and a size of the memory location. When the relocations are fixed at runtime, the difference between the actual IAT slot value and the IAT slot address is added to the reference, doing the right thing for both absolute and relative references.

With this patch alone, things work fine for i386 binaries, and mostly for x86_64 binaries, with feature parity with GNU ld. Despite this,
there are a few gotchas:

• References to data from within code works fine on both x86 architectures, since their relocations consist of plain 32 or 64 bit absolute/relative references. On ARM and AArch64, references to data doesn't consist of a plain 32 or 64 bit embedded address or offset in the code. On ARMNT, it's usually a MOVW+MOVT instruction pair represented by a IMAGE_REL_ARM_MOV32T relocation, each instruction containing 16 bit of the target address), on AArch64, it's usually an ADRP+ADD/LDR/STR instruction pair with an even more complex encoding, storing a PC relative address (with a range of +/- 4 GB). This could theoretically be remedied by extending the runtime pseudo relocation handler with new relocation types, to support these instruction encodings. This isn't an issue for GCC/GNU ld since they don't support windows on ARMNT/AArch64.
• For x86_64, if references in code are encoded as 32 bit PC relative offsets, the runtime relocation will fail if the target turns out to be out of range for a 32 bit offset.
• Fixing up the relocations at runtime requires making sections writable if necessary, with the VirtualProtect function. In Windows Store/UWP apps, this function is forbidden.

These limitations will be addressed by a few later patches in lld and llvm.

[rnk]

Sigh. ELF supports too much and lets people do too much, and then we have to go reimplement that functionality badly for other object file formats that tried to be simple.

Anyway, we should do something. I understand that for many developers, Windows is a corner case platform and they are going to spend approximately zero effort porting their code to it, so this feature is valuable to them.

Will subsequent LLVM patches make the compiler use more general code sequences for global variable access, like an IAT load? That would address the list of architectural limitations you outlined.

COFF/Chunks.h

161 ↗

(On Diff #161304)

This can be a reference to indicate that it is required and not nullable.

test/COFF/autoimport-arm-code.s

10 ↗

(On Diff #161304)

Do we have a table to print relocations symbolically?

[mstorsjo]

In D50917#1206111, @rnk wrote:

Sigh. ELF supports too much and lets people do too much, and then we have to go reimplement that functionality badly for other object file formats that tried to be simple.

Anyway, we should do something. I understand that for many developers, Windows is a corner case platform and they are going to spend approximately zero effort porting their code to it, so this feature is valuable to them.

Indeed... While using this feature to handle libraries public APIs with data symbols is one thing, the fact that it more or less is required for the itanium C++ ABI tipped the scales for me about implementing it (instead of the clang-contained kludge I tried before).

Will subsequent LLVM patches make the compiler use more general code sequences for global variable access, like an IAT load? That would address the list of architectural limitations you outlined.

Yes, exactly. I've got patches that make every global variable access (except those where we do see a definition, making it sure that it really is DSO local) go via a variable stub. And once you have such a stub, you can even replace accesses to it with an access to __imp_<sym> in the linker, avoiding most runtime relocations (except for cases where the pointer is used in initialized data, like in the C++ cases). And finally we can make all sections that still contain runtime relocations writable, avoiding any need for VirtualProtect at runtime.

COFF/Chunks.h

161 ↗

(On Diff #161304)

Ok, will change.

test/COFF/autoimport-arm-code.s

10 ↗

(On Diff #161304)

Yes, there is something in lib/Object, I'll try to make use of it.

[mstorsjo]

Printing relocs symbolically (depends on D50995), using a vector reference instead of a pointer as parameter.

[mstorsjo]

Any further comments on this, or is this tolerable enough?

[pcc]

COFF/Chunks.h

420 ↗

(On Diff #161555)

Would it be simpler to have a single PseudoRelocChunk for all the pseudo-relocs instead of creating a separate one for each reloc?

447 ↗

(On Diff #161555)

It looks like this function is not used.

COFF/SymbolTable.cpp

208 ↗

(On Diff #161555)

It looks like the RVA of the IAT entry is stored in the pseudo-reloc. So does this need to be relocated to the IAT entry? Could you replace it with a DefinedAbsolute of value 0 for example?

[mstorsjo]

COFF/Chunks.h

420 ↗

(On Diff #161555)

I guess that could work just as well.

447 ↗

(On Diff #161555)

Hmm, indeed, will remove.

COFF/SymbolTable.cpp

208 ↗

(On Diff #161555)

Yes, this needs to be relocated to the IAT entry - DefinedAbsolute with a zero value won't work.

At runtime, the runtime pseudo reloc mechanism only adds the difference between IAT entry itself and IAT entry value to the relocation address; this makes it work the same both for absolute addresses and RIP relative addressing.

[mstorsjo]

Applied @pcc's suggestions; the pseudo reloc table/list turned out much cleaner/nicer with just one Chunk containing it all, removed the unused method.

[ruiu]

This patch looks okay to me though it is unfortunate that we need to support it. This patch overall lacks explanation -- at somewhere in the patch, I'd explain what is automatic import and how lld supports that functionality. Once you get an overview, details should hopefully become self-explanatory.

COFF/Chunks.cpp

422 ↗

(On Diff #162463)

It's not clear to me what this function is supposed to return in the first place. Could you write a brief function comment?

493 ↗

(On Diff #162463)

What this function is doing? Please write a brief function comment.

494 ↗

(On Diff #162463)

If Res is always empty at the entry of this function, return a new instance of a std::vector instead of taking an instance of std::vector as a reference.

631 ↗

(On Diff #162463)

There's no explanation of "pseudo relocation". Please explain it somewhere.

COFF/Chunks.h

424 ↗

(On Diff #162463)

Please add comment to explain what this is.

436–437 ↗

(On Diff #162463)

Please explain the motivation of defining these classes in the first place. In particular, I'd mention that we don't really need this for MS compatibility but this is for MinGW.

445 ↗

(On Diff #162463)

Ditto

COFF/SymbolTable.cpp

197 ↗

(On Diff #162463)

This function is already too long. Please consider splitting to a new function.

COFF/Writer.cpp

1148 ↗

(On Diff #162463)

Please add a comment.

[mstorsjo]

COFF/Chunks.cpp

422 ↗

(On Diff #162463)

Sure, will do - with this explanation:

// 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.

493 ↗

(On Diff #162463)

Will do, like this:

// Append information to the provided vector about all relocations that
// need to be handled at runtime as runtime pseudo relocations (references
// to a module local variable, which turned out to actually need to be
// imported from another DLL).

494 ↗

(On Diff #162463)

It isn't empty at entry; we append entries to an existing vector.

631 ↗

(On Diff #162463)

Adding a comment like this above here:

// MinGW specific, for the "automatic import of variables from DLLs" feature.

I added a slightly longer comment about the same class in Chunks.h as well.

COFF/Chunks.h

424 ↗

(On Diff #162463)

I'll add a comment like this:

// MinGW specific, for the "automatic import of variables from DLLs" feature.
// This provides the table of runtime pseudo relocations, for variable
// references that turned out to need to be imported from a DLL even though
// the reference didn't use the dllimport attribute. The MinGW runtime will
// process this table after loading, before handling control over to user
// code.

436–437 ↗

(On Diff #162463)

Well the EmptyChunk isn't inherently anything MinGW specific at all, I could imagine that it would be useful for any case where you want to attach a Symbol to a specific place in an OutputSection, without actually producing any content.

I can mention that it is used for the MinGW specific __RUNTIME_PSEUDO_RELOC_LIST_END__ symbol if that makes it clearer?

445 ↗

(On Diff #162463)

Added a comment like this:

// MinGW specific; information about one individual location in the image
// that needs to be fixed up at runtime after loading. This represents
// one individual element in the PseudoRelocTableChunk table.

COFF/SymbolTable.cpp

197 ↗

(On Diff #162463)

Done, split the extra new added code to a separate method.

COFF/Writer.cpp

1148 ↗

(On Diff #162463)

I wrote:

// MinGW specific. Gather all relocations that are imported from a DLL even
// though the code didn't expect it to, produce the table that the runtime
// uses for fixing them up, and provide the synthetic symbols that the
// runtime uses for finding the table.

[mstorsjo]

Updated according to @ruiu's comments. I also updated the patch summary (the first three paragraphs are updated/rewritten) to introduce the feature a little better.

[ruiu]

COFF/Chunks.cpp

428 ↗

(On Diff #162618)

I'd add MinGW specific. to all functions that are added in this patch.

525 ↗

(On Diff #162618)

SizeInBits is called Flags in RuntimePseudoReloc class. I was little confused because Flags sounds like bit flags. Can you consistently use one name?

COFF/SymbolTable.cpp

163 ↗

(On Diff #162618)

nit: add a blank line.

COFF/Writer.cpp

191 ↗

(On Diff #162618)

Looks like this variable is used only by one function. Can this be a local variable?

[mstorsjo]

COFF/Chunks.cpp

428 ↗

(On Diff #162618)

Ok, will do, except for methods where MinGW is part of the name where it otherwise is apparent.

525 ↗

(On Diff #162618)

This dualism comes from the MinGW sources itself; the field is called Flags in the struct, but so far the only flags used is the size of the relocation, but I guess they've left it open to use other higher bits. I'll try to clarify this.

COFF/Writer.cpp

191 ↗

(On Diff #162618)

Not really, the PseudoRelocTableChunk contains an ArrayRef to this, so it needs to be kept alive until the chunks actually are written.

[mstorsjo]

Clarified the comments further, as requested.

[ruiu]

COFF/Writer.cpp

191 ↗

(On Diff #162618)

Then maybe you can transfer the ownership of the object?

[mstorsjo]

Transferring ownership of the runtime pseudo relocs vector to the Chunk that will write it.

[ruiu]

LGTM

Thank you for doing this. It looks much less intrusive than I originally thought. Also, thank you for all your code comments. I believe it the new code is easy to understand.

COFF/Writer.cpp

1152 ↗

(On Diff #162627)

Since the scope of this variable is much narrower than before, I'd use a shorter name, such as Rels.

[mstorsjo]

In D50917#1214042, @ruiu wrote:

LGTM

Thank you for doing this. It looks much less intrusive than I originally thought. Also, thank you for all your code comments. I believe it the new code is easy to understand.

Thanks for taking the time to review it! I was also initially pleasantly surprised by how easy it was to implement.

COFF/Writer.cpp

1152 ↗

(On Diff #162627)

Oh, right, yes. Will change before committing.

lld/trunk/COFF/Chunks.h

 using llvm::object::coff_section;
 
 class Baserel;
 class Defined;
 class DefinedImportData;
 class DefinedRegular;
 class ObjFile;
 class OutputSection;
+class RuntimePseudoReloc;
 class Symbol;
 
 // Mask for permissions (discardable, writable, readable, executable, etc).
 const uint32_t PermMask = 0xFE000000;
 
 // Mask for section types (code, data, bss).
 const uint32_t TypeMask = 0x000000E0;
 
void applyRelX64(uint8_t *Off, uint16_t Type, OutputSection *OS, uint64_t S,
                    uint64_t P) const;
   void applyRelX86(uint8_t *Off, uint16_t Type, OutputSection *OS, uint64_t S,
                    uint64_t P) const;
   void applyRelARM(uint8_t *Off, uint16_t Type, OutputSection *OS, uint64_t S,
                    uint64_t P) const;
   void applyRelARM64(uint8_t *Off, uint16_t Type, OutputSection *OS, uint64_t S,
                      uint64_t P) 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
   // and its children are treated as a group by the garbage collector.
   void addAssociative(SectionChunk *Child);
 
public:
   Baserel(uint32_t V, uint8_t Ty) : RVA(V), Type(Ty) {}
   explicit Baserel(uint32_t V) : Baserel(V, getDefaultType()) {}
   uint8_t getDefaultType();
 
   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
+// of an empty chunk isn't MinGW specific.
+class EmptyChunk : public Chunk {
+public:
+  EmptyChunk() {}
+  size_t getSize() const override { return 0; }
+  void writeTo(uint8_t *Buf) const override {}
+};
+
+// MinGW specific, for the "automatic import of variables from DLLs" feature.
+// This provides the table of runtime pseudo relocations, for variable
+// references that turned out to need to be imported from a DLL even though
+// the reference didn't use the dllimport attribute. The MinGW runtime will
+// process this table after loading, before handling control over to user
+// code.
+class PseudoRelocTableChunk : public Chunk {
+public:
+  PseudoRelocTableChunk(std::vector<RuntimePseudoReloc> &Relocs)
+      : Relocs(std::move(Relocs)) {
+    Alignment = 4;
+  }
+  size_t getSize() const override;
+  void writeTo(uint8_t *Buf) const override;
+
+private:
+  std::vector<RuntimePseudoReloc> Relocs;
+};
+
+// MinGW specific; information about one individual location in the image
+// that needs to be fixed up at runtime after loading. This represents
+// one individual element in the PseudoRelocTableChunk table.
+class RuntimePseudoReloc {
+public:
+  RuntimePseudoReloc(Defined *Sym, SectionChunk *Target, uint32_t TargetOffset,
+                     int Flags)
+      : Sym(Sym), Target(Target), TargetOffset(TargetOffset), Flags(Flags) {}
+
+  Defined *Sym;
+  SectionChunk *Target;
+  uint32_t TargetOffset;
+  // The Flags field contains the size of the relocation, in bits. No other
+  // flags are currently defined.
+  int Flags;
+};
+
 void applyMOV32T(uint8_t *Off, uint32_t V);
 void applyBranch24T(uint8_t *Off, int32_t V);
 
 } // namespace coff
 } // namespace lld
 
 namespace llvm {
 template <>
 struct DenseMapInfo<lld::coff::ChunkAndOffset>
     : lld::coff::ChunkAndOffset::DenseMapInfo {};
 }
 
 #endif

lld/trunk/COFF/Chunks.cpp

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) {
+  // 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;
+  //   DWORD target;
+  //   DWORD flags;
+  // } runtime_pseudo_reloc_item_v2;
+  //
+  // the runtime relocation performs this adjustment:
+  //     *(base + .target) += *(base + .sym) - (base + .sym)
+  //
+  // This works for both absolute addresses (IMAGE_REL_*_ADDR32/64,
+  // IMAGE_REL_I386_DIR32, where the memory location initially contains
+  // 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) {
+  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:
+    case IMAGE_REL_AMD64_REL32_3:
+    case IMAGE_REL_AMD64_REL32_4:
+    case IMAGE_REL_AMD64_REL32_5:
+      return 32;
+    default:
+      return 0;
+    }
+  case I386:
+    switch (Type) {
+    case IMAGE_REL_I386_DIR32:
+    case IMAGE_REL_I386_REL32:
+      return 32;
+    default:
+      return 0;
+    }
+  case ARMNT:
+    switch (Type) {
+    case IMAGE_REL_ARM_ADDR32:
+      return 32;
+    default:
+      return 0;
+    }
+  case ARM64:
+    switch (Type) {
+    case IMAGE_REL_ARM64_ADDR64:
+      return 64;
+    case IMAGE_REL_ARM64_ADDR32:
+      return 32;
+    default:
+      return 0;
+    }
+  default:
+    llvm_unreachable("unknown machine type");
+  }
+}
+
+// MinGW specific.
+// Append information to the provided vector about all relocations that
+// need to be handled at runtime as runtime pseudo relocations (references
+// to a module local variable, which turned out to actually need to be
+// imported from another DLL).
+void SectionChunk::getRuntimePseudoRelocs(
+    std::vector<RuntimePseudoReloc> &Res) {
+  for (const coff_relocation &Rel : Relocs) {
+    auto *Target = dyn_cast_or_null<DefinedImportData>(
+        File->getSymbol(Rel.SymbolTableIndex));
+    if (!Target || !Target->IsRuntimePseudoReloc)
+      continue;
+    int SizeInBits = getRuntimePseudoRelocSize(Rel.Type);
+    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
+    // other flags are defined.
+    Res.emplace_back(
+        RuntimePseudoReloc(Target, this, Rel.VirtualAddress, SizeInBits));
+  }
+}
+
 bool SectionChunk::hasData() const {
   return !(Header->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA);
 }
 
 uint32_t SectionChunk::getOutputCharacteristics() const {
   return Header->Characteristics & (PermMask | TypeMask);
 }
 
void RVATableChunk::writeTo(uint8_t *Buf) const {
   size_t Cnt = 0;
   for (const ChunkAndOffset &CO : Syms)
     Begin[Cnt++] = CO.InputChunk->getRVA() + CO.Offset;
   std::sort(Begin, Begin + Cnt);
   assert(std::unique(Begin, Begin + Cnt) == Begin + Cnt &&
          "RVA tables should be de-duplicated");
 }
 
+// MinGW specific, for the "automatic import of variables from DLLs" feature.
+size_t PseudoRelocTableChunk::getSize() const {
+  if (Relocs.empty())
+    return 0;
+  return 12 + 12 * Relocs.size();
+}
+
+// MinGW specific.
+void PseudoRelocTableChunk::writeTo(uint8_t *Buf) const {
+  if (Relocs.empty())
+    return;
+
+  ulittle32_t *Table = reinterpret_cast<ulittle32_t *>(Buf + OutputSectionOff);
+  // This is the list header, to signal the runtime pseudo relocation v2
+  // format.
+  Table[0] = 0;
+  Table[1] = 0;
+  Table[2] = 1;
+
+  size_t Idx = 3;
+  for (const RuntimePseudoReloc &RPR : Relocs) {
+    Table[Idx + 0] = RPR.Sym->getRVA();
+    Table[Idx + 1] = RPR.Target->getRVA() + RPR.TargetOffset;
+    Table[Idx + 2] = RPR.Flags;
+    Idx += 3;
+  }
+}
+
 // Windows-specific. This class represents a block in .reloc section.
 // The format is described here.
 //
 // On Windows, each DLL is linked against a fixed base address and
 // usually loaded to that address. However, if there's already another
 // DLL that overlaps, the loader has to relocate it. To do that, DLLs
 // contain .reloc sections which contain offsets that need to be fixed
 // up at runtime. If the loader finds that a DLL cannot be loaded to its

lld/trunk/COFF/Driver.cpp

void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   Symtab->addAbsolute(mangle("__guard_flags"), 0);
   Symtab->addAbsolute(mangle("__guard_iat_count"), 0);
   Symtab->addAbsolute(mangle("__guard_iat_table"), 0);
   Symtab->addAbsolute(mangle("__guard_longjmp_count"), 0);
   Symtab->addAbsolute(mangle("__guard_longjmp_table"), 0);
   // Needed for MSVC 2017 15.5 CRT.
   Symtab->addAbsolute(mangle("__enclave_config"), 0);
 
+  if (Config->MinGW) {
+    Symtab->addAbsolute(mangle("__RUNTIME_PSEUDO_RELOC_LIST__"), 0);
+    Symtab->addAbsolute(mangle("__RUNTIME_PSEUDO_RELOC_LIST_END__"), 0);
+  }
+
   // This code may add new undefined symbols to the link, which may enqueue more
   // symbol resolution tasks, so we need to continue executing tasks until we
   // converge.
   do {
     // Windows specific -- if entry point is not found,
     // search for its mangled names.
     if (Config->Entry)
       Symtab->mangleMaybe(Config->Entry);
void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   if (errorCount())
     return;
 
   // Do LTO by compiling bitcode input files to a set of native COFF files then
   // link those files.
   Symtab->addCombinedLTOObjects();
   run();
 
+  if (Config->MinGW) {
+    // Load any further object files that might be needed for doing automatic
+    // imports.
+    //
+    // For cases with no automatically imported symbols, this iterates once
+    // over the symbol table and doesn't do anything.
+    //
+    // For the normal case with a few automatically imported symbols, this
+    // should only need to be run once, since each new object file imported
+    // is an import library and wouldn't add any new undefined references,
+    // but there's nothing stopping the __imp_ symbols from coming from a
+    // normal object file as well (although that won't be used for the
+    // actual autoimport later on). If this pass adds new undefined references,
+    // we won't iterate further to resolve them.
+    Symtab->loadMinGWAutomaticImports();
+    run();
+  }
+
   // Make sure we have resolved all symbols.
   Symtab->reportRemainingUndefines();
   if (errorCount())
     return;
 
   // Handle /safeseh.
   if (Args.hasFlag(OPT_safeseh, OPT_safeseh_no, false)) {
     for (ObjFile *File : ObjFile::Instances)

lld/trunk/COFF/SymbolTable.h

 public:
   void addFile(InputFile *File);
 
   // Try to resolve any undefined symbols and update the symbol table
   // accordingly, then print an error message for any remaining undefined
   // symbols.
   void reportRemainingUndefines();
 
+  void loadMinGWAutomaticImports();
+  bool handleMinGWAutomaticImport(Symbol *Sym, StringRef Name);
+
   // Returns a list of chunks of selected symbols.
   std::vector<Chunk *> getChunks();
 
   // Returns a symbol for a given name. Returns a nullptr if not found.
   Symbol *find(StringRef Name);
   Symbol *findUnderscore(StringRef Name);
 
   // Occasionally we have to resolve an undefined symbol to its

lld/trunk/COFF/SymbolTable.cpp

if (!Loc.FileLine.first.empty())
          << "\n>>>               ";
     OS << toString(File);
     if (!Loc.SymName.empty())
       OS << ":(" << Loc.SymName << ')';
   }
   return OS.str();
 }
 
+void SymbolTable::loadMinGWAutomaticImports() {
+  for (auto &I : SymMap) {
+    Symbol *Sym = I.second;
+    auto *Undef = dyn_cast<Undefined>(Sym);
+    if (!Undef)
+      continue;
+    if (!Sym->IsUsedInRegularObj)
+      continue;
+
+    StringRef Name = Undef->getName();
+
+    if (Name.startswith("__imp_"))
+      continue;
+    // If we have an undefined symbol, but we have a Lazy representing a
+    // symbol we could load from file, make sure to load that.
+    Lazy *L = dyn_cast_or_null<Lazy>(find(("__imp_" + Name).str()));
+    if (!L || L->PendingArchiveLoad)
+      continue;
+
+    log("Loading lazy " + L->getName() + " from " + L->File->getName() +
+        " for automatic import");
+    L->PendingArchiveLoad = true;
+    L->File->addMember(&L->Sym);
+  }
+}
+
+bool SymbolTable::handleMinGWAutomaticImport(Symbol *Sym, StringRef Name) {
+  if (Name.startswith("__imp_"))
+    return false;
+  DefinedImportData *Imp =
+      dyn_cast_or_null<DefinedImportData>(find(("__imp_" + Name).str()));
+  if (!Imp)
+    return false;
+
+  log("Automatically importing " + Name + " from " + Imp->getDLLName());
+
+  // Replace the reference directly to a variable with a reference
+  // to the import address table instead. This obviously isn't right,
+  // but we mark the symbol as IsRuntimePseudoReloc, and a later pass
+  // will add runtime pseudo relocations for every relocation against
+  // this Symbol. The runtime pseudo relocation framework expects the
+  // reference itself to point at the IAT entry.
+  Sym->replaceKeepingName(Imp, sizeof(DefinedImportData));
+  cast<DefinedImportData>(Sym)->IsRuntimePseudoReloc = true;
+  return true;
+}
+
 void SymbolTable::reportRemainingUndefines() {
   SmallPtrSet<Symbol *, 8> Undefs;
   DenseMap<Symbol *, Symbol *> LocalImports;
 
   for (auto &I : SymMap) {
     Symbol *Sym = I.second;
     auto *Undef = dyn_cast<Undefined>(Sym);
     if (!Undef)
if (Name.startswith("__imp_")) {
         auto *D = cast<Defined>(Imp);
         replaceSymbol<DefinedLocalImport>(Sym, Name, D);
         LocalImportChunks.push_back(cast<DefinedLocalImport>(Sym)->getChunk());
         LocalImports[Sym] = D;
         continue;
       }
     }
 
+    if (Config->MinGW && handleMinGWAutomaticImport(Sym, Name))
+      continue;
+
     // Remaining undefined symbols are not fatal if /force is specified.
     // They are replaced with dummy defined symbols.
     if (Config->Force)
       replaceSymbol<DefinedAbsolute>(Sym, Name, 0);
     Undefs.insert(Sym);
   }
 
   if (Undefs.empty() && LocalImports.empty())

lld/trunk/COFF/Symbols.h

public:
   Kind kind() const { return static_cast<Kind>(SymbolKind); }
 
   // Returns true if this is an external symbol.
   bool isExternal() { return IsExternal; }
 
   // Returns the symbol name.
   StringRef getName();
 
+  void replaceKeepingName(Symbol *Other, size_t Size);
+
   // Returns the file from which this symbol was created.
   InputFile *getFile();
 
   // Indicates that this symbol will be included in the final image. Only valid
   // after calling markLive.
   bool isLive() const;
 
 protected:
public:
   Chunk *getChunk() { return File->Location; }
   void setLocation(Chunk *AddressTable) { File->Location = AddressTable; }
 
   StringRef getDLLName() { return File->DLLName; }
   StringRef getExternalName() { return File->ExternalName; }
   uint16_t getOrdinal() { return File->Hdr->OrdinalHint; }
 
   ImportFile *File;
+
+  bool IsRuntimePseudoReloc = false;
 };
 
 // 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 {

lld/trunk/COFF/Symbols.cpp

bool Symbol::isLive() const {
   if (auto *Imp = dyn_cast<DefinedImportData>(this))
     return Imp->File->Live;
   if (auto *Imp = dyn_cast<DefinedImportThunk>(this))
     return Imp->WrappedSym->File->ThunkLive;
   // Assume any other kind of symbol is live.
   return true;
 }
 
+// MinGW specific.
+void Symbol::replaceKeepingName(Symbol *Other, size_t Size) {
+  StringRef OrigName = Name;
+  memcpy(this, Other, Size);
+  Name = OrigName;
+}
+
 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));
 }
 

lld/trunk/COFF/Writer.cpp

private:
   void createExportTable();
   void mergeSections();
   void assignAddresses();
   void removeEmptySections();
   void createSymbolAndStringTable();
   void openFile(StringRef OutputPath);
   template <typename PEHeaderTy> void writeHeader();
   void createSEHTable();
+  void createRuntimePseudoRelocs();
   void createGuardCFTables();
   void markSymbolsForRVATable(ObjFile *File,
                               ArrayRef<SectionChunk *> SymIdxChunks,
                               SymbolRVASet &TableSymbols);
   void maybeAddRVATable(SymbolRVASet TableSymbols, StringRef TableSym,
                         StringRef CountSym);
   void setSectionPermissions();
   void writeSections();
void Writer::createMiscChunks() {
 
   // Create SEH table. x86-only.
   if (Config->Machine == I386)
     createSEHTable();
 
   // Create /guard:cf tables if requested.
   if (Config->GuardCF != GuardCFLevel::Off)
     createGuardCFTables();
+
+  if (Config->MinGW)
+    createRuntimePseudoRelocs();
 }
 
 // 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() {
   if (ImportFile::Instances.empty())
void Writer::maybeAddRVATable(SymbolRVASet TableSymbols, StringRef TableSym,
   RdataSec->addChunk(TableChunk);
 
   Symbol *T = Symtab->findUnderscore(TableSym);
   Symbol *C = Symtab->findUnderscore(CountSym);
   replaceSymbol<DefinedSynthetic>(T, T->getName(), TableChunk);
   cast<DefinedAbsolute>(C)->setVA(TableChunk->getSize() / 4);
 }
 
+// MinGW specific. Gather all relocations that are imported from a DLL even
+// though the code didn't expect it to, produce the table that the runtime
+// uses for fixing them up, and provide the synthetic symbols that the
+// runtime uses for finding the table.
+void Writer::createRuntimePseudoRelocs() {
+  std::vector<RuntimePseudoReloc> Rels;
+
+  for (Chunk *C : Symtab->getChunks()) {
+    auto *SC = dyn_cast<SectionChunk>(C);
+    if (!SC || !SC->isLive())
+      continue;
+    SC->getRuntimePseudoRelocs(Rels);
+  }
+
+  if (!Rels.empty())
+    log("Writing " + Twine(Rels.size()) + " runtime pseudo relocations");
+  PseudoRelocTableChunk *Table = make<PseudoRelocTableChunk>(Rels);
+  RdataSec->addChunk(Table);
+  EmptyChunk *EndOfList = make<EmptyChunk>();
+  RdataSec->addChunk(EndOfList);
+
+  Symbol *HeadSym = Symtab->findUnderscore("__RUNTIME_PSEUDO_RELOC_LIST__");
+  Symbol *EndSym = Symtab->findUnderscore("__RUNTIME_PSEUDO_RELOC_LIST_END__");
+  replaceSymbol<DefinedSynthetic>(HeadSym, HeadSym->getName(), Table);
+  replaceSymbol<DefinedSynthetic>(EndSym, EndSym->getName(), EndOfList);
+}
+
 // Handles /section options to allow users to overwrite
 // section attributes.
 void Writer::setSectionPermissions() {
   for (auto &P : Config->Section) {
     StringRef Name = P.first;
     uint32_t Perm = P.second;
     for (OutputSection *Sec : OutputSections)
       if (Sec->Name == Name)

lld/trunk/test/COFF/autoimport-arm-code.s

+# REQUIRES: arm
+
+# RUN: echo -e ".global variable\n.global DllMainCRTStartup\n.thumb\n.text\nDllMainCRTStartup:\nbx lr\n.data\nvariable:\n.long 42" > %t-lib.s
+# RUN: llvm-mc -triple=armv7-windows-gnu %t-lib.s -filetype=obj -o %t-lib.obj
+# RUN: lld-link -out:%t-lib.dll -dll -entry:DllMainCRTStartup %t-lib.obj -lldmingw -implib:%t-lib.lib
+
+# RUN: llvm-mc -triple=armv7-windows-gnu %s -filetype=obj -o %t.obj
+# RUN: not lld-link -lldmingw -out:%t.exe -entry:main %t.obj %t-lib.lib 2>&1 | FileCheck %s
+
+# CHECK: error: unable to automatically import from variable with relocation type IMAGE_REL_ARM_MOV32T
+
+    .global main
+    .text
+    .thumb
+main:
+    movw r0, :lower16:variable
+    movt r0, :upper16:variable
+    ldr  r0, [r0]
+    bx   lr

lld/trunk/test/COFF/autoimport-arm-data.s

+# REQUIRES: arm
+
+# RUN: echo -e ".global variable\n.global DllMainCRTStartup\n.thumb\n.text\nDllMainCRTStartup:\nbx lr\n.data\nvariable:\n.long 42" > %t-lib.s
+# RUN: llvm-mc -triple=armv7-windows-gnu %t-lib.s -filetype=obj -o %t-lib.obj
+# RUN: lld-link -out:%t-lib.dll -dll -entry:DllMainCRTStartup %t-lib.obj -lldmingw -implib:%t-lib.lib
+
+# RUN: llvm-mc -triple=armv7-windows-gnu %s -filetype=obj -o %t.obj
+# RUN: lld-link -lldmingw -out:%t.exe -entry:main %t.obj %t-lib.lib -verbose
+
+# RUN: llvm-readobj -coff-imports %t.exe | FileCheck -check-prefix=IMPORTS %s
+# RUN: llvm-objdump -s %t.exe | FileCheck -check-prefix=CONTENTS %s
+
+# IMPORTS: Import {
+# IMPORTS-NEXT: Name: autoimport-arm-data.s.tmp-lib.dll
+# IMPORTS-NEXT: ImportLookupTableRVA: 0x2040
+# IMPORTS-NEXT: ImportAddressTableRVA: 0x2048
+# IMPORTS-NEXT: Symbol: variable (0)
+# IMPORTS-NEXT: }
+
+# Runtime pseudo reloc list header consisting of 0x0, 0x0, 0x1.
+# First runtime pseudo reloc, with import from 0x2048,
+# applied at 0x3000, with a size of 32 bits.
+# CONTENTS: Contents of section .rdata:
+# CONTENTS:  402000 00000000 00000000 01000000 48200000
+# CONTENTS:  402010 00300000 20000000
+# ptr: pointing at the IAT RVA at 0x2048
+# relocs: pointing at the runtime pseudo reloc list at
+# 0x2000 - 0x2018.
+# CONTENTS: Contents of section .data:
+# CONTENTS:  403000 48204000 00204000 18204000
+
+    .global main
+    .text
+    .thumb
+main:
+    bx lr
+    .data
+ptr:
+    .long variable
+relocs:
+    .long __RUNTIME_PSEUDO_RELOC_LIST__
+    .long __RUNTIME_PSEUDO_RELOC_LIST_END__

lld/trunk/test/COFF/autoimport-arm64-code.s

+# REQUIRES: aarch64
+
+# RUN: echo -e ".global variable\n.global DllMainCRTStartup\n.text\nDllMainCRTStartup:\nret\n.data\nvariable:\n.long 42" > %t-lib.s
+# RUN: llvm-mc -triple=aarch64-windows-gnu %t-lib.s -filetype=obj -o %t-lib.obj
+# RUN: lld-link -out:%t-lib.dll -dll -entry:DllMainCRTStartup %t-lib.obj -lldmingw -implib:%t-lib.lib
+
+# RUN: llvm-mc -triple=aarch64-windows-gnu %s -filetype=obj -o %t.obj
+# RUN: not lld-link -lldmingw -out:%t.exe -entry:main %t.obj %t-lib.lib 2>&1 | FileCheck %s
+
+# CHECK: error: unable to automatically import from variable with relocation type IMAGE_REL_ARM64_PAGEBASE_REL21
+# CHECK: error: unable to automatically import from variable with relocation type IMAGE_REL_ARM64_PAGEOFFSET_12L
+
+    .global main
+    .text
+main:
+    adrp x0, variable
+    ldr  w0, [x0, :lo12:variable]
+    ret

lld/trunk/test/COFF/autoimport-arm64-data.s

+# REQUIRES: aarch64
+
+# RUN: echo -e ".global variable\n.global DllMainCRTStartup\n.text\nDllMainCRTStartup:\nret\n.data\nvariable:\n.long 42" > %t-lib.s
+# RUN: llvm-mc -triple=aarch64-windows-gnu %t-lib.s -filetype=obj -o %t-lib.obj
+# RUN: lld-link -out:%t-lib.dll -dll -entry:DllMainCRTStartup %t-lib.obj -lldmingw -implib:%t-lib.lib
+
+# RUN: llvm-mc -triple=aarch64-windows-gnu %s -filetype=obj -o %t.obj
+# RUN: lld-link -lldmingw -out:%t.exe -entry:main %t.obj %t-lib.lib -verbose
+
+# RUN: llvm-readobj -coff-imports %t.exe | FileCheck -check-prefix=IMPORTS %s
+# RUN: llvm-objdump -s %t.exe | FileCheck -check-prefix=CONTENTS %s
+
+# IMPORTS: Import {
+# IMPORTS-NEXT: Name: autoimport-arm64-data.s.tmp-lib.dll
+# IMPORTS-NEXT: ImportLookupTableRVA: 0x2040
+# IMPORTS-NEXT: ImportAddressTableRVA: 0x2050
+# IMPORTS-NEXT: Symbol: variable (0)
+# IMPORTS-NEXT: }
+
+# Runtime pseudo reloc list header consisting of 0x0, 0x0, 0x1.
+# First runtime pseudo reloc, with import from 0x2050,
+# applied at 0x3000, with a size of 32 bits.
+# CONTENTS: Contents of section .rdata:
+# CONTENTS:  140002000 00000000 00000000 01000000 50200000
+# CONTENTS:  140002010 00300000 40000000
+# ptr: pointing at the IAT RVA at 0x2050
+# relocs: pointing at the runtime pseudo reloc list at
+# 0x2000 - 0x2018.
+# CONTENTS: Contents of section .data:
+# CONTENTS:  140003000 50200040 01000000 00200040 01000000
+# CONTENTS:  140003010 18200040 01000000
+
+    .global main
+    .text
+main:
+    ret
+    .data
+ptr:
+    .quad variable
+relocs:
+    .quad __RUNTIME_PSEUDO_RELOC_LIST__
+    .quad __RUNTIME_PSEUDO_RELOC_LIST_END__

lld/trunk/test/COFF/autoimport-list-ptrs.s

+# REQUIRES: x86
+
+# RUN: llvm-mc -triple=x86_64-windows-gnu %s -filetype=obj -o %t.obj
+# RUN: lld-link -lldmingw -out:%t.exe -entry:main %t.obj -verbose
+
+# RUN: llvm-objdump -s %t.exe | FileCheck -check-prefix=CONTENTS %s
+
+# Even if we didn't actually write any pseudo relocations,
+# check that the synthetic pointers still are set to a non-null value
+# CONTENTS: Contents of section .data:
+# CONTENTS:  140002000 00200040 01000000 00200040 01000000
+
+    .global main
+    .text
+main:
+    retq
+    .data
+relocs:
+    .quad __RUNTIME_PSEUDO_RELOC_LIST__
+    .quad __RUNTIME_PSEUDO_RELOC_LIST_END__

lld/trunk/test/COFF/autoimport-x86.s

+# REQUIRES: x86
+
+# RUN: echo -e ".global variable\n.global DllMainCRTStartup\n.text\nDllMainCRTStartup:\nret\n.data\nvariable:\n.long 42" > %t-lib.s
+# RUN: llvm-mc -triple=x86_64-windows-gnu %t-lib.s -filetype=obj -o %t-lib.obj
+# RUN: lld-link -out:%t-lib.dll -dll -entry:DllMainCRTStartup %t-lib.obj -lldmingw -implib:%t-lib.lib
+
+# RUN: llvm-mc -triple=x86_64-windows-gnu %s -filetype=obj -o %t.obj
+# RUN: lld-link -lldmingw -out:%t.exe -entry:main %t.obj %t-lib.lib -verbose
+
+# RUN: llvm-readobj -coff-imports %t.exe | FileCheck -check-prefix=IMPORTS %s
+# RUN: llvm-objdump -d %t.exe | FileCheck -check-prefix=DISASM %s
+# RUN: llvm-objdump -s %t.exe | FileCheck -check-prefix=CONTENTS %s
+
+# IMPORTS: Import {
+# IMPORTS-NEXT: Name: autoimport-x86.s.tmp-lib.dll
+# IMPORTS-NEXT: ImportLookupTableRVA: 0x2050
+# IMPORTS-NEXT: ImportAddressTableRVA: 0x2060
+# IMPORTS-NEXT: Symbol: variable (0)
+# IMPORTS-NEXT: }
+
+# DISASM: Disassembly of section .text:
+# DISASM: .text:
+# Relative offset at 0x1002 pointing at the IAT at 0x2060.
+# DISASM: 140001000:      8b 05 5a 10 00 00       movl    4186(%rip), %eax
+# DISASM: 140001006:      c3      retq
+
+# Runtime pseudo reloc list header consisting of 0x0, 0x0, 0x1.
+# First runtime pseudo reloc, with import from 0x2060,
+# applied at 0x1002, with a size of 32 bits.
+# Second runtime pseudo reloc, with import from 0x2060,
+# applied at 0x3000, with a size of 64 bits.
+# CONTENTS: Contents of section .rdata:
+# CONTENTS:  140002000 00000000 00000000 01000000 60200000
+# CONTENTS:  140002010 02100000 20000000 60200000 00300000
+# CONTENTS:  140002020 40000000
+# ptr: pointing at the IAT RVA at 0x2060
+# relocs: pointing at the runtime pseudo reloc list at
+# 0x2000 - 0x2024.
+# CONTENTS: Contents of section .data:
+# CONTENTS:  140003000 60200040 01000000 00200040 01000000
+# CONTENTS:  140003010 24200040 01000000
+
+    .global main
+    .text
+main:
+    movl variable(%rip), %eax
+    ret
+    .data
+ptr:
+    .quad variable
+relocs:
+    .quad __RUNTIME_PSEUDO_RELOC_LIST__
+    .quad __RUNTIME_PSEUDO_RELOC_LIST_END__