Make JITDylib ignore Exported flag

[save-buffer]

Summary

This change addresses an issue with current compatibility with COFF.
COFF lacks an "Exported" flag. When the COFF object file is generated,
ORC compares the flags from the symbol table in the object file to the
flags it expected from the IR. This was incorrect because when
generating a COFF, the Exported flag was never set. This change ignores
it in asserts.

[lhames]

Hi Sasha,

I definitely want this to work on Windows, but this isn't the right way to fix it. Instead, you want to turn on symbol-flag-overrides in the linking layer by calling RTDyldObjectLinkingLayer's (or ObjectLinkingLayer's, if you're using that) setOverrideObjectFlagsWithResponsibilityFlags() method.

If you have a custom JIT stack:

ObjLinkingLayer.setOverrideObjectFlagsWithResponsibilityFlags(true);

should do it.

I will update LLJIT to do this automatically if the target is Windows.

[save-buffer]

Great, thanks!

llvm/lib/ExecutionEngine/Orc/Core.cpp

void MaterializationResponsibility::notifyResolved(const SymbolMap &Symbols) {
   LLVM_DEBUG({
     dbgs() << "In " << JD.getName() << " resolving " << Symbols << "\n";
   });
 #ifndef NDEBUG
   for (auto &KV : Symbols) {
     auto I = SymbolFlags.find(KV.first);
     assert(I != SymbolFlags.end() &&
            "Resolving symbol outside this responsibility set");
+    // Mask out Exported for compatibility with COFF
+    constexpr auto Mask = ~JITSymbolFlags::Exported;
     if (I->second.isWeak())
-      assert(I->second == (KV.second.getFlags() | JITSymbolFlags::Weak) &&
+      assert((I->second & Mask) == ((KV.second.getFlags() | JITSymbolFlags::Weak) & Mask) &&
              "Resolving symbol with incorrect flags");
     else
-      assert(I->second == KV.second.getFlags() &&
+      assert((I->second & Mask) == (KV.second.getFlags() & Mask) &&
              "Resolving symbol with incorrect flags");
   }
 #endif
 
   JD.resolve(Symbols);
 }
 
 void MaterializationResponsibility::notifyEmitted() {
for (const auto &KV : Resolved) {
 
       assert(I != Symbols.end() && "Symbol not found");
       assert(!I->second.hasMaterializerAttached() &&
              "Resolving symbol with materializer attached?");
       assert(I->second.getState() == SymbolState::Materializing &&
              "Symbol should be materializing");
       assert(I->second.getAddress() == 0 && "Symbol has already been resolved");
 
-      assert((Sym.getFlags() & ~JITSymbolFlags::Weak) ==
-                 (I->second.getFlags() & ~JITSymbolFlags::Weak) &&
+      // Mask out Exported flag for compatibility with COFF
+      constexpr auto Mask = ~(JITSymbolFlags::Weak | JITSymbolFlags::Exported);
+      assert((Sym.getFlags() & Mask) ==
+                 (I->second.getFlags() & Mask) &&
              "Resolved flags should match the declared flags");
 
       // Once resolved, symbols can never be weak.
-      JITSymbolFlags ResolvedFlags = Sym.getFlags();
+      // IMPORTANT: We use I->second.getFlags() because we want
+      //            to reuse the flags from the original IR. Some
+      //            object file formats like COFF don't have an
+      //            exported flag, for example, so we want to preserve
+      //            IR flags.
+      JITSymbolFlags ResolvedFlags = I->second.getFlags();
       ResolvedFlags &= ~JITSymbolFlags::Weak;
       I->second.setAddress(Sym.getAddress());
       I->second.setFlags(ResolvedFlags);
       I->second.setState(SymbolState::Resolved);
 
       auto &MI = MaterializingInfos[Name];
       for (auto &Q : MI.takeQueriesMeeting(SymbolState::Resolved)) {
         Q->notifySymbolMetRequiredState(Name, Sym);