[JITLink][COFF] Implement include/alternatename linker directive.

[sunho]

Summary

Implements include/alternatename linker directive. Alternatename is used by static msvc runtime library. Alias symbol is technically incorrect (we have to search for external definition) but we don't have a way to represent this in jitlink/orc yet, this is solved in the following up patch.

Inlcude linker directive is used in ucrt to forcelly lookup the static initializer symbols so that they will be emitted. It's implemented as extenral symbols with live flag on that cause the lookup of these symbols.

[sunho]

Add tests / handle string read after free.

[lhames]

LGTM. This is really cool -- we've never had a proper way to handle COFF exports!

Speaking of which -- in the long term we may want to move the COFF options parser to libObject -- it would allow us to set the SF_Export flag correctly in that library, and JITLink could re-use the parser from there (since JITLink depends on libObject).

[lhames]

I've filed https://github.com/llvm/llvm-project/issues/56716 to investigate moving the options parser to libObject in the future.

llvm/lib/ExecutionEngine/JITLink/CMakeLists.txt

+set(LLVM_TARGET_DEFINITIONS COFFOptions.td)
+tablegen(LLVM COFFOptions.inc -gen-opt-parser-defs)
+add_public_tablegen_target(JITLinkTableGen)
+
 add_llvm_component_library(LLVMJITLink
   DWARFRecordSectionSplitter.cpp
   EHFrameSupport.cpp
   JITLink.cpp
   JITLinkGeneric.cpp
   JITLinkMemoryManager.cpp
   MemoryFlags.cpp
 
add_llvm_component_library(LLVMJITLink
   ELF.cpp
   ELFLinkGraphBuilder.cpp
   ELF_aarch64.cpp
   ELF_riscv.cpp
   ELF_x86_64.cpp
 
   # COFF
   COFF.cpp
+  COFFDirectiveParser.cpp
   COFFLinkGraphBuilder.cpp
   COFF_x86_64.cpp
 
   # Architectures:
   aarch64.cpp
   riscv.cpp
   x86_64.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/ExecutionEngine/JITLink
 
   DEPENDS
   intrinsics_gen
+  JITLinkTableGen
 
   LINK_COMPONENTS
   BinaryFormat
   Object
+  Option
   OrcTargetProcess
   Support
   )
 
 target_link_libraries(LLVMJITLink
   PRIVATE
   LLVMObject
   LLVMOrcShared
   LLVMOrcTargetProcess
   LLVMSupport
 )

llvm/lib/ExecutionEngine/JITLink/COFFDirectiveParser.h

+//===--- COFFDirectiveParser.h - JITLink coff directive parser --*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// MSVC COFF directive parser
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_JITLINK_COFFDIRECTIVEPARSER_H
+#define LLVM_EXECUTIONENGINE_JITLINK_COFFDIRECTIVEPARSER_H
+
+#include "llvm/ADT/Triple.h"
+#include "llvm/ExecutionEngine/JITLink/JITLink.h"
+#include "llvm/Option/Arg.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/StringSaver.h"
+
+namespace llvm {
+namespace jitlink {
+
+enum {
+  COFF_OPT_INVALID = 0,
+#define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) COFF_OPT_##ID,
+#include "COFFOptions.inc"
+#undef OPTION
+};
+
+/// Parser for the MSVC specific preprocessor directives.
+/// https://docs.microsoft.com/en-us/cpp/preprocessor/comment-c-cpp?view=msvc-160
+class COFFDirectiveParser {
+public:
+  Expected<std::unique_ptr<opt::InputArgList>> parse(StringRef Str);
+
+private:
+  llvm::BumpPtrAllocator bAlloc;
+  llvm::StringSaver saver{bAlloc};
+};
+
+} // end namespace jitlink
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_JITLINK_COFFDIRECTIVEPARSER_H
 No newline at end of file

llvm/lib/ExecutionEngine/JITLink/COFFDirectiveParser.cpp

+//===-- COFFDirectiveParser.cpp - JITLink coff directive parser --*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// MSVC COFF directive parser
+//
+//===----------------------------------------------------------------------===//
+
+#include "COFFDirectiveParser.h"
+
+using namespace llvm;
+using namespace jitlink;
+
+#define DEBUG_TYPE "jitlink"
+
+// Create prefix string literals used in Options.td
+#define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
+#include "COFFOptions.inc"
+#undef PREFIX
+
+// Create table mapping all options defined in COFFOptions.td
+static const opt::OptTable::Info infoTable[] = {
+#define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12)      \
+  {X1,                                                                         \
+   X2,                                                                         \
+   X10,                                                                        \
+   X11,                                                                        \
+   COFF_OPT_##ID,                                                              \
+   opt::Option::KIND##Class,                                                   \
+   X9,                                                                         \
+   X8,                                                                         \
+   COFF_OPT_##GROUP,                                                           \
+   COFF_OPT_##ALIAS,                                                           \
+   X7,                                                                         \
+   X12},
+#include "COFFOptions.inc"
+#undef OPTION
+};
+
+class COFFOptTable : public opt::OptTable {
+public:
+  COFFOptTable() : OptTable(infoTable, true) {}
+};
+
+static COFFOptTable optTable;
+
+Expected<std::unique_ptr<opt::InputArgList>>
+COFFDirectiveParser::parse(StringRef Str) {
+  SmallVector<StringRef, 16> Tokens;
+  SmallVector<const char *, 16> Buffer;
+  cl::TokenizeWindowsCommandLineNoCopy(Str, saver, Tokens);
+  for (StringRef Tok : Tokens) {
+    bool HasNul = Tok.end() != Str.end() && Tok.data()[Tok.size()] == '\0';
+    Buffer.push_back(HasNul ? Tok.data() : saver.save(Tok).data());
+  }
+
+  unsigned missingIndex;
+  unsigned missingCount;
+
+  auto Result = std::make_unique<opt::InputArgList>(
+      optTable.ParseArgs(Buffer, missingIndex, missingCount));
+
+  if (missingCount)
+    return make_error<JITLinkError>(Twine("COFF directive parsing failed: ") +
+                                    Result->getArgString(missingIndex) +
+                                    " missing argument");
+  LLVM_DEBUG({
+    for (auto *arg : Result->filtered(COFF_OPT_UNKNOWN))
+      dbgs() << "Unknown coff option argument: " << arg->getAsString(*Result)
+             << "\n";
+  });
+  return Result;
+}

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.h

 #ifndef LIB_EXECUTIONENGINE_JITLINK_COFFLINKGRAPHBUILDER_H
 #define LIB_EXECUTIONENGINE_JITLINK_COFFLINKGRAPHBUILDER_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ExecutionEngine/JITLink/JITLink.h"
 #include "llvm/Object/COFF.h"
 
+#include "COFFDirectiveParser.h"
 #include "EHFrameSupportImpl.h"
 #include "JITLinkGeneric.h"
 
 #define DEBUG_TYPE "jitlink"
 
 #include <list>
 
 namespace llvm {
private:
 
   // Per COFF section jitlink symbol set sorted by offset.
   // Used for calculating implicit size of defined symbols.
   using SymbolSet = std::set<std::pair<orc::ExecutorAddrDiff, Symbol *>>;
   std::vector<SymbolSet> SymbolSets;
 
   Section &getCommonSection();
 
+  Symbol *createExternalSymbol(COFFSymbolIndex SymIndex, StringRef SymbolName,
+                               object::COFFSymbolRef Symbol,
+                               const object::coff_section *Section);
+  Expected<Symbol *> createAliasSymbol(StringRef SymbolName, Linkage L, Scope S,
+                                       Symbol &Target);
   Expected<Symbol *> createDefinedSymbol(COFFSymbolIndex SymIndex,
                                          StringRef SymbolName,
                                          object::COFFSymbolRef Symbol,
                                          const object::coff_section *Section);
   Expected<Symbol *> createCOMDATExportRequest(
       COFFSymbolIndex SymIndex, object::COFFSymbolRef Symbol,
       const object::coff_aux_section_definition *Definition);
   Expected<Symbol *> exportCOMDATSymbol(COFFSymbolIndex SymIndex,
                                         StringRef SymbolName,
                                         object::COFFSymbolRef Symbol);
+
+  Error handleDirectiveSection(StringRef Str);
   Error flushWeakAliasRequests();
+  Error handleAlternateNames();
   Error calculateImplicitSizeOfSymbols();
 
   static uint64_t getSectionAddress(const object::COFFObjectFile &Obj,
                                     const object::coff_section *Section);
   static uint64_t getSectionSize(const object::COFFObjectFile &Obj,
                                  const object::coff_section *Section);
   static bool isComdatSection(const object::coff_section *Section);
   static unsigned getPointerSize(const object::COFFObjectFile &Obj);
   static support::endianness getEndianness(const object::COFFObjectFile &Obj);
   static StringRef getDLLImportStubPrefix() { return "__imp_"; }
+  static StringRef getDirectiveSectionName() { return ".drectve"; }
   StringRef getCOFFSectionName(COFFSectionIndex SectionIndex,
                                const object::coff_section *Sec,
                                object::COFFSymbolRef Sym);
 
   const object::COFFObjectFile &Obj;
   std::unique_ptr<LinkGraph> G;
+  COFFDirectiveParser DirectiveParser;
 
   Section *CommonSection = nullptr;
   std::vector<Block *> GraphBlocks;
   std::vector<Symbol *> GraphSymbols;
 
+  DenseMap<StringRef, StringRef> AlternateNames;
   DenseMap<StringRef, Symbol *> ExternalSymbols;
+  DenseMap<StringRef, Symbol *> DefinedSymbols;
 };
 
 template <typename RelocHandlerFunction>
 Error COFFLinkGraphBuilder::forEachRelocation(const object::SectionRef &RelSec,
                                               RelocHandlerFunction &&Func,
                                               bool ProcessDebugSections) {
 
   auto COFFRelSect = Obj.getCOFFSection(RelSec);

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp

if ((*Sec)->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA)
           *GraphSec, getSectionSize(Obj, *Sec),
           orc::ExecutorAddr(getSectionAddress(Obj, *Sec)),
           (*Sec)->getAlignment(), 0);
     else {
       ArrayRef<uint8_t> Data;
       if (auto Err = Obj.getSectionContents(*Sec, Data))
         return Err;
 
+      auto CharData = ArrayRef<char>(
+          reinterpret_cast<const char *>(Data.data()), Data.size());
+
+      if (SectionName == getDirectiveSectionName())
+        if (auto Err = handleDirectiveSection(
+                StringRef(CharData.data(), CharData.size())))
+          return Err;
+
       B = &G->createContentBlock(
-          *GraphSec,
-          ArrayRef<char>(reinterpret_cast<const char *>(Data.data()),
-                         Data.size()),
-          orc::ExecutorAddr(getSectionAddress(Obj, *Sec)),
+          *GraphSec, CharData, orc::ExecutorAddr(getSectionAddress(Obj, *Sec)),
           (*Sec)->getAlignment(), 0);
     }
 
     setGraphBlock(SecIndex, B);
   }
 
   return Error::success();
 }
for (COFFSymbolIndex SymIndex = 0;
     if (Sym->isFileRecord())
       LLVM_DEBUG({
         dbgs() << "    " << SymIndex << ": Skipping FileRecord symbol \""
                << SymbolName << "\" in "
                << getCOFFSectionName(SectionIndex, Sec, *Sym)
                << " (index: " << SectionIndex << ") \n";
       });
     else if (Sym->isUndefined()) {
-      auto CreateExternalSymbol = [&](StringRef SymbolName) {
-        if (!ExternalSymbols.count(SymbolName))
-          ExternalSymbols[SymbolName] = &G->addExternalSymbol(
-              SymbolName, Sym->getValue(), Linkage::Strong);
-
-        LLVM_DEBUG({
-          dbgs() << "    " << SymIndex
-                 << ": Creating external graph symbol for COFF symbol \""
-                 << SymbolName << "\" in "
-                 << getCOFFSectionName(SectionIndex, Sec, *Sym)
-                 << " (index: " << SectionIndex << ") \n";
-        });
-        return ExternalSymbols[SymbolName];
-      };
       if (SymbolName.startswith(getDLLImportStubPrefix())) {
         if (Sym->getValue() != 0)
           return make_error<JITLinkError>(
               "DLL import symbol has non-zero offset");
 
-        auto ExternalSym = CreateExternalSymbol(
-            SymbolName.drop_front(getDLLImportStubPrefix().size()));
+        auto ExternalSym = createExternalSymbol(
+            SymIndex, SymbolName.drop_front(getDLLImportStubPrefix().size()),
+            *Sym, Sec);
         GSym = &createDLLImportEntry(SymbolName, *ExternalSym);
       } else
-        GSym = CreateExternalSymbol(SymbolName);
+        GSym = createExternalSymbol(SymIndex, SymbolName, *Sym, Sec);
     } else if (Sym->isWeakExternal()) {
       auto *WeakExternal = Sym->getAux<object::coff_aux_weak_external>();
       COFFSymbolIndex TagIndex = WeakExternal->TagIndex;
       uint32_t Characteristics = WeakExternal->Characteristics;
       WeakExternalRequests.push_back(
           {SymIndex, TagIndex, Characteristics, SymbolName});
     } else {
       Expected<jitlink::Symbol *> NewGSym =
for (COFFSymbolIndex SymIndex = 0;
     if (GSym)
       setGraphSymbol(SectionIndex, SymIndex, *GSym);
     SymIndex += Sym->getNumberOfAuxSymbols();
   }
 
   if (auto Err = flushWeakAliasRequests())
     return Err;
 
+  if (auto Err = handleAlternateNames())
+    return Err;
+
   if (auto Err = calculateImplicitSizeOfSymbols())
     return Err;
 
   return Error::success();
 }
 
+Error COFFLinkGraphBuilder::handleDirectiveSection(StringRef Str) {
+  auto Parsed = DirectiveParser.parse(Str);
+  if (!Parsed)
+    return Parsed.takeError();
+  for (auto *Arg : **Parsed) {
+    StringRef S = Arg->getValue();
+    switch (Arg->getOption().getID()) {
+    case COFF_OPT_alternatename: {
+      StringRef From, To;
+      std::tie(From, To) = S.split('=');
+      if (From.empty() || To.empty())
+        return make_error<JITLinkError>(
+            "Invalid COFF /alternatename directive");
+      AlternateNames[From] = To;
+      break;
+    }
+    case COFF_OPT_incl: {
+      auto DataCopy = G->allocateString(S);
+      StringRef StrCopy(DataCopy.data(), DataCopy.size());
+      ExternalSymbols[StrCopy] =
+          &G->addExternalSymbol(StrCopy, 0, Linkage::Strong);
+      ExternalSymbols[StrCopy]->setLive(true);
+      break;
+    }
+    case COFF_OPT_export:
+      break;
+    default: {
+      LLVM_DEBUG({
+        dbgs() << "Unknown coff directive: " << Arg->getSpelling() << "\n";
+      });
+      break;
+    }
+    }
+  }
+  return Error::success();
+}
+
 Error COFFLinkGraphBuilder::flushWeakAliasRequests() {
   // Export the weak external symbols and alias it
   for (auto &WeakExternal : WeakExternalRequests) {
     if (auto *Target = getGraphSymbol(WeakExternal.Target)) {
       Expected<object::COFFSymbolRef> AliasSymbol =
           Obj.getSymbol(WeakExternal.Alias);
       if (!AliasSymbol)
         return AliasSymbol.takeError();
 
       // FIXME: IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY and
       // IMAGE_WEAK_EXTERN_SEARCH_LIBRARY are handled in the same way.
       Scope S =
           WeakExternal.Characteristics == COFF::IMAGE_WEAK_EXTERN_SEARCH_ALIAS
               ? Scope::Default
               : Scope::Local;
 
-      // FIXME: Support this when there's a way to handle this.
-      if (!Target->isDefined())
-        return make_error<JITLinkError>("Weak external symbol with external "
-                                        "symbol as alternative not supported.");
-
-      jitlink::Symbol *NewSymbol = &G->addDefinedSymbol(
-          Target->getBlock(), Target->getOffset(), WeakExternal.SymbolName,
-          Target->getSize(), Linkage::Weak, S, Target->isCallable(), false);
+      auto NewSymbol =
+          createAliasSymbol(WeakExternal.SymbolName, Linkage::Weak, S, *Target);
+      if (!NewSymbol)
+        return NewSymbol.takeError();
       setGraphSymbol(AliasSymbol->getSectionNumber(), WeakExternal.Alias,
-                     *NewSymbol);
+                     **NewSymbol);
       LLVM_DEBUG({
         dbgs() << "    " << WeakExternal.Alias
                << ": Creating weak external symbol for COFF symbol \""
                << WeakExternal.SymbolName << "\" in section "
                << AliasSymbol->getSectionNumber() << "\n";
-        dbgs() << "      " << *NewSymbol << "\n";
+        dbgs() << "      " << **NewSymbol << "\n";
       });
     } else
       return make_error<JITLinkError>("Weak symbol alias requested but actual "
                                       "symbol not found for symbol " +
                                       formatv("{0:d}", WeakExternal.Alias));
   }
   return Error::success();
 }
 
+Error COFFLinkGraphBuilder::handleAlternateNames() {
+  // FIXME: Use proper alias
+  for (auto &KeyValue : AlternateNames)
+    if (DefinedSymbols.count(KeyValue.second) &&
+        ExternalSymbols.count(KeyValue.first)) {
+      auto *Target = DefinedSymbols[KeyValue.second];
+      auto *Alias = ExternalSymbols[KeyValue.first];
+      G->makeDefined(*Alias, Target->getBlock(), Target->getOffset(),
+                     Target->getSize(), Linkage::Weak, Scope::Local, false);
+    }
+  return Error::success();
+}
+
+Symbol *COFFLinkGraphBuilder::createExternalSymbol(
+    COFFSymbolIndex SymIndex, StringRef SymbolName,
+    object::COFFSymbolRef Symbol, const object::coff_section *Section) {
+  if (!ExternalSymbols.count(SymbolName))
+    ExternalSymbols[SymbolName] =
+        &G->addExternalSymbol(SymbolName, Symbol.getValue(), Linkage::Strong);
+
+  LLVM_DEBUG({
+    dbgs() << "    " << SymIndex
+           << ": Creating external graph symbol for COFF symbol \""
+           << SymbolName << "\" in "
+           << getCOFFSectionName(Symbol.getSectionNumber(), Section, Symbol)
+           << " (index: " << Symbol.getSectionNumber() << ") \n";
+  });
+  return ExternalSymbols[SymbolName];
+}
+
+Expected<Symbol *> COFFLinkGraphBuilder::createAliasSymbol(StringRef SymbolName,
+                                                           Linkage L, Scope S,
+                                                           Symbol &Target) {
+  if (!Target.isDefined()) {
+    // FIXME: Support this when there's a way to handle this.
+    return make_error<JITLinkError>("Weak external symbol with external "
+                                    "symbol as alternative not supported.");
+  }
+  return &G->addDefinedSymbol(Target.getBlock(), Target.getOffset(), SymbolName,
+                              Target.getSize(), L, S, Target.isCallable(),
+                              false);
+}
+
 // In COFF, most of the defined symbols don't contain the size information.
 // Hence, we calculate the "implicit" size of symbol by taking the delta of
 // offsets of consecutive symbols within a block. We maintain a balanced tree
 // set of symbols sorted by offset per each block in order to achieve
 // logarithmic time complexity of sorted symbol insertion. Symbol is inserted to
 // the set once it's processed in graphifySymbols. In this function, we iterate
 // each collected symbol in sorted order and calculate the implicit size.
 Error COFFLinkGraphBuilder::calculateImplicitSizeOfSymbols() {
LLVM_DEBUG({
              << "\n";
     });
     return nullptr;
   }
 
   if (Symbol.isExternal()) {
     // This is not a comdat sequence, export the symbol as it is
     if (!isComdatSection(Section)) {
-
-      return &G->addDefinedSymbol(
+      auto GSym = &G->addDefinedSymbol(
           *B, Symbol.getValue(), SymbolName, 0, Linkage::Strong, Scope::Default,
           Symbol.getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION, false);
+      DefinedSymbols[SymbolName] = GSym;
+      return GSym;
     } else {
       if (!PendingComdatExports[Symbol.getSectionNumber()])
         return make_error<JITLinkError>("No pending COMDAT export for symbol " +
                                         formatv("{0:d}", SymIndex));
 
       return exportCOMDATSymbol(SymIndex, SymbolName, Symbol);
     }
   }
COFFLinkGraphBuilder::exportCOMDATSymbol(COFFSymbolIndex SymIndex,
   Target->setScope(Scope::Default);
   LLVM_DEBUG({
     dbgs() << "    " << SymIndex
            << ": Exporting COMDAT graph symbol for COFF symbol \"" << SymbolName
            << "\" in section " << Symbol.getSectionNumber() << "\n";
     dbgs() << "      " << *Target << "\n";
   });
   PendingComdatExport = None;
+  DefinedSymbols[SymbolName] = Target;
   return Target;
 }
 
 } // namespace jitlink
-} // namespace llvm
+} // namespace llvm
 No newline at end of file

llvm/lib/ExecutionEngine/JITLink/COFFOptions.td

+include "llvm/Option/OptParser.td"
+
+// link.exe accepts options starting with either a dash or a slash.
+
+// Flag that takes no arguments.
+class F<string name> : Flag<["/", "-", "/?", "-?"], name>;
+
+// Flag that takes one argument after ":".
+class P<string name> :
+      Joined<["/", "-", "/?", "-?"], name#":">;
+
+// Boolean flag which can be suffixed by ":no". Using it unsuffixed turns the
+// flag on and using it suffixed by ":no" turns it off.
+multiclass B_priv<string name> {
+  def "" : F<name>;
+  def _no : F<name#":no">;
+}
+
+def export  : P<"export">;
+def alternatename : P<"alternatename">;
+def incl : Joined<["/", "-", "/?", "-?"], "include:">;
 No newline at end of file

llvm/test/ExecutionEngine/JITLink/X86/COFF_directive_alternatename.s

+# RUN: llvm-mc -filetype=obj -triple=x86_64-windows-msvc %s -o %t
+# RUN: llvm-jitlink -noexec %t
+#
+# Check object with alternatename directive does not fail, because
+# foo external symbol was resolved to foo_def.
+#
+
+  .text
+  
+  .def   foo_def;
+  .scl  2;
+  .type 32;
+  .endef
+  .globl  foo_def
+  .p2align  4, 0x90
+foo_def:
+  retq
+
+  .def  main;
+  .scl  2;
+  .type 32;
+  .endef
+  .globl  main
+  .p2align  4, 0x90
+main:
+  callq foo
+  retq
+
+.section .drectve,"yn"
+.ascii "/alternatename:foo=foo_def"

llvm/test/ExecutionEngine/JITLink/X86/COFF_directive_alternatename_fail.s

+# RUN: llvm-mc -filetype=obj -triple=x86_64-windows-msvc %s -o %t
+# RUN: not llvm-jitlink -noexec %t 2>&1 | FileCheck %s
+#
+# Check object without alternatename directive fails because of
+# external symbol not found error.
+#
+# CHECK: error: Symbols not found: [ foo ]
+  .text
+  
+  .def   foo_def;
+  .scl  2;
+  .type 32;
+  .endef
+  .globl  foo_def
+  .p2align  4, 0x90
+foo_def:
+  retq
+
+  .def  main;
+  .scl  2;
+  .type 32;
+  .endef
+  .globl  main
+  .p2align  4, 0x90
+main:
+  callq foo
+  retq

llvm/test/ExecutionEngine/JITLink/X86/COFF_directive_include.s

+# RUN: llvm-mc -filetype=obj -triple=x86_64-windows-msvc %s -o %t
+# RUN: not llvm-jitlink -noexec %t 2>&1 | FileCheck %s
+#
+# Check an external symbol "foo" is generated and not dead-stripped
+# because of include directive which turned into symbol not found error.
+#
+# CHECK: error: Symbols not found: [ foo ]
+
+  .text
+
+  .def  main;
+  .scl  2;
+  .type 32;
+  .endef
+  .globl  main
+  .p2align  4, 0x90
+main:
+  retq
+
+  .section .drectve,"yn"
+  .ascii "/include:foo"