[LLD][COFF] Allow overwriting directives exports with cmd-line exports

[aganea]

Summary

MSVC link.exe allows overriding exports on the cmd-line with exports seen in OBJ directives. The typical case is what is described in #62329.

Before this patch, trying to override an export with /export or /def would generate a duplicate warning. This patches tries to replicate the MSVC behavior. A second override on the cmd-line would still generate the warning.

There's still a case which we don't cover: MSVC link.exe is able to demangle an exported OBJ directive function, and match it with a unmangled export function in a .def file. In the meanwhile, one can use the mangled export in the .def to cover that case.

Depends on D149610.

This fixes #62329

[mstorsjo]

Overall LGTM on this, a couple minor comments on the test.

lld/test/COFF/ordinals-override.test

66

Can you add a comment what the contained directive string is?

67

I guess the debug chunk is irrelevant for the test and could be left out?

111

Symbols like this also probably could be left out here, keeping the testcase yaml more minimal?

(For tests like these, we usually start with handcrafted files - or strip down the compiler generated ones as far as possible.)

[alvinhochun]

lld/COFF/DLL.cpp

562

Can we at least have a more descriptive name for the new argument for baseOrdinal?

601–602

651–652

847

Can you check whether MSVC link.exe allows using export ordinal 0?

lld/test/COFF/export.test

17

This seems to depend on changes to llvm-objdump? There should be a separate parent patch to add this output.

Also this patch despite being marked as depending on D149610 somehow does not include the changes in it.

[alvinhochun]

lld/test/COFF/export.test

17

Sorry, I missed that this line already exists in the current output of llvm-objdump. The second point still applies though.

[aganea]

Address comments.

[aganea]

I'm not quite sure how the parenting works in Phabricator I might be doing things wrong.

lld/COFF/DLL.cpp

562

Good point, I noticed that and forgot to change it.

847

It does not. This links suggests it must start at 1: https://learn.microsoft.com/en-us/cpp/build/reference/export-exports-a-function?view=msvc-170

> link.exe ... /EXPORT:foo,@0
LINK : fatal error LNK1119: invalid ordinal number '0'

[jhenderson]

You've got the parent/child links right, but the diff in this patch should be versus the parent, not versus the base commit on main, i.e. if you think of each patch as a git commit, this patch would be the second commit, which is a child of the previous commit in the stack.

[alvinhochun]

Yes, what jhenderson said. Also you can see in the pre-merge checks it fails to apply the patch, because what it does is that it first applies the parent patch before applying this patch.

[aganea]

Rebase on D149610

[alvinhochun]

lld/test/COFF/ordinals-override.test

66

This is marked "done" but I don't see the comment. Anyway, decoding this shows /export:baz=?baz@@YAXXZ /DEFAULTLIB:"LIBCMT" /DEFAULTLIB:"OLDNAMES" /EXPORT:?foo@@YAXXZ /EXPORT:?bar@@YAXXZ, which seems to be why the pre-merge checks failed on Debian, so I guess they should be cleaned up a bit.

lld-link: error: could not open 'LIBCMT.lib': No such file or directory
lld-link: error: could not open 'OLDNAMES.lib': No such file or directory

[aganea]

Re-apply changes & rebase.

lld/test/COFF/ordinals-override.test

66

Sorry about that, I lost some changes between my rebases. I added them back, please see the new revision. I fixed the linker errors as well.

[alvinhochun]

LGTM except for the issue with the test. I guess wait a few days to see if anyone else have other comments, or someone else can accept too.

lld/test/COFF/ordinals-override.test

66

The pre-merge check is still failing. Can you remove the /DEFAULTLIB: flags from .drectve?

[mstorsjo]

lld/test/COFF/ordinals-override.test

66

Relatedly, it would probably be good if the lld tests would run with some flag that tells it to not look at the surrounding environment, to avoid accidentally making tests that refer to libraries available outside of the tests? Or perhaps it's not too much of an issue as it'd be hit immediately by all buildbots anyway, and the premerge CI in this case too.

[aganea]

Simplify .drectve section and fix tests for real.

[alvinhochun]

Since there have been no other comments, I'll go ahead and mark this accepted.

[aganea]

Thank you for reviewing @alvinhochun @mstorsjo !

lld/COFF/Config.h

 class SectionChunk;
 
 // Short aliases.
 static const auto AMD64 = llvm::COFF::IMAGE_FILE_MACHINE_AMD64;
 static const auto ARM64 = llvm::COFF::IMAGE_FILE_MACHINE_ARM64;
 static const auto ARMNT = llvm::COFF::IMAGE_FILE_MACHINE_ARMNT;
 static const auto I386 = llvm::COFF::IMAGE_FILE_MACHINE_I386;
 
+enum class ExportSource {
+  Unset,
+  Directives,
+  Export,
+  ModuleDefinition,
+};
+
 // Represents an /export option.
 struct Export {
   StringRef name;       // N in /export:N or /export:E=N
   StringRef extName;    // E in /export:E=N
   StringRef aliasTarget; // GNU specific: N in "alias == N"
   Symbol *sym = nullptr;
   uint16_t ordinal = 0;
   bool noname = false;
   bool data = false;
   bool isPrivate = false;
   bool constant = false;
 
   // If an export is a form of /export:foo=dllname.bar, that means
   // that foo should be exported as an alias to bar in the DLL.
   // forwardTo is set to "dllname.bar" part. Usually empty.
   StringRef forwardTo;
   StringChunk *forwardChunk = nullptr;
 
-  // True if this /export option was in .drectves section.
-  bool directives = false;
+  ExportSource source = ExportSource::Unset;
   StringRef symbolName;
   StringRef exportName; // Name in DLL
 
   bool operator==(const Export &e) {
     return (name == e.name && extName == e.extName &&
             aliasTarget == e.aliasTarget &&
             ordinal == e.ordinal && noname == e.noname &&
             data == e.data && isPrivate == e.isPrivate);

lld/COFF/DLL.cpp

 };
 
 // Export table
 // Read Microsoft PE/COFF spec 5.3 for details.
 
 // A chunk for the export descriptor table.
 class ExportDirectoryChunk : public NonSectionChunk {
 public:
-  ExportDirectoryChunk(int i, int j, Chunk *d, Chunk *a, Chunk *n, Chunk *o)
-      : maxOrdinal(i), nameTabSize(j), dllName(d), addressTab(a), nameTab(n),
+  ExportDirectoryChunk(int baseOrdinal, int maxOrdinal, int nameTabSize,
+                       Chunk *d, Chunk *a, Chunk *n, Chunk *o)
+      : baseOrdinal(baseOrdinal), maxOrdinal(maxOrdinal),
+        nameTabSize(nameTabSize), dllName(d), addressTab(a), nameTab(n),
         ordinalTab(o) {}
 
   size_t getSize() const override {
     return sizeof(export_directory_table_entry);
   }
 
   void writeTo(uint8_t *buf) const override {
     memset(buf, 0, getSize());
 
     auto *e = (export_directory_table_entry *)(buf);
     e->NameRVA = dllName->getRVA();
-    e->OrdinalBase = 1;
-    e->AddressTableEntries = maxOrdinal;
+    e->OrdinalBase = baseOrdinal;
+    e->AddressTableEntries = (maxOrdinal - baseOrdinal) + 1;
     e->NumberOfNamePointers = nameTabSize;
     e->ExportAddressTableRVA = addressTab->getRVA();
     e->NamePointerRVA = nameTab->getRVA();
     e->OrdinalTableRVA = ordinalTab->getRVA();
   }
 
+  uint16_t baseOrdinal;
   uint16_t maxOrdinal;
   uint16_t nameTabSize;
   Chunk *dllName;
   Chunk *addressTab;
   Chunk *nameTab;
   Chunk *ordinalTab;
 };
 
 class AddressTableChunk : public NonSectionChunk {
 public:
-  explicit AddressTableChunk(COFFLinkerContext &ctx, size_t maxOrdinal)
-      : size(maxOrdinal), ctx(ctx) {}
+  explicit AddressTableChunk(COFFLinkerContext &ctx, size_t baseOrdinal,
+                             size_t maxOrdinal)
+      : baseOrdinal(baseOrdinal), size((maxOrdinal - baseOrdinal) + 1),
+        ctx(ctx) {}
   size_t getSize() const override { return size * 4; }
 
   void writeTo(uint8_t *buf) const override {
     memset(buf, 0, getSize());
 
     for (const Export &e : ctx.config.exports) {
-      assert(e.ordinal != 0 && "Export symbol has invalid ordinal");
-      // OrdinalBase is 1, so subtract 1 to get the index.
-      uint8_t *p = buf + (e.ordinal - 1) * 4;
+      assert(e.ordinal >= baseOrdinal && "Export symbol has invalid ordinal");
+      // Subtract the OrdinalBase to get the index.
+      uint8_t *p = buf + (e.ordinal - baseOrdinal) * 4;
       uint32_t bit = 0;
       // Pointer to thumb code must have the LSB set, so adjust it.
       if (ctx.config.machine == ARMNT && !e.data)
         bit = 1;
       if (e.forwardChunk) {
         write32le(p, e.forwardChunk->getRVA() | bit);
       } else {
         assert(cast<Defined>(e.sym)->getRVA() != 0 &&
                "Exported symbol unmapped");
         write32le(p, cast<Defined>(e.sym)->getRVA() | bit);
       }
     }
   }
 
 private:
+  size_t baseOrdinal;
   size_t size;
   const COFFLinkerContext &ctx;
 };
 
 class NamePointersChunk : public NonSectionChunk {
 public:
   explicit NamePointersChunk(std::vector<Chunk *> &v) : chunks(v) {}
   size_t getSize() const override { return chunks.size() * 4; }
 
   void writeTo(uint8_t *buf) const override {
     for (Chunk *c : chunks) {
       write32le(buf, c->getRVA());
       buf += 4;
     }
   }
 
 private:
   std::vector<Chunk *> chunks;
 };
 
 class ExportOrdinalChunk : public NonSectionChunk {
 public:
-  explicit ExportOrdinalChunk(const COFFLinkerContext &ctx, size_t i)
-      : size(i), ctx(ctx) {}
+  explicit ExportOrdinalChunk(const COFFLinkerContext &ctx, size_t baseOrdinal,
+                              size_t tableSize)
+      : baseOrdinal(baseOrdinal), size(tableSize), ctx(ctx) {}
   size_t getSize() const override { return size * 2; }
 
   void writeTo(uint8_t *buf) const override {
     for (const Export &e : ctx.config.exports) {
       if (e.noname)
         continue;
-      assert(e.ordinal != 0 && "Export symbol has invalid ordinal");
-      // This table stores unbiased indices, so subtract 1 (OrdinalBase).
-      write16le(buf, e.ordinal - 1);
+      assert(e.ordinal >= baseOrdinal && "Export symbol has invalid ordinal");
+      // This table stores unbiased indices, so subtract OrdinalBase.
+      write16le(buf, e.ordinal - baseOrdinal);
       buf += 2;
     }
   }
 
 private:
+  size_t baseOrdinal;
   size_t size;
   const COFFLinkerContext &ctx;
 };
 
 } // anonymous namespace
 
 void IdataContents::create(COFFLinkerContext &ctx) {
   std::vector<std::vector<DefinedImportData *>> v = binImports(ctx, imports);
Chunk *DelayLoadContents::newThunkChunk(DefinedImportData *s,
   case ARM64:
     return make<ThunkChunkARM64>(s, tailMerge);
   default:
     llvm_unreachable("unsupported machine type");
   }
 }
 
 EdataContents::EdataContents(COFFLinkerContext &ctx) : ctx(ctx) {
-  uint16_t maxOrdinal = 0;
-  for (Export &e : ctx.config.exports)
-    maxOrdinal = std::max(maxOrdinal, e.ordinal);
+  unsigned baseOrdinal = 1 << 16, maxOrdinal = 0;
+  for (Export &e : ctx.config.exports) {
+    baseOrdinal = std::min(baseOrdinal, (unsigned)e.ordinal);
+    maxOrdinal = std::max(maxOrdinal, (unsigned)e.ordinal);
+  }
+  // Ordinals must start at 1 as suggested in:
+  // https://learn.microsoft.com/en-us/cpp/build/reference/export-exports-a-function?view=msvc-170
+  assert(baseOrdinal >= 1);
 
   auto *dllName = make<StringChunk>(sys::path::filename(ctx.config.outputFile));
-  auto *addressTab = make<AddressTableChunk>(ctx, maxOrdinal);
+  auto *addressTab = make<AddressTableChunk>(ctx, baseOrdinal, maxOrdinal);
   std::vector<Chunk *> names;
   for (Export &e : ctx.config.exports)
     if (!e.noname)
       names.push_back(make<StringChunk>(e.exportName));
 
   std::vector<Chunk *> forwards;
   for (Export &e : ctx.config.exports) {
     if (e.forwardTo.empty())
       continue;
     e.forwardChunk = make<StringChunk>(e.forwardTo);
     forwards.push_back(e.forwardChunk);
   }
 
   auto *nameTab = make<NamePointersChunk>(names);
-  auto *ordinalTab = make<ExportOrdinalChunk>(ctx, names.size());
-  auto *dir = make<ExportDirectoryChunk>(maxOrdinal, names.size(), dllName,
-                                         addressTab, nameTab, ordinalTab);
+  auto *ordinalTab = make<ExportOrdinalChunk>(ctx, baseOrdinal, names.size());
+  auto *dir =
+      make<ExportDirectoryChunk>(baseOrdinal, maxOrdinal, names.size(), dllName,
   chunks.push_back(dir);
   chunks.push_back(dllName);
   chunks.push_back(addressTab);
   chunks.push_back(nameTab);
   chunks.push_back(ordinalTab);
   chunks.insert(chunks.end(), names.begin(), names.end());
   chunks.insert(chunks.end(), forwards.begin(), forwards.end());
 }
 
 } // namespace lld::coff

lld/COFF/Driver.cpp

for (StringRef e : directives.exports) {
 
     Export exp = parseExport(e);
     if (ctx.config.machine == I386 && ctx.config.mingw) {
       if (!isDecorated(exp.name))
         exp.name = saver().save("_" + exp.name);
       if (!exp.extName.empty() && !isDecorated(exp.extName))
         exp.extName = saver().save("_" + exp.extName);
     }
-    exp.directives = true;
+    exp.source = ExportSource::Directives;
     ctx.config.exports.push_back(exp);
   }
 
   // Handle /include: in bulk.
   for (StringRef inc : directives.includes)
     addUndefined(inc);
 
   // Handle /exclude-symbols: in bulk.
for (COFFShortExport e1 : m.Exports) {
     e2.name = saver().save(e1.Name);
     e2.extName = saver().save(e1.ExtName);
     e2.aliasTarget = saver().save(e1.AliasTarget);
     e2.ordinal = e1.Ordinal;
     e2.noname = e1.Noname;
     e2.data = e1.Data;
     e2.isPrivate = e1.Private;
     e2.constant = e1.Constant;
+    e2.source = ExportSource::ModuleDefinition;
     ctx.config.exports.push_back(e2);
   }
 }
 
 void LinkerDriver::enqueueTask(std::function<void()> task) {
   taskQueue.push_back(std::move(task));
 }
 
do {
     if (config->entry)
       mangleMaybe(config->entry);
 
     // Windows specific -- Make sure we resolve all dllexported symbols.
     for (Export &e : config->exports) {
       if (!e.forwardTo.empty())
         continue;
       e.sym = addUndefined(e.name);
-      if (!e.directives)
+      if (e.source != ExportSource::Directives)
         e.symbolName = mangleMaybe(e.sym);
     }
 
     // Add weak aliases. Weak aliases is a mechanism to give remaining
     // undefined symbols final chance to be resolved successfully.
     for (auto pair : config->alternateNames) {
       StringRef from = pair.first;
       StringRef to = pair.second;

lld/COFF/DriverUtils.cpp

 }
 
 // Parse a string in the form of
 // "<name>[=<internalname>][,@ordinal[,NONAME]][,DATA][,PRIVATE]"
 // or "<name>=<dllname>.<name>".
 // Used for parsing /export arguments.
 Export LinkerDriver::parseExport(StringRef arg) {
   Export e;
+  e.source = ExportSource::Export;
+
   StringRef rest;
   std::tie(e.name, rest) = arg.split(",");
   if (e.name.empty())
     goto err;
 
   if (e.name.contains('=')) {
     auto [x, y] = e.name.split("=");
 
static StringRef killAt(StringRef sym, bool prefix) {
   // For fastcall, remove the leading @ and replace it with an
   // underscore, if prefixes are used.
   sym = sym.substr(1);
   if (prefix)
     sym = saver().save("_" + sym);
   return sym;
 }
 
+static StringRef exportSourceName(ExportSource s) {
+  switch (s) {
+  case ExportSource::Directives:
+    return "source file (directives)";
+  case ExportSource::Export:
+    return "/export";
+  case ExportSource::ModuleDefinition:
+    return "/def";
+  default:
+    llvm_unreachable("unknown ExportSource");
+  }
+}
+
 // Performs error checking on all /export arguments.
 // It also sets ordinals.
 void LinkerDriver::fixupExports() {
   // Symbol ordinals must be unique.
   std::set<uint16_t> ords;
   for (Export &e : ctx.config.exports) {
     if (e.ordinal == 0)
       continue;
for (Export &e : ctx.config.exports) {
       e.name = killAt(e.name, true);
       e.exportName = killAt(e.exportName, false);
       e.extName = killAt(e.extName, true);
       e.symbolName = killAt(e.symbolName, true);
     }
   }
 
   // Uniquefy by name.
-  DenseMap<StringRef, Export *> map(ctx.config.exports.size());
+  DenseMap<StringRef, std::pair<Export *, unsigned>> map(
+      ctx.config.exports.size());
   std::vector<Export> v;
   for (Export &e : ctx.config.exports) {
-    auto pair = map.insert(std::make_pair(e.exportName, &e));
+    auto pair = map.insert(std::make_pair(e.exportName, std::make_pair(&e, 0)));
     bool inserted = pair.second;
     if (inserted) {
+      pair.first->second.second = v.size();
       v.push_back(e);
       continue;
     }
-    Export *existing = pair.first->second;
+    Export *existing = pair.first->second.first;
     if (e == *existing || e.name != existing->name)
       continue;
-    warn("duplicate /export option: " + e.name);
+    // If the existing export comes from .OBJ directives, we are allowed to
+    // overwrite it with /DEF: or /EXPORT without any warning, as MSVC link.exe
+    // does.
+    if (existing->source == ExportSource::Directives) {
+      *existing = e;
+      v[pair.first->second.second] = e;
+      continue;
+    }
+    if (existing->source == e.source) {
+      warn(Twine("duplicate ") + exportSourceName(existing->source) +
+           " option: " + e.name);
+    } else {
+      warn("duplicate export: " + e.name +
+           Twine(" first seen in " + exportSourceName(existing->source) +
+                 Twine(", now in " + exportSourceName(e.source))));
+    }
   }
   ctx.config.exports = std::move(v);
 
   // Sort by name.
   llvm::sort(ctx.config.exports, [](const Export &a, const Export &b) {
     return a.exportName < b.exportName;
   });
 }

lld/test/COFF/export.test

 # RUN: yaml2obj %p/Inputs/export.yaml -o %t.obj
 #
 # RUN: lld-link /out:%t.dll /dll %t.obj /export:exportfn1 /export:exportfn2
 # RUN: llvm-objdump -p %t.dll | FileCheck --check-prefix=CHECK1 %s
 
 CHECK1:      Export Table:
 CHECK1-NEXT: DLL name: export.test.tmp.dll
 CHECK1-NEXT: Ordinal base: 1
 CHECK1-NEXT: Ordinal      RVA  Name
 CHECK1-NEXT:       1   0x1008  exportfn1
 CHECK1-NEXT:       2   0x1010  exportfn2
 
 # RUN: lld-link /out:%t.dll /dll %t.obj /export:exportfn1,@5 /export:exportfn2
 # RUN: llvm-objdump -p %t.dll | FileCheck --check-prefix=CHECK2 %s
 
 CHECK2:      Export Table:
 CHECK2-NEXT: DLL name: export.test.tmp.dll
-CHECK2-NEXT: Ordinal base: 1
+CHECK2-NEXT: Ordinal base: 5
 CHECK2-NEXT: Ordinal      RVA  Name
 CHECK2-NEXT:       5   0x1008  exportfn1
 CHECK2-NEXT:       6   0x1010  exportfn2
 CHECK2-NEXT:       7   0x1010  exportfn3
 
 # RUN: lld-link /out:%t.dll /dll %t.obj /export:exportfn1,@5,noname /export:exportfn2
 # RUN: llvm-objdump -p %t.dll | FileCheck --check-prefix=CHECK3 %s
 
 CHECK3:      Export Table:
 CHECK3-NEXT: DLL name: export.test.tmp.dll
-CHECK3-NEXT: Ordinal base: 1
+CHECK3-NEXT: Ordinal base: 5
 CHECK3-NEXT: Ordinal      RVA  Name
 CHECK3-NEXT:       5   0x1008
 CHECK3-NEXT:       6   0x1010  exportfn2
 
 # RUN: lld-link /out:%t.dll /dll %t.obj /export:f1=exportfn1 /export:f2=exportfn2 /implib:%t.lib
 # RUN: llvm-objdump -p %t.dll | FileCheck --check-prefix=CHECK4 %s
 # RUN: llvm-nm %t.lib | FileCheck -check-prefix=CHECK4-NM %s
 

 
 # RUN: echo "EXPORTS exportfn1 @3" > %t.def
 # RUN: echo "fn2=exportfn2 @2" >> %t.def
 # RUN: lld-link /out:%t.dll /dll %t.obj /def:%t.def
 # RUN: llvm-objdump -p %t.dll | FileCheck --check-prefix=CHECK5 %s
 
 CHECK5:      Export Table:
 CHECK5-NEXT: DLL name: export.test.tmp.dll
-CHECK5-NEXT: Ordinal base: 1
+CHECK5-NEXT: Ordinal base: 2
 CHECK5-NEXT: Ordinal      RVA  Name
 CHECK5-NEXT:       2   0x1010  fn2
 CHECK5-NEXT:       3   0x1008  exportfn1
 CHECK5-NEXT:       4   0x1010  exportfn3
 
 # RUN: lld-link /out:%t.DLL /dll %t.obj /export:exportfn1 /export:exportfn2 \
 # RUN:   /export:exportfn1 /export:exportfn2,@5 >& %t.log
 # RUN: FileCheck -check-prefix=CHECK6 %s < %t.log

lld/test/COFF/export32.test

 # HEADER-MERGE-NEXT: VirtualAddress: 0x2000
 
 # RUN: lld-link -safeseh:no /out:%t.dll /dll %t.obj /export:exportfn1,@5 \
 # RUN:   /export:exportfn2 /export:mangled
 # RUN: llvm-objdump -p %t.dll | FileCheck --check-prefix=CHECK2 %s
 
 # CHECK2:      Export Table:
 # CHECK2-NEXT: DLL name: export32.test.tmp.dll
-# CHECK2-NEXT: Ordinal base: 1
+# CHECK2-NEXT: Ordinal base: 5
 # CHECK2-NEXT: Ordinal      RVA  Name
 # CHECK2-NEXT:       5   0x1008  exportfn1
 # CHECK2-NEXT:       6   0x1010  exportfn2
 # CHECK2-NEXT:       7   0x1010  exportfn3
 # CHECK2-NEXT:       8   0x1010  mangled
 
 # RUN: lld-link -safeseh:no /out:%t.dll /dll %t.obj /export:exportfn1,@5,noname /export:exportfn2
 # RUN: llvm-objdump -p %t.dll | FileCheck --check-prefix=CHECK3 %s
 
 # CHECK3:      Export Table:
 # CHECK3-NEXT: DLL name: export32.test.tmp.dll
-# CHECK3-NEXT: Ordinal base: 1
+# CHECK3-NEXT: Ordinal base: 5
 # CHECK3-NEXT: Ordinal      RVA  Name
 # CHECK3-NEXT:       5   0x1008
 # CHECK3-NEXT:       6   0x1010  exportfn2
 
 # RUN: lld-link -safeseh:no /out:%t.dll /dll %t.obj /export:f1=exportfn1 /export:f2=exportfn2
 # RUN: llvm-objdump -p %t.dll | FileCheck --check-prefix=CHECK4 %s
 
 # CHECK4:      Export Table:

 
 # RUN: echo "EXPORTS exportfn1 @ 3" > %t.def
 # RUN: echo "fn2=exportfn2 @ 2" >> %t.def
 # RUN: lld-link -safeseh:no /out:%t.dll /dll %t.obj /def:%t.def
 # RUN: llvm-objdump -p %t.dll | FileCheck --check-prefix=CHECK5 %s
 
 # CHECK5:      Export Table:
 # CHECK5-NEXT: DLL name: export32.test.tmp.dll
-# CHECK5-NEXT: Ordinal base: 1
+# CHECK5-NEXT: Ordinal base: 2
 # CHECK5-NEXT: Ordinal      RVA  Name
 # CHECK5-NEXT:       2   0x1010  fn2
 # CHECK5-NEXT:       3   0x1008  exportfn1
 # CHECK5-NEXT:       4   0x1010  exportfn3
 
 # RUN: lld-link -safeseh:no /out:%t.dll /dll %t.obj /export:exportfn1 /export:exportfn2 \
 # RUN:   /export:exportfn1 /export:exportfn2,@5 >& %t.log
 # RUN: FileCheck -check-prefix=CHECK6 %s < %t.log

lld/test/COFF/ordinals-override.test

+# RUN: yaml2obj %s -o %t.obj
+#
+# RUN: lld-link /out:%t.dll /dll %t.obj
+# RUN: llvm-objdump -p %t.dll | FileCheck --check-prefix=CHECK1 %s
+#
+# CHECK1:      Export Table:
+# CHECK1:      DLL name: ordinals-override.test.tmp.dll
+# CHECK1:      Ordinal base: 1
+# CHECK1:      Ordinal      RVA  Name
+# CHECK1-NEXT:       1   0x1010  ?bar@@YAXXZ
+# CHECK1-NEXT:       2   0x1000  ?foo@@YAXXZ
+# CHECK1-NEXT:       3   0x1020  baz
+#
+# RUN: lld-link /out:%t.dll /dll %t.obj /EXPORT:?foo@@YAXXZ,@55
+# RUN: llvm-objdump -p %t.dll | FileCheck --check-prefix=CHECK2 %s
+#
+# CHECK2:      Export Table:
+# CHECK2:      DLL name: ordinals-override.test.tmp.dll
+# CHECK2:      Ordinal base: 55
+# CHECK2:      Ordinal      RVA  Name
+# CHECK2-NEXT:      55   0x1000  ?foo@@YAXXZ
+# CHECK2-NEXT:      56   0x1010  ?bar@@YAXXZ
+# CHECK2-NEXT:      57   0x1020  baz
+#
+# RUN: lld-link /out:%t.dll /dll %t.obj /EXPORT:?foo@@YAXXZ,@55 /EXPORT:?bar@@YAXXZ,@122
+# RUN: llvm-objdump -p %t.dll | FileCheck --check-prefix=CHECK3 %s
+#
+# CHECK3:      Export Table:
+# CHECK3:      DLL name: ordinals-override.test.tmp.dll
+# CHECK3:      Ordinal base: 55
+# CHECK3:      Ordinal      RVA  Name
+# CHECK3-NEXT:      55   0x1000  ?foo@@YAXXZ
+# CHECK3-NEXT:     122   0x1010  ?bar@@YAXXZ
+# CHECK3-NEXT:     123   0x1020  baz
+#
+# RUN: echo "EXPORTS" > %t.def
+# RUN: echo "?foo@@YAXXZ @55" >> %t.def
+# RUN: echo "?bar@@YAXXZ @122" >> %t.def
+# RUN: lld-link /out:%t.dll /dll %t.obj /DEF:%t.def 2>&1 | FileCheck --check-prefix=WARN --allow-empty %s
+# WARN-NOT: lld-link: warning
+#
+# RUN: llvm-objdump -p %t.dll | FileCheck --check-prefix=CHECK3 %s
+#
+# RUN: lld-link /out:%t.dll /dll %t.obj /DEF:%t.def /EXPORT:?foo@@YAXXZ,@10000 /nodefaultlib /force 2>&1 | FileCheck --check-prefix=DUPLICATED %s
+# DUPLICATED: lld-link: warning: duplicate export: ?foo@@YAXXZ first seen in /export, now in /def
+#
+# RUN: llvm-objdump -p %t.dll | FileCheck --check-prefix=CHECK4 %s
+#
+# CHECK4:      Export Table:
+# CHECK4:      DLL name: ordinals-override.test.tmp.dll
+# CHECK4:      Ordinal base: 122
+# CHECK4:      Ordinal      RVA  Name
+# CHECK4-NEXT:     122   0x1010  ?bar@@YAXXZ
+# CHECK4-NEXT:   10000   0x1000  ?foo@@YAXXZ
+# CHECK4-NEXT:   10001   0x1020  baz
+
+# The .drectve section below contains the following:
+#
+#   Linker Directives
+#   -----------------
+#   /export:baz=?baz@@YAXXZ
+#   /DEFAULTLIB:LIBCMT
+#   /DEFAULTLIB:OLDNAMES
+#   /EDITANDCONTINUE
+#   /EXPORT:?foo@@YAXXZ
+#   /EXPORT:?bar@@YAXXZ
+
+--- !COFF
+header:
+  Machine:         IMAGE_FILE_MACHINE_AMD64
+  Characteristics: [  ]
+sections:
+  - Name:            .drectve
+    Characteristics: [ IMAGE_SCN_LNK_INFO, IMAGE_SCN_LNK_REMOVE ]
+    Alignment:       1
+    SectionData:     2020202F6578706F72743A62617A3D3F62617A4040594158585A202F44454641554C544C49423A224C4942434D5422202F44454641554C544C49423A224F4C444E414D455322202F4558504F52543A3F666F6F4040594158585A202F4558504F52543A3F6261724040594158585A20
+  - Name:            '.text$mn'
+    Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]
+    Alignment:       16
+    SectionData:     C20000CCCCCCCCCCCCCCCCCCCCCCCCCCC20000CCCCCCCCCCCCCCCCCCCCCCCCCCC20000
+symbols:
+  - Name:            .drectve
+    Value:           0
+    SectionNumber:   1
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          111
+      NumberOfRelocations: 0
+      NumberOfLinenumbers: 0
+      CheckSum:        3793361033
+      Number:          0
+  - Name:            '.text$mn'
+    Value:           0
+    SectionNumber:   2
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_NULL
+    StorageClass:    IMAGE_SYM_CLASS_STATIC
+    SectionDefinition:
+      Length:          35
+      NumberOfRelocations: 0
+      NumberOfLinenumbers: 0
+      CheckSum:        1911911868
+      Number:          0
+  - Name:            '?foo@@YAXXZ'
+    Value:           0
+    SectionNumber:   2
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_FUNCTION
+    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL
+  - Name:            '?bar@@YAXXZ'
+    Value:           16
+    SectionNumber:   2
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_FUNCTION
+    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL
+  - Name:            '?baz@@YAXXZ'
+    Value:           32
+    SectionNumber:   2
+    SimpleType:      IMAGE_SYM_TYPE_NULL
+    ComplexType:     IMAGE_SYM_DTYPE_FUNCTION
+    StorageClass:    IMAGE_SYM_CLASS_EXTERNAL
+...