[LLD] [COFF] Support linking directly against DLLs in MinGW mode

[mstorsjo]

Summary

GNU ld.bfd supports linking directly against DLLs without using an
import library, and some projects have picked up on this habit.
(There's no one single unsurmountable issue with using import
libraries, but this is a regularly surfacing missing feature.)

As long as one is linking by name (instead of by ordinal), the DLL
export table contains most of the information needed. (One can
inspect what section a symbol points at, to see if it's a function
or data symbol. The practical implementation of this loops over all
sections for each symbol, but as long as they're not very many, that
should hopefully be tolerable performance wise.)

One exception where the information in the DLL isn't entirely enough
is on i386 with stdcall functions; depending on how they're done,
the exported function name can be a plain undecorated name, while
the import library would contain the full decorated symbol name. This
issue is addressed separately in a different patch.

This is implemented mimicing the structure of a regular import library,
with one InputFile corresponding to the static archive that just adds
lazy symbols, which then are fetched when they are needed. When such
a symbol is fetched, we synthesize a coff_import_header structure
in memory and create a regular ImportFile out of it.

The implementation could be even smaller by just creating ImportFiles
for every symbol available immediately, but that would have the
drawback of actually ending up importing all symbols unless running
with GC enabled (and mingw mode defaults to having it disabled for
historical reasons).

[mstorsjo]

Updated missed bits in one testcase.

[mstorsjo]

@rnk - Do you think you can have a look at this patch (plus D104532)? There’s not that many other active reviewers who know the coff linker in detail… Hoping to get them in by the 13.x branch if they aren’t too controversial.

[rnk]

lld/COFF/InputFiles.cpp

1170

Factoring out the computation of this boolean would help readability. Initially I thought "this should be a data structure", but there are so few PE sections that it really doesn't matter.

1181–1184

Instead of copying these strings into a newly allocated data structure, is there some way to put the export directory index into the LazyDLLSymbol? Most of the fields of DLLFile::Symbol seem like they can be calculated later after symbol resolution. This would avoid copying all the exported strings once.

[mstorsjo]

lld/COFF/InputFiles.cpp

1170

Yep; this does end up with something like O(n*m) efficiency too, but as the number of sections is only half a dozen normally, it's probably not a biggie.

I can split it out to a separate function.

1181–1184

I iterated a bit back and forth on this while making the patch...

In practice, we actually do need most of the fields from the get go; we do need to know whether to insert the __imp_-less symbol into the symbol table (so we need to find the bool code for each symbol). Technically we don't need to store the original symbolName (for a data import), but once we synthesize the import struct we do need the original symbolName again (and I'd prefer to avoid working with heuristics for stripping out __imp_ from the symbol name when we can avoid it). The dllName isn't needed until the end, but a StringRef for it is pretty much as cheap as a reference to the COFFObjectFile for fetching it later, assuming the operation for fetching it isn't too costly.

Secondly, ExportDirectoryEntryRef is kinda opaque - it's a bit large in itself and it doesn't expose the index publicly. I did experiment with storing the whole ExportDirectoryEntryRef in LazyDLLSymbol, but I needed to have the code flag separately anyway, and then it exceeded the size for the symbol union.

So in practice, it feels a bit excessive to fetch all the info originally at first, but there's surprisingly little to shave off...

[mstorsjo]

Split out a isRVACode() helper function.

[rnk]

lgtm

[thakis]

lld/COFF/InputFiles.h

398

Can you say "MinGW only" in the comment?

lld/COFF/Symbols.h

314

Likewise

[mstorsjo]

lld/COFF/InputFiles.h

398

Sure thing, done (for both instances) in e0e09481eef2602f14523e30a612e7c9fc941936.

lld/COFF/Driver.cpp

case file_magic::coff_import_library:
     break;
   case file_magic::pdb:
     symtab->addFile(make<PDBInputFile>(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) {
+      symtab->addFile(make<DLLFile>(mbref));
+      break;
+    }
     if (filename.endswith_insensitive(".dll")) {
       error(filename + ": bad file type. Did you specify a DLL instead of an "
                        "import library?");
       break;
     }
     LLVM_FALLTHROUGH;
   default:
     error(mbref.getBufferIdentifier() + ": unknown file type");

lld/COFF/InputFiles.h

 //===- InputFiles.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_INPUT_FILES_H
 #define LLD_COFF_INPUT_FILES_H
 
 #include "Config.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/StringSet.h"
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/StringSaver.h"
 #include <memory>
 #include <set>
 #include <vector>
 

 class InputFile {
 public:
   enum Kind {
     ArchiveKind,
     ObjectKind,
     LazyObjectKind,
     PDBKind,
     ImportKind,
-    BitcodeKind
+    BitcodeKind,
+    DLLKind
   };
   Kind kind() const { return fileKind; }
   virtual ~InputFile() {}
 
   // Returns the filename.
   StringRef getName() const { return mb.getBufferIdentifier(); }
 
   // Reads a file (the constructor doesn't do that).
public:
   std::unique_ptr<llvm::lto::InputFile> obj;
 
 private:
   void parse() override;
 
   std::vector<Symbol *> symbols;
 };
 
+// .dll file.
+class DLLFile : public InputFile {
+public:
+  explicit DLLFile(MemoryBufferRef m) : InputFile(DLLKind, m) {}
+  static bool classof(const InputFile *f) { return f->kind() == DLLKind; }
+  void parse() override;
+  MachineTypes getMachineType() override;
+
+  struct Symbol {
+    StringRef dllName;
+    StringRef symbolName;
+    llvm::COFF::ImportNameType nameType;
+    llvm::COFF::ImportType importType;
+  };
+
+  void makeImport(Symbol *s);
+
+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);
 } // namespace coff
 
 std::string toString(const coff::InputFile *file);
 } // namespace lld
 
 #endif

lld/COFF/InputFiles.cpp

 std::string lld::coff::replaceThinLTOSuffix(StringRef path) {
   StringRef suffix = config->thinLTOObjectSuffixReplace.first;
   StringRef repl = config->thinLTOObjectSuffixReplace.second;
 
   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);
+    if (rva >= sec->VirtualAddress &&
+        rva <= sec->VirtualAddress + sec->VirtualSize) {
+      return (sec->Characteristics & COFF::IMAGE_SCN_CNT_CODE) != 0;
+    }
+  }
+  return false;
+}
+
+void DLLFile::parse() {
+  // Parse a memory buffer as a PE-COFF executable.
+  std::unique_ptr<Binary> bin = CHECK(createBinary(mb), this);
+
+  if (auto *obj = dyn_cast<COFFObjectFile>(bin.get())) {
+    bin.release();
+    coffObj.reset(obj);
+  } else {
+    error(toString(this) + " is not a COFF file");
+    return;
+  }
+
+  if (!coffObj->getPE32Header() && !coffObj->getPE32PlusHeader()) {
+    error(toString(this) + " is not a PE-COFF executable");
+    return;
+  }
+
+  for (const auto &exp : coffObj->export_directories()) {
+    StringRef dllName, symbolName;
+    uint32_t exportRVA;
+    checkError(exp.getDllName(dllName));
+    checkError(exp.getSymbolName(symbolName));
+    checkError(exp.getExportRVA(exportRVA));
+
+    if (symbolName.empty())
+      continue;
+
+    bool code = isRVACode(coffObj.get(), exportRVA, this);
+
+    Symbol *s = make<Symbol>();
+    s->dllName = dllName;
+    s->symbolName = symbolName;
+    s->importType = code ? ImportType::IMPORT_CODE : ImportType::IMPORT_DATA;
+    s->nameType = ImportNameType::IMPORT_NAME;
+
+    if (coffObj->getMachine() == I386) {
+      s->symbolName = symbolName = saver.save("_" + symbolName);
+      s->nameType = ImportNameType::IMPORT_NAME_NOPREFIX;
+    }
+
+    StringRef impName = saver.save("__imp_" + symbolName);
+    symtab->addLazyDLLSymbol(this, s, impName);
+    if (code)
+      symtab->addLazyDLLSymbol(this, s, symbolName);
+  }
+}
+
+MachineTypes DLLFile::getMachineType() {
+  if (coffObj)
+    return static_cast<MachineTypes>(coffObj->getMachine());
+  return IMAGE_FILE_MACHINE_UNKNOWN;
+}
+
+void DLLFile::makeImport(DLLFile::Symbol *s) {
+  if (!seen.insert(s->symbolName).second)
+    return;
+
+  size_t impSize = s->dllName.size() + s->symbolName.size() + 2; // +2 for NULs
+  size_t size = sizeof(coff_import_header) + impSize;
+  char *buf = bAlloc.Allocate<char>(size);
+  memset(buf, 0, size);
+  char *p = buf;
+  auto *imp = reinterpret_cast<coff_import_header *>(p);
+  p += sizeof(*imp);
+  imp->Sig2 = 0xFFFF;
+  imp->Machine = coffObj->getMachine();
+  imp->SizeOfData = impSize;
+  imp->OrdinalHint = 0; // Only linking by name
+  imp->TypeInfo = (s->nameType << 2) | s->importType;
+
+  // Write symbol name and DLL name.
+  memcpy(p, s->symbolName.data(), s->symbolName.size());
+  p += s->symbolName.size() + 1;
+  memcpy(p, s->dllName.data(), s->dllName.size());
+  MemoryBufferRef mbref = MemoryBufferRef(StringRef(buf, size), s->dllName);
+  ImportFile *impFile = make<ImportFile>(mbref);
+  symtab->addFile(impFile);
+}

lld/COFF/SymbolTable.h

public:
   Symbol *addUndefined(StringRef name);
 
   Symbol *addSynthetic(StringRef n, Chunk *c);
   Symbol *addAbsolute(StringRef n, uint64_t va);
 
   Symbol *addUndefined(StringRef name, InputFile *f, bool isWeakAlias);
   void addLazyArchive(ArchiveFile *f, const Archive::Symbol &sym);
   void addLazyObject(LazyObjFile *f, StringRef n);
+  void addLazyDLLSymbol(DLLFile *f, DLLFile::Symbol *sym, StringRef n);
   Symbol *addAbsolute(StringRef n, COFFSymbolRef s);
   Symbol *addRegular(InputFile *f, StringRef n,
                      const llvm::object::coff_symbol_generic *s = nullptr,
                      SectionChunk *c = nullptr, uint32_t sectionOffset = 0);
   std::pair<DefinedRegular *, bool>
   addComdat(InputFile *f, StringRef n,
             const llvm::object::coff_symbol_generic *s = nullptr);
   Symbol *addCommon(InputFile *f, StringRef n, uint64_t size,

lld/COFF/SymbolTable.cpp

static void forceLazy(Symbol *s) {
   case Symbol::Kind::LazyArchiveKind: {
     auto *l = cast<LazyArchive>(s);
     l->file->addMember(l->sym);
     break;
   }
   case Symbol::Kind::LazyObjectKind:
     cast<LazyObject>(s)->file->fetch();
     break;
+  case Symbol::Kind::LazyDLLSymbolKind: {
+    auto *l = cast<LazyDLLSymbol>(s);
+    l->file->makeImport(l->sym);
+    break;
+  }
   default:
     llvm_unreachable(
         "symbol passed to forceLazy is not a LazyArchive or LazyObject");
   }
 }
 
 // Returns the symbol in SC whose value is <= Addr that is closest to Addr.
 // This is generally the global variable or function whose definition contains
void SymbolTable::addLazyObject(LazyObjFile *f, StringRef n) {
   }
   auto *u = dyn_cast<Undefined>(s);
   if (!u || u->weakAlias || s->pendingArchiveLoad)
     return;
   s->pendingArchiveLoad = true;
   f->fetch();
 }
 
+void SymbolTable::addLazyDLLSymbol(DLLFile *f, DLLFile::Symbol *sym,
+                                   StringRef n) {
+  Symbol *s;
+  bool wasInserted;
+  std::tie(s, wasInserted) = insert(n);
+  if (wasInserted) {
+    replaceSymbol<LazyDLLSymbol>(s, f, sym, n);
+    return;
+  }
+  auto *u = dyn_cast<Undefined>(s);
+  if (!u || u->weakAlias || s->pendingArchiveLoad)
+    return;
+  s->pendingArchiveLoad = true;
+  f->makeImport(sym);
+}
+
 static std::string getSourceLocationBitcode(BitcodeFile *file) {
   std::string res("\n>>> defined at ");
   StringRef source = file->obj->getSourceFileName();
   if (!source.empty())
     res += source.str() + "\n>>>            ";
   res += toString(file);
   return res;
 }

lld/COFF/Symbols.h

enum Kind {
     DefinedImportThunkKind,
     DefinedImportDataKind,
     DefinedAbsoluteKind,
     DefinedSyntheticKind,
 
     UndefinedKind,
     LazyArchiveKind,
     LazyObjectKind,
+    LazyDLLSymbolKind,
 
     LastDefinedCOFFKind = DefinedCommonKind,
     LastDefinedKind = DefinedSyntheticKind,
   };
 
   Kind kind() const { return static_cast<Kind>(symbolKind); }
 
   // Returns the symbol name.
public:
   // 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;
 
   bool isLazy() const {
-    return symbolKind == LazyArchiveKind || symbolKind == LazyObjectKind;
+    return symbolKind == LazyArchiveKind || symbolKind == LazyObjectKind ||
+           symbolKind == LazyDLLSymbolKind;
   }
 
 private:
   void computeName();
 
 protected:
   friend SymbolTable;
   explicit Symbol(Kind k, StringRef n = "")

 class LazyObject : public Symbol {
 public:
   LazyObject(LazyObjFile *f, StringRef n)
       : Symbol(LazyObjectKind, n), file(f) {}
   static bool classof(const Symbol *s) { return s->kind() == LazyObjectKind; }
   LazyObjFile *file;
 };
 
+class LazyDLLSymbol : public Symbol {
+public:
+  LazyDLLSymbol(DLLFile *f, DLLFile::Symbol *s, StringRef n)
+      : Symbol(LazyDLLSymbolKind, n), file(f), sym(s) {}
+  static bool classof(const Symbol *s) {
+    return s->kind() == LazyDLLSymbolKind;
+  }
+
+  DLLFile *file;
+  DLLFile::Symbol *sym;
+};
+
 // Undefined symbols.
 class Undefined : public Symbol {
 public:
   explicit Undefined(StringRef n) : Symbol(UndefinedKind, n) {}
 
   static bool classof(const Symbol *s) { return s->kind() == UndefinedKind; }
 
   // An undefined symbol can have a fallback symbol which gives an
inline uint64_t Defined::getRVA() {
   case DefinedLocalImportKind:
     return cast<DefinedLocalImport>(this)->getRVA();
   case DefinedCommonKind:
     return cast<DefinedCommon>(this)->getRVA();
   case DefinedRegularKind:
     return cast<DefinedRegular>(this)->getRVA();
   case LazyArchiveKind:
   case LazyObjectKind:
+  case LazyDLLSymbolKind:
   case UndefinedKind:
     llvm_unreachable("Cannot get the address for an undefined symbol.");
   }
   llvm_unreachable("unknown symbol kind");
 }
 
 inline Chunk *Defined::getChunk() {
   switch (kind()) {
   case DefinedRegularKind:
     return cast<DefinedRegular>(this)->getChunk();
   case DefinedAbsoluteKind:
     return nullptr;
   case DefinedSyntheticKind:
     return cast<DefinedSynthetic>(this)->getChunk();
   case DefinedImportDataKind:
     return cast<DefinedImportData>(this)->getChunk();
   case DefinedImportThunkKind:
     return cast<DefinedImportThunk>(this)->getChunk();
   case DefinedLocalImportKind:
     return cast<DefinedLocalImport>(this)->getChunk();
   case DefinedCommonKind:
     return cast<DefinedCommon>(this)->getChunk();
   case LazyArchiveKind:
   case LazyObjectKind:
+  case LazyDLLSymbolKind:
   case UndefinedKind:
     llvm_unreachable("Cannot get the chunk of an undefined symbol.");
   }
   llvm_unreachable("unknown symbol kind");
 }
 
 // A buffer class that is large enough to hold any Symbol-derived
 // object. We allocate memory using this class and instantiate a symbol
 // using the placement new.
 union SymbolUnion {
   alignas(DefinedRegular) char a[sizeof(DefinedRegular)];
   alignas(DefinedCommon) char b[sizeof(DefinedCommon)];
   alignas(DefinedAbsolute) char c[sizeof(DefinedAbsolute)];
   alignas(DefinedSynthetic) char d[sizeof(DefinedSynthetic)];
   alignas(LazyArchive) char e[sizeof(LazyArchive)];
   alignas(Undefined) char f[sizeof(Undefined)];
   alignas(DefinedImportData) char g[sizeof(DefinedImportData)];
   alignas(DefinedImportThunk) char h[sizeof(DefinedImportThunk)];
   alignas(DefinedLocalImport) char i[sizeof(DefinedLocalImport)];
   alignas(LazyObject) char j[sizeof(LazyObject)];
+  alignas(LazyDLLSymbol) char k[sizeof(LazyDLLSymbol)];
 };
 
 template <typename T, typename... ArgT>
 void replaceSymbol(Symbol *s, ArgT &&... arg) {
   static_assert(std::is_trivially_destructible<T>(),
                 "Symbol types must be trivially destructible");
   static_assert(sizeof(T) <= sizeof(SymbolUnion), "Symbol too small");
   static_assert(alignof(T) <= alignof(SymbolUnion),

lld/COFF/Symbols.cpp

 
 InputFile *Symbol::getFile() {
   if (auto *sym = dyn_cast<DefinedCOFF>(this))
     return sym->file;
   if (auto *sym = dyn_cast<LazyArchive>(this))
     return sym->file;
   if (auto *sym = dyn_cast<LazyObject>(this))
     return sym->file;
+  if (auto *sym = dyn_cast<LazyDLLSymbol>(this))
+    return sym->file;
   return nullptr;
 }
 
 bool Symbol::isLive() const {
   if (auto *r = dyn_cast<DefinedRegular>(this))
     return r->getChunk()->live;
   if (auto *imp = dyn_cast<DefinedImportData>(this))
     return imp->file->live;

lld/COFF/Writer.cpp

case Symbol::DefinedCommonKind:
     break;
   case Symbol::DefinedAbsoluteKind:
   case Symbol::DefinedSyntheticKind:
     // Absolute is never code, synthetic generally isn't and usually isn't
     // determinable.
     break;
   case Symbol::LazyArchiveKind:
   case Symbol::LazyObjectKind:
+  case Symbol::LazyDLLSymbolKind:
   case Symbol::UndefinedKind:
     // Undefined symbols resolve to zero, so they don't have an RVA. Lazy
     // symbols shouldn't have relocations.
     break;
 
   case Symbol::DefinedImportThunkKind:
     // Thunks are always code, include them.
     addSymbolToRVASet(addressTakenSyms, cast<Defined>(s));

lld/test/COFF/link-dll-i386.s

+# REQUIRES: x86
+
+## Test creating a DLL and linking against the DLL without using an import
+## library.
+
+## Test on i386 with cdecl decorated symbols.
+
+## Linking the executable with -opt:noref, to make sure that we don't
+## pull in more import entries than what's needed, even if not running GC.
+
+# RUN: split-file %s %t.dir
+
+# RUN: llvm-mc -filetype=obj -triple=i386-windows-gnu %t.dir/lib.s -o %t.lib.o
+# RUN: lld-link -safeseh:no -noentry -dll -def:%t.dir/lib.def %t.lib.o -out:%t.lib.dll -implib:%t.implib.lib
+# RUN: llvm-mc -filetype=obj -triple=i386-windows-gnu %t.dir/main.s -o %t.main.o
+# RUN: lld-link -lldmingw %t.main.o -out:%t.main.exe %t.lib.dll -opt:noref -verbose 2>&1 | FileCheck --check-prefix=LOG %s
+# RUN: llvm-readobj --coff-imports %t.main.exe | FileCheck %s
+
+#--- lib.s
+.text
+.global _func1
+_func1:
+  ret
+.global _func2
+_func2:
+  ret
+.global _func3
+_func3:
+  ret
+.data
+.global _variable
+_variable:
+  .int 42
+
+#--- lib.def
+EXPORTS
+func1
+func2
+func3
+variable
+
+#--- main.s
+.text
+.global _mainCRTStartup
+_mainCRTStartup:
+  call _func2
+  movl .refptr._variable, %eax
+  movl (%eax), %eax
+  ret
+
+.section .rdata$.refptr._variable,"dr",discard,.refptr._variable
+.globl .refptr._variable
+.refptr._variable:
+  .long _variable
+
+# CHECK:      Import {
+# CHECK-NEXT:   Name: link-dll-i386.s.tmp.lib.dll
+# CHECK-NEXT:   ImportLookupTableRVA:
+# CHECK-NEXT:   ImportAddressTableRVA
+# CHECK-NEXT:   Symbol: func2
+# CHECK-NEXT:   Symbol: variable
+# CHECK-NEXT: }
+
+# LOG: Automatically importing _variable from link-dll-i386.s.tmp.lib.dll

lld/test/COFF/link-dll.s

+# REQUIRES: x86
+
+## Test creating a DLL and linking against the DLL without using an import
+## library.
+
+## Explicitly creating an import library but naming it differently than the
+## DLL, to avoid any risk of implicitly referencing it instead of the DLL
+## itself.
+
+## Linking the executable with -opt:noref, to make sure that we don't
+## pull in more import entries than what's needed, even if not running GC.
+
+# RUN: split-file %s %t.dir
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-windows-gnu %t.dir/lib.s -o %t.lib.o
+# RUN: lld-link -noentry -dll -def:%t.dir/lib.def %t.lib.o -out:%t.lib.dll -implib:%t.implib.lib
+# RUN: llvm-mc -filetype=obj -triple=x86_64-windows-gnu %t.dir/main.s -o %t.main.o
+# RUN: lld-link -lldmingw %t.main.o -out:%t.main.exe %t.lib.dll -opt:noref -verbose 2>&1 | FileCheck --check-prefix=LOG %s
+# RUN: llvm-readobj --coff-imports %t.main.exe | FileCheck %s
+
+#--- lib.s
+.text
+.global func1
+func1:
+  ret
+.global func2
+func2:
+  ret
+.global func3
+func3:
+  ret
+.data
+.global variable
+variable:
+  .int 42
+
+#--- lib.def
+EXPORTS
+func1
+func2
+func3
+variable
+
+#--- main.s
+.text
+.global mainCRTStartup
+mainCRTStartup:
+  call func2
+  movq .refptr.variable(%rip), %rax
+  movl (%rax), %eax
+  ret
+
+.section .rdata$.refptr.variable,"dr",discard,.refptr.variable
+.globl .refptr.variable
+.refptr.variable:
+  .quad variable
+
+# CHECK:      Import {
+# CHECK-NEXT:   Name: link-dll.s.tmp.lib.dll
+# CHECK-NEXT:   ImportLookupTableRVA:
+# CHECK-NEXT:   ImportAddressTableRVA
+# CHECK-NEXT:   Symbol: func2
+# CHECK-NEXT:   Symbol: variable
+# CHECK-NEXT: }
+
+# LOG: Automatically importing variable from link-dll.s.tmp.lib.dll