[LLD] [COFF] Implement a GNU/ELF like -wrap option

[mstorsjo]

Summary

Add a simple forwarding option in the MinGW frontend, and implement the private -wrap option in the COFF linker.

The feature in lld-link isn't gated by the -lldmingw option, but the option is left as a private, undocumented option primarily used by the MinGW driver.

The implementation is significantly based on the support for --wrap in the ELF linker, but many small nuance details are different between the ELF and COFF linkers, ending up with more than a few implementation differences.

This fixes https://bugs.llvm.org/show_bug.cgi?id=47384.

[orgads]

Thank you very much!

I'll try to test it next week.

lld/COFF/Driver.cpp

2012

-wrap?

2061

ditto

lld/COFF/MinGW.cpp

194

You have using namespace lld::coff. Remove the qualifiers? (repeats below)

lld/test/MinGW/driver.test

285

-wrap foo2?

286

ditto

[mstorsjo]

lld/COFF/Driver.cpp

2012

Oh, right, yes, within lld-link, that's the only correct spelling of it.

lld/test/MinGW/driver.test

285

No, GNU ld supports the option with one or two leading dashes, so this intentionally tests both (and either with the parameter as a separate argument, or with concatenated with an equals char). The option on the lld-link level on the other hand, has only one spelling.

[mstorsjo]

Consistently spell the option "-wrap" within comments within the COFF subdirectory.

[rnk]

I had a naming suggestion, but otherwise it looks neat.

lld/COFF/MinGW.cpp

194

True for WrappedSymbol, but for the function definition, this applies:
https://llvm.org/docs/CodingStandards.html#use-namespace-qualifiers-to-implement-previously-declared-functions

lld/COFF/Symbols.h

141

There are more kinds of IPO than just inlining, so the name isn't quite right. I also would prefer to reverse the sense so that a default value of false is the more prevalent value, and only special wrapped symbols set this to true. I suggest using the name isHiddenFromLTO for that purpose.

[mstorsjo]

lld/COFF/Symbols.h

141

Sounds like a good suggestion, but this is (including the comment) an exact copy of the corresponding field from the ELF side - and consistency also is nice.

Or should I go with this and then rename accordingly on the ELF side afterwards - WDYT @MaskRay?

[MaskRay]

lld/COFF/Symbols.h

141

I agree that canInline is a misnomer. isHiddenFromLTO may be a bit confusing as well: there is an LTO property called VisibleToRegularObj. "hidden" and "Visible" are confusing when used together. FWIW in lib/LTO, this property is called LinkerRedefined.

However, LinkerRedefined is not great for the ELF case because a linker script symbol assignment (e.g. a = 1013;) does not set LinkerRedefined. The ELF port just overrides the LTO definition in a later pass.

[MaskRay]

The testsuite is simply ported from test/ELF. The way the tests are organized in ELF is actually not great. For the 3 symbols: foo __wrap_foo __real_foo. There are 8 states of their presence. The ELF naming is a bit arbitrary.

[mstorsjo]

In D89004#2329215, @MaskRay wrote:

The testsuite is simply ported from test/ELF.

It's based on those tests yes, but some amount of modifications, and with a few new things. In particular, I added a negative test to see that we really do fail if referencing __real_func but it isn't available. (During development, while fiddling with different flags, I had one situation where such an error actually could slip through.)

The way the tests are organized in ELF is actually not great. For the 3 symbols: foo __wrap_foo __real_foo. There are 8 states of their presence. The ELF naming is a bit arbitrary.

Any concrete suggestions on what to improve?

lld/COFF/MinGW.cpp

194

Removing it from the WrappedSymbol references.

[mstorsjo]

Removed superfluous lld::coff:: specifiers where possible. Added a testcase for wrapping an imported symbol. (In that case, one can't do the wrapping by replacing the actual Symbol object contents, because that breaks generation of the import thunks.) Didn't rename the canInline field yet, pending consensus on what to rename it to.

[rnk]

lld/COFF/Symbols.h

141

I think consistency with ELF is better than trying to improve on the naming. We can do a follow-up to rename all the properties to something sensible and consistent.

For example, I like IsUsedByRegularObj better than VisibleFromRegularObj, and I think we can improve on LinkerRedefined, and make that match whatever LLD uses in both ELF and COFF.

[orgads]

Thank you very much!

Can you please send me a static 64-bit build like you did in the old days? ;)

If you can give me instructions how to build it that would be even better :)

[aeubanks]

This breaks the Windows build:

C:\src\llvm-mint\lld\COFF\Symbols.cpp(26,1): error: static_assert failed due to requirement 'sizeof(lld::coff::SymbolUnion) <= 48' "symbols should be optimized for memory usage"
static_assert(sizeof(SymbolUnion) <= 48,

Reverted in 3d338f681340e2075707eabcf530bcc0c37da80e.

[aeubanks]

(example bot failure: http://45.33.8.238/win/25918/step_4.txt, I also repro'd locally with the normal CMake build)

[MaskRay]

lld/COFF/Symbols.h

141

This needs to be unsigned, instead of uint8_t, to have good packing on MSVC (I think).

[rnk]

lld/COFF/Symbols.h

141

Yep, that should be sufficient to fix the error. I'm glad I put the assert in, or we'd never find out about these regressions. :)

[mstorsjo]

lld/COFF/Symbols.h

141

Thanks, reapplying it with that fixed soon - and sorry for the breakage.

[mstorsjo]

In D89004#2332496, @orgads wrote:

Thank you very much!

Can you please send me a static 64-bit build like you did in the old days? ;)

If you can give me instructions how to build it that would be even better :)

I primarily cross compile things, so to build it, I'd do something equivalent to this, on linux:

• Check out https://github.com/mstorsjo/llvm-mingw
• Build a cross toolchain using LLVM_VERSION=<current_rev> ./build-all.sh ~/llvm-mingw-latest
• Using the newly built cross toolchain, cross compile LLVM and the rest of the toolchain to run on windows, ./build-cross-tools.sh ~/llvm-mingw-latest ~/llvm-mingw-latest-x86_64 x86_64

If you want the toolchain not to use a dynamically linked libc++, you can either add --disable-shared in build-all.sh on the ./build-libcxx.sh line before the second step, or delete the libc++.dll.a and libunwind.dll.a files from the built toolchain after the second step.

If you've got an old checkout to build in, either export SYNC=1 (to force it to fetch the given revision instead of using whatever was checked out) and CLEAN=1 (to clean the existing build directories before building) or nuke it completely before starting.

If you've only got access to building things on MSYS, the same steps should mostly apply still. If you just run the first step, you'll end up with a working LLD, but it's linked against libstdc++ and winpthreads - and some people report issues still with the LLD threading and winpthreads. So on MSYS, the second step would rebuild all of the tools using the newly built tools, so you have an LLD linked against libc++.

lld/COFF/Driver.cpp

void LinkerDriver::link(ArrayRef<const char *> argsArr) {
   if (args.hasArg(OPT_include_optional)) {
     // Handle /includeoptional
     for (auto *arg : args.filtered(OPT_include_optional))
       if (dyn_cast_or_null<LazyArchive>(symtab->find(arg->getValue())))
         addUndefined(arg->getValue());
     while (run());
   }
 
+  // Create wrapped symbols for -wrap option.
+  std::vector<WrappedSymbol> wrapped = addWrappedSymbols(args);
+  // Load more object files that might be needed for wrapped symbols.
+  if (!wrapped.empty())
+    while (run());
+
   if (config->autoImport) {
     // MinGW specific.
     // 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.
     //
void LinkerDriver::link(ArrayRef<const char *> argsArr) {
   // 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 (!wrapped.empty())
+    wrapSymbols(wrapped);
+
   // Resolve remaining undefined symbols and warn about imported locals.
   symtab->resolveRemainingUndefines();
   if (errorCount())
     return;
 
   config->hadExplicitExports = !config->exports.empty();
   if (config->mingw) {
     // In MinGW, all symbols are automatically exported if no symbols

lld/COFF/InputFiles.h

public:
   ArrayRef<Chunk *> getChunks() { return chunks; }
   ArrayRef<SectionChunk *> getDebugChunks() { return debugChunks; }
   ArrayRef<SectionChunk *> getSXDataChunks() { return sxDataChunks; }
   ArrayRef<SectionChunk *> getGuardFidChunks() { return guardFidChunks; }
   ArrayRef<SectionChunk *> getGuardIATChunks() { return guardIATChunks; }
   ArrayRef<SectionChunk *> getGuardLJmpChunks() { return guardLJmpChunks; }
   ArrayRef<Symbol *> getSymbols() { return symbols; }
 
+  MutableArrayRef<Symbol *> getMutableSymbols() { return symbols; }
+
   ArrayRef<uint8_t> getDebugSection(StringRef secName);
 
   // Returns a Symbol object for the symbolIndex'th symbol in the
   // underlying object file.
   Symbol *getSymbol(uint32_t symbolIndex) {
     return symbols[symbolIndex];
   }
 

lld/COFF/LTO.cpp

for (const lto::InputFile::Symbol &objSym : obj.symbols()) {
     // reports two symbols for module ASM defined. Without this check, lld
     // flags an undefined in IR with a definition in ASM as prevailing.
     // Once IRObjectFile is fixed to report only one symbol this hack can
     // be removed.
     r.Prevailing = !objSym.isUndefined() && sym->getFile() == &f;
     r.VisibleToRegularObj = sym->isUsedInRegularObj;
     if (r.Prevailing)
       undefine(sym);
+
+    // We tell LTO to not apply interprocedural optimization for wrapped
+    // (with -wrap) symbols because otherwise LTO would inline them while
+    // 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() {
   unsigned maxTasks = ltoObj->getMaxTasks();

lld/COFF/MinGW.h

 //===- MinGW.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_MINGW_H
 #define LLD_COFF_MINGW_H
 
 #include "Config.h"
 #include "Symbols.h"
 #include "lld/Common/LLVM.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/Option/ArgList.h"
+#include <vector>
 
 namespace lld {
 namespace coff {
 
 // Logic for deciding what symbols to export, when exporting all
 // symbols for MinGW.
 class AutoExporter {
 public:
   AutoExporter();
 
   void addWholeArchive(StringRef path);
 
   llvm::StringSet<> excludeSymbols;
   llvm::StringSet<> excludeSymbolPrefixes;
   llvm::StringSet<> excludeSymbolSuffixes;
   llvm::StringSet<> excludeLibs;
   llvm::StringSet<> excludeObjects;
 
   bool shouldExport(Defined *sym) const;
 };
 
 void writeDefFile(StringRef name);
 
+// 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.
+//
+// This data structure is instantiated for each -wrap option.
+struct WrappedSymbol {
+  Symbol *sym;
+  Symbol *real;
+  Symbol *wrap;
+};
+
+std::vector<WrappedSymbol> addWrappedSymbols(llvm::opt::InputArgList &args);
+
+void wrapSymbols(ArrayRef<WrappedSymbol> wrapped);
+
 } // namespace coff
 } // namespace lld
 
 #endif

lld/COFF/MinGW.cpp

 //===- MinGW.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 "MinGW.h"
+#include "Driver.h"
+#include "InputFiles.h"
 #include "SymbolTable.h"
 #include "lld/Common/ErrorHandler.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/Object/COFF.h"
+#include "llvm/Support/Parallel.h"
 #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;
 
for (Export &e : config->exports) {
     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)
+    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(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 = symtab->findUnderscore(name);
+    if (!sym)
+      continue;
+
+    Symbol *real = symtab->addUndefined(mangle("__real_" + name));
+    Symbol *wrap = symtab->addUndefined(mangle("__wrap_" + name));
+    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;
+    // We want to tell LTO not to inline symbols to be overwritten
+    // because LTO doesn't know the final symbol contents after renaming.
+    real->canInline = false;
+    sym->canInline = false;
+
+    // Tell LTO not to eliminate these symbols.
+    sym->isUsedInRegularObj = true;
+    if (!isa<Undefined>(wrap))
+      wrap->isUsedInRegularObj = true;
+  }
+  return v;
+}
+
+// Do renaming for -wrap by updating pointers to symbols.
+//
+// When this function is executed, only InputFiles and symbol table
+// contain pointers to symbol objects. We visit them to replace pointers,
+// so that wrapped symbols are swapped as instructed by the command line.
+void lld::coff::wrapSymbols(ArrayRef<WrappedSymbol> wrapped) {
+  DenseMap<Symbol *, Symbol *> map;
+  for (const WrappedSymbol &w : wrapped) {
+    map[w.sym] = w.wrap;
+    map[w.real] = w.sym;
+  }
+
+  // Update pointers in input files.
+  parallelForEach(ObjFile::instances, [&](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/Options.td

 defm call_graph_profile_sort: B<
     "call-graph-profile-sort",
     "Reorder sections with call graph profile (default)",
     "Do not reorder sections with call graph profile">;
 def print_symbol_order: P<
     "print-symbol-order",
     "Print a symbol order specified by /call-graph-ordering-file and "
     "/call-graph-profile-sort into the specified file">;
+def wrap : P_priv<"wrap">;
 
 // Flags for debugging
 def lldmap : F<"lldmap">;
 def lldmap_file : Joined<["/", "-", "/?", "-?"], "lldmap:">;
 def map : F<"map">;
 def map_file : Joined<["/", "-", "/?", "-?"], "map:">;
 def show_timing : F<"time">;
 def summary : F<"summary">;

lld/COFF/SymbolTable.cpp

for (const UndefinedDiag &undefDiag : undefDiags)
     reportUndefinedSymbol(undefDiag);
 }
 
 void SymbolTable::reportUnresolvable() {
   SmallPtrSet<Symbol *, 8> undefs;
   for (auto &i : symMap) {
     Symbol *sym = i.second;
     auto *undef = dyn_cast<Undefined>(sym);
-    if (!undef)
+    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;

 
 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;
     sym->pendingArchiveLoad = false;
+    sym->canInline = true;
     inserted = true;
   }
   return {sym, inserted};
 }
 
 std::pair<Symbol *, bool> SymbolTable::insert(StringRef name, InputFile *file) {
   std::pair<Symbol *, bool> result = insert(name);
   if (!file || !isa<BitcodeFile>(file))

lld/COFF/Symbols.h

 private:
   void computeName();
 
 protected:
   friend SymbolTable;
   explicit Symbol(Kind k, StringRef n = "")
       : symbolKind(k), isExternal(true), isCOMDAT(false),
         writtenToSymtab(false), pendingArchiveLoad(false), isGCRoot(false),
-        isRuntimePseudoReloc(false), nameSize(n.size()),
-        nameData(n.empty() ? nullptr : n.data()) {}
+        isRuntimePseudoReloc(false), deferUndefined(false), canInline(true),
+        nameSize(n.size()), nameData(n.empty() ? nullptr : n.data()) {}
 
   const unsigned symbolKind : 8;
   unsigned isExternal : 1;
 
 public:
   // This bit is used by the \c DefinedRegular subclass.
   unsigned isCOMDAT : 1;
 
public:
   // not load any more archive members to resolve the same symbol.
   unsigned pendingArchiveLoad : 1;
 
   /// True if we've already added this symbol to the list of GC roots.
   unsigned isGCRoot : 1;
 
   unsigned isRuntimePseudoReloc : 1;
 
+  // True if we want to allow this symbol to be undefined in the early
+  // undefined check pass in SymbolTable::reportUnresolvable(), as it
+  // might be fixed up later.
+  unsigned deferUndefined : 1;
+
+  // False if LTO shouldn't inline whatever this symbol points to. If a symbol
+  // is overwritten after LTO, LTO shouldn't inline the symbol because it
+  // doesn't know the final contents of the symbol.
+  uint8_t canInline : 1;
+
 protected:
   // Symbol name length. Assume symbol lengths fit in a 32-bit integer.
   uint32_t nameSize;
 
   const char *nameData;
 };
 
 // The base class for any defined symbols, including absolute symbols,

 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),
                 "SymbolUnion not aligned enough");
   assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr &&
          "Not a Symbol");
+  bool canInline = s->canInline;
   new (s) T(std::forward<ArgT>(arg)...);
+  s->canInline = canInline;
 }
 } // namespace coff
 
 } // namespace lld
 
 #endif

lld/MinGW/Driver.cpp

else
     add("-alternatename:__image_base__=__ImageBase");
 
   for (auto *a : args.filtered(OPT_require_defined))
     add("-include:" + StringRef(a->getValue()));
   for (auto *a : args.filtered(OPT_undefined))
     add("-includeoptional:" + StringRef(a->getValue()));
   for (auto *a : args.filtered(OPT_delayload))
     add("-delayload:" + StringRef(a->getValue()));
+  for (auto *a : args.filtered(OPT_wrap))
+    add("-wrap:" + StringRef(a->getValue()));
 
   std::vector<StringRef> searchPaths;
   for (auto *a : args.filtered(OPT_L)) {
     searchPaths.push_back(a->getValue());
     add("-libpath:" + StringRef(a->getValue()));
   }
 
   StringRef prefix = "";

lld/MinGW/Options.td

defm require_defined: Eq<"require-defined",
      "Force symbol to be added to symbol table as an undefined one">;
 defm undefined: Eq<"undefined", "Include symbol in the link, if available">;
 defm whole_archive: B<"whole-archive",
     "Include all object files for following archives",
     "No longer include all object files for following archives">;
 def v: Flag<["-"], "v">, HelpText<"Display the version number">;
 def verbose: F<"verbose">, HelpText<"Verbose mode">;
 def version: F<"version">, HelpText<"Display the version number and exit">;
+defm wrap: Eq<"wrap", "Use wrapper functions for symbol">,
+     MetaVarName<"<symbol>">;
 
 // LLD specific options
 def _HASH_HASH_HASH : Flag<["-"], "###">,
     HelpText<"Print (but do not run) the commands to run for this compilation">;
 def appcontainer: F<"appcontainer">, HelpText<"Set the appcontainer flag in the executable">;
 defm delayload: Eq<"delayload", "DLL to load only on demand">;
 def mllvm: S<"mllvm">;
 defm pdb: Eq<"pdb", "Output PDB debug info file, chosen implicitly if the argument is empty">;

lld/test/COFF/wrap-i386.s

+// REQUIRES: x86
+// RUN: split-file %s %t.dir
+// RUN: llvm-mc -filetype=obj -triple=i686-win32-gnu %t.dir/main.s -o %t.main.obj
+// RUN: llvm-mc -filetype=obj -triple=i686-win32-gnu %t.dir/other.s -o %t.other.obj
+
+// RUN: lld-link -out:%t.exe %t.main.obj %t.other.obj -entry:entry -subsystem:console -debug:symtab -safeseh:no -wrap:foo -wrap:nosuchsym
+// RUN: llvm-objdump -d --print-imm-hex %t.exe | FileCheck %s
+
+// CHECK: <_entry>:
+// CHECK-NEXT: movl $0x11010, %edx
+// CHECK-NEXT: movl $0x11010, %edx
+// CHECK-NEXT: movl $0x11000, %edx
+
+// RUN: llvm-readobj --symbols %t.exe > %t.dump
+// RUN: FileCheck --check-prefix=SYM1 %s < %t.dump
+// RUN: FileCheck --check-prefix=SYM2 %s < %t.dump
+// RUN: FileCheck --check-prefix=SYM3 %s < %t.dump
+
+// _foo = 0xffc11000 = 4290842624
+// ___wrap_foo = ffc11010 = 4290842640
+// SYM1:      Name: _foo
+// SYM1-NEXT: Value: 4290842624
+// SYM1-NEXT: Section: IMAGE_SYM_ABSOLUTE
+// SYM1-NEXT: BaseType: Null
+// SYM1-NEXT: ComplexType: Null
+// SYM1-NEXT: StorageClass: External
+// SYM2:      Name: ___wrap_foo
+// SYM2-NEXT: Value: 4290842640
+// SYM2-NEXT: Section: IMAGE_SYM_ABSOLUTE
+// SYM2-NEXT: BaseType: Null
+// SYM2-NEXT: ComplexType: Null
+// SYM2-NEXT: StorageClass: External
+// SYM3-NOT:  Name: ___real_foo
+
+#--- main.s
+.global _entry
+_entry:
+  movl $_foo, %edx
+  movl $___wrap_foo, %edx
+  movl $___real_foo, %edx
+
+#--- other.s
+.global _foo
+.global ___wrap_foo
+.global ___real_foo
+
+_foo = 0x11000
+___wrap_foo = 0x11010
+___real_foo = 0x11020

lld/test/COFF/wrap-import.ll

+// REQUIRES: x86
+
+// Check that wrapping works when the wrapped symbol is imported from a
+// different DLL.
+
+// RUN: split-file %s %t.dir
+// RUN: llc %t.dir/main.ll -o %t.main.obj --filetype=obj
+// RUN: llvm-as %t.dir/main.ll -o %t.main.bc
+// RUN: llvm-mc -filetype=obj -triple=x86_64-win32-gnu %t.dir/lib.s -o %t.lib.obj
+
+// RUN: lld-link -dll -out:%t.lib.dll %t.lib.obj -noentry -export:func -implib:%t.lib.lib
+// RUN: lld-link -out:%t.exe %t.main.obj %t.lib.lib -entry:entry -subsystem:console -wrap:func
+// RUN: lld-link -out:%t.exe %t.main.bc %t.lib.lib -entry:entry -subsystem:console -wrap:func
+
+#--- main.ll
+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"
+
+declare void @func()
+
+define void @entry() {
+  call void @func()
+  ret void
+}
+
+declare void @__real_func()
+
+define void @__wrap_func() {
+  call void @__real_func()
+  ret void
+}
+
+#--- lib.s
+.global func
+func:
+  ret

lld/test/COFF/wrap-lto-1.ll

+; REQUIRES: x86
+; LTO
+; RUN: llvm-as %s -o %t.obj
+; RUN: lld-link -out:%t.exe %t.obj -entry:entry -subsystem:console -wrap:bar -debug:symtab -lldsavetemps
+; RUN: cat %t.exe.resolution.txt | FileCheck -check-prefix=RESOLS %s
+
+; ThinLTO
+; RUN: opt -module-summary %s -o %t.obj
+; RUN: lld-link -out:%t.exe %t.obj -entry:entry -subsystem:console -wrap:bar -debug:symtab -lldsavetemps
+; RUN: cat %t.exe.resolution.txt | FileCheck -check-prefix=RESOLS %s
+
+; Make sure that the 'r' (linker redefined) bit is set for bar and __real_bar
+; in the resolutions file. The calls to bar and __real_bar will be routed to
+; __wrap_bar and bar, respectively. So they cannot be inlined.
+; RESOLS: ,bar,pxr{{$}}
+; RESOLS: ,__real_bar,xr{{$}}
+; RESOLS: ,__wrap_bar,px{{$}}
+
+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"
+
+define void @bar() {
+  ret void
+}
+
+define void @entry() {
+  call void @bar()
+  ret void
+}
+
+declare void @__real_bar()
+
+define void @__wrap_bar() {
+  call void @__real_bar()
+  ret void
+}

lld/test/COFF/wrap-lto-2.ll

+; REQUIRES: x86
+; RUN: split-file %s %t.dir
+;; LTO
+; RUN: llvm-as %t.dir/main.ll -o %t.main.bc
+; RUN: llvm-as %t.dir/wrap.ll -o %t.wrap.bc
+; RUN: llvm-as %t.dir/other.ll -o %t.other.bc
+; RUN: rm -f %t.bc.lib
+; RUN: llvm-ar rcs %t.bc.lib %t.wrap.bc %t.other.bc
+;; ThinLTO
+; RUN: opt -module-summary %t.dir/main.ll -o %t.main.thin
+; RUN: opt -module-summary %t.dir/wrap.ll -o %t.wrap.thin
+; RUN: opt -module-summary %t.dir/other.ll -o %t.other.thin
+; RUN: rm -f %t.thin.lib
+; RUN: llvm-ar rcs %t.thin.lib %t.wrap.thin %t.other.thin
+;; Object
+; RUN: llc %t.dir/main.ll -o %t.main.obj --filetype=obj
+; RUN: llc %t.dir/wrap.ll -o %t.wrap.obj --filetype=obj
+; RUN: llc %t.dir/other.ll -o %t.other.obj --filetype=obj
+; RUN: rm -f %t.obj.lib
+; RUN: llvm-ar rcs %t.obj.lib %t.wrap.obj %t.other.obj
+
+;; This test verifies that -wrap works correctly for inter-module references to
+;; the wrapped symbol, when LTO or ThinLTO is involved. It checks for various
+;; combinations of bitcode and regular objects.
+
+;; LTO + LTO
+; RUN: lld-link -out:%t.bc-bc.exe %t.main.bc -libpath:%T %t.bc.lib -entry:entry -subsystem:console -wrap:bar -debug:symtab -lldsavetemps
+; RUN: llvm-objdump -d %t.bc-bc.exe | FileCheck %s --check-prefixes=CHECK,JMP
+
+;; LTO + Object
+; RUN: lld-link -out:%t.bc-obj.exe %t.main.bc -libpath:%T %t.obj.lib -entry:entry -subsystem:console -wrap:bar -debug:symtab -lldsavetemps
+; RUN: llvm-objdump -d %t.bc-obj.exe | FileCheck %s --check-prefixes=CHECK,JMP
+
+;; Object + LTO
+; RUN: lld-link -out:%t.obj-bc.exe %t.main.obj -libpath:%T %t.bc.lib -entry:entry -subsystem:console -wrap:bar -debug:symtab -lldsavetemps
+; RUN: llvm-objdump -d %t.obj-bc.exe | FileCheck %s --check-prefixes=CHECK,CALL
+
+;; ThinLTO + ThinLTO
+; RUN: lld-link -out:%t.thin-thin.exe %t.main.thin -libpath:%T %t.thin.lib -entry:entry -subsystem:console -wrap:bar -debug:symtab -lldsavetemps
+; RUN: llvm-objdump -d %t.thin-thin.exe | FileCheck %s --check-prefixes=CHECK,JMP
+
+;; ThinLTO + Object
+; RUN: lld-link -out:%t.thin-obj.exe %t.main.thin -libpath:%T %t.obj.lib -entry:entry -subsystem:console -wrap:bar -debug:symtab -lldsavetemps
+; RUN: llvm-objdump -d %t.thin-obj.exe | FileCheck %s --check-prefixes=CHECK,JMP
+
+;; Object + ThinLTO
+; RUN: lld-link -out:%t.obj-thin.exe %t.main.obj -libpath:%T %t.thin.lib -entry:entry -subsystem:console -wrap:bar -debug:symtab -lldsavetemps
+; RUN: llvm-objdump -d %t.obj-thin.exe | FileCheck %s --check-prefixes=CHECK,CALL
+
+;; Make sure that calls in entry() are not eliminated and that bar is
+;; routed to __wrap_bar.
+
+; CHECK: <entry>:
+; CHECK: {{jmp|callq}}{{.*}}<__wrap_bar>
+
+;--- main.ll
+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"
+
+declare void @bar()
+
+define void @entry() {
+  call void @bar()
+  ret void
+}
+
+;--- wrap.ll
+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"
+
+declare void @other()
+
+define void @__wrap_bar() {
+  call void @other()
+  ret void
+}
+
+;--- other.ll
+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"
+
+define void @other() {
+  ret void
+}

lld/test/COFF/wrap-real-missing.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-win32-gnu %s -o %t.obj
+
+// RUN: not lld-link -lldmingw -out:%t.exe %t.obj -entry:entry -subsystem:console -wrap:foo 2>&1 | FileCheck %s
+
+// Check that we error out properly with an undefined symbol, if
+// __real_foo is referenced and missing, even if the -lldmingw flag is set
+// (which otherwise tolerates certain cases of references to missing
+// sections, to tolerate certain GCC pecularities).
+
+// CHECK: error: undefined symbol: foo
+
+.global entry
+entry:
+  call foo
+  ret
+
+.global __wrap_foo
+__wrap_foo:
+  call __real_foo
+  ret

lld/test/COFF/wrap-with-archive.s

+// REQUIRES: x86
+// RUN: split-file %s %t.dir
+// RUN: llvm-mc -filetype=obj -triple=x86_64-win32-gnu %t.dir/main.s -o %t.main.obj
+// RUN: llvm-mc -filetype=obj -triple=x86_64-win32-gnu %t.dir/wrap.s -o %t.wrap.obj
+// RUN: llvm-mc -filetype=obj -triple=x86_64-win32-gnu %t.dir/other.s -o %t.other.obj
+// RUN: rm -f %t.lib
+// RUN: llvm-ar rcs %t.lib %t.wrap.obj %t.other.obj
+
+// RUN: lld-link -out:%t.exe %t.main.obj -libpath:%T %t.lib -entry:entry -subsystem:console -wrap:foo
+
+// Note: No real definition of foo exists here, but that works fine as long
+// as there's no actual references to __real_foo.
+
+#--- main.s
+.global entry
+entry:
+  call foo
+  ret
+
+#--- wrap.s
+.global __wrap_foo
+__wrap_foo:
+  call other_func
+  ret
+
+#--- other.s
+.global other_func
+other_func:
+  ret

lld/test/COFF/wrap.s

+// REQUIRES: x86
+// RUN: split-file %s %t.dir
+// RUN: llvm-mc -filetype=obj -triple=x86_64-win32-gnu %t.dir/main.s -o %t.main.obj
+// RUN: llvm-mc -filetype=obj -triple=x86_64-win32-gnu %t.dir/other.s -o %t.other.obj
+
+// RUN: lld-link -out:%t.exe %t.main.obj %t.other.obj -entry:entry -subsystem:console -debug:symtab -wrap:foo -wrap:nosuchsym
+// RUN: llvm-objdump -d --print-imm-hex %t.exe | FileCheck %s
+// RUN: lld-link -out:%t.exe %t.main.obj %t.other.obj -entry:entry -subsystem:console -debug:symtab -wrap:foo -wrap:foo -wrap:nosuchsym
+// RUN: llvm-objdump -d --print-imm-hex %t.exe | FileCheck %s
+
+// CHECK: <entry>:
+// CHECK-NEXT: movl $0x11010, %edx
+// CHECK-NEXT: movl $0x11010, %edx
+// CHECK-NEXT: movl $0x11000, %edx
+
+// RUN: llvm-readobj --symbols %t.exe > %t.dump
+// RUN: FileCheck --check-prefix=SYM1 %s < %t.dump
+// RUN: FileCheck --check-prefix=SYM2 %s < %t.dump
+// RUN: FileCheck --check-prefix=SYM3 %s < %t.dump
+
+// foo = 0xC0011000 = 3221295104
+// __wrap_foo = 0xC0011010 = 3221295120
+// SYM1:      Name: foo
+// SYM1-NEXT: Value: 3221295104
+// SYM1-NEXT: Section: IMAGE_SYM_ABSOLUTE
+// SYM1-NEXT: BaseType: Null
+// SYM1-NEXT: ComplexType: Null
+// SYM1-NEXT: StorageClass: External
+// SYM2:      Name: __wrap_foo
+// SYM2-NEXT: Value: 3221295120
+// SYM2-NEXT: Section: IMAGE_SYM_ABSOLUTE
+// SYM2-NEXT: BaseType: Null
+// SYM2-NEXT: ComplexType: Null
+// SYM2-NEXT: StorageClass: External
+// SYM3-NOT:  Name: __real_foo
+
+#--- main.s
+.global entry
+entry:
+  movl $foo, %edx
+  movl $__wrap_foo, %edx
+  movl $__real_foo, %edx
+
+#--- other.s
+.global foo
+.global __wrap_foo
+.global __real_foo
+
+foo = 0x11000
+__wrap_foo = 0x11010
+__real_foo = 0x11020

lld/test/MinGW/driver.test

 
 RUN: ld.lld -### -m i386pep foo.o --no-allow-multiple-definition --allow-multiple-definition | FileCheck -check-prefix ALLOW_MULTIPLE_DEFINITION %s
 RUN: ld.lld -### -m i386pep foo.o -no-allow-multiple-definition -allow-multiple-definition | FileCheck -check-prefix ALLOW_MULTIPLE_DEFINITION %s
 ALLOW_MULTIPLE_DEFINITION: -force:multiple
 
 RUN: ld.lld -### -m i386pep foo.o --allow-multiple-definition --no-allow-multiple-definition | FileCheck -check-prefix NO_ALLOW_MULTIPLE_DEFINITION %s
 RUN: ld.lld -### -m i386pep foo.o -allow-multiple-definition -no-allow-multiple-definition | FileCheck -check-prefix NO_ALLOW_MULTIPLE_DEFINITION %s
 NO_ALLOW_MULTIPLE_DEFINITION-NOT: -force:multiple
+
+RUN: ld.lld -### -m i386pep foo.o -wrap foo1 --wrap foo2 | FileCheck -check-prefix WRAP %s
+RUN: ld.lld -### -m i386pep foo.o -wrap=foo1 --wrap=foo2 | FileCheck -check-prefix WRAP %s
+WRAP: -wrap:foo1 -wrap:foo2