Linker: Mark non-prevailing dllexport symbols as exported with a linker flag.

[pcc]

Summary

Fixes PR32334.

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

void emitModuleMetadata(MCStreamer &Streamer, Module &M,
                           const TargetMachine &TM) const override;
 
   MCSection *getStaticCtorSection(unsigned Priority,
                                   const MCSymbol *KeySym) const override;
   MCSection *getStaticDtorSection(unsigned Priority,
                                   const MCSymbol *KeySym) const override;
 
   void emitLinkerFlagsForGlobal(raw_ostream &OS,
-                                const GlobalValue *GV) const override;
+                                const GlobalValue *GV) const;
 };
 
 class TargetLoweringObjectFileWasm : public TargetLoweringObjectFile {
   mutable unsigned NextUniqueID = 0;
 
 public:
   TargetLoweringObjectFileWasm() = default;
   ~TargetLoweringObjectFileWasm() override = default;
public:
 
   void InitializeWasm();
 
   const MCExpr *lowerRelativeReference(const GlobalValue *LHS,
                                        const GlobalValue *RHS,
                                        const TargetMachine &TM) const override;
 };
 
-void emitLinkerFlagsForGlobalCOFF(raw_ostream &OS, const GlobalValue *GV,
-                                  const Triple &TT, Mangler &Mangler);
-
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_TARGETLOWERINGOBJECTFILEIMPL_H

llvm/include/llvm/IR/Mangler.h

void getNameWithPrefix(SmallVectorImpl<char> &OutName, const GlobalValue *GV,
                          bool CannotUsePrivateLabel) const;
 
   /// Print the appropriate prefix and the specified name as the global variable
   /// name. GVName must not be empty.
   static void getNameWithPrefix(raw_ostream &OS, const Twine &GVName,
                                 const DataLayout &DL);
   static void getNameWithPrefix(SmallVectorImpl<char> &OutName,
                                 const Twine &GVName, const DataLayout &DL);
+
+  /// Print an appropriate linker flag for exporting this symbol on COFF
+  /// targets.
+  void getCOFFDLLExportLinkerFlag(raw_ostream &OS, const GlobalValue *GV);
 };
 
 } // End llvm namespace
 
 #endif

llvm/include/llvm/Target/TargetLoweringObjectFile.h

public:
   virtual const MCExpr *getIndirectSymViaGOTPCRel(const MCSymbol *Sym,
                                                   const MCValue &MV,
                                                   int64_t Offset,
                                                   MachineModuleInfo *MMI,
                                                   MCStreamer &Streamer) const {
     return nullptr;
   }
 
-  virtual void emitLinkerFlagsForGlobal(raw_ostream &OS,
-                                        const GlobalValue *GV) const {}
-
 protected:
   virtual MCSection *SelectSectionForGlobal(const GlobalObject *GO,
                                             SectionKind Kind,
                                             const TargetMachine &TM) const = 0;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_TARGET_TARGETLOWERINGOBJECTFILE_H

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

if (ComdatKey == GV) {
       }
     } else {
       return COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE;
     }
   }
   return 0;
 }
 
-void llvm::emitLinkerFlagsForGlobalCOFF(raw_ostream &OS, const GlobalValue *GV,
-                                        const Triple &TT, Mangler &Mangler) {
-  if (!GV->hasDLLExportStorageClass() || GV->isDeclaration())
-    return;
-
-  if (TT.isKnownWindowsMSVCEnvironment())
-    OS << " /EXPORT:";
-  else
-    OS << " -export:";
-
-  if (TT.isWindowsGNUEnvironment() || TT.isWindowsCygwinEnvironment()) {
-    std::string Flag;
-    raw_string_ostream FlagOS(Flag);
-    Mangler.getNameWithPrefix(FlagOS, GV, false);
-    FlagOS.flush();
-    if (Flag[0] == GV->getParent()->getDataLayout().getGlobalPrefix())
-      OS << Flag.substr(1);
-    else
-      OS << Flag;
-  } else {
-    Mangler.getNameWithPrefix(OS, GV, false);
-  }
-
-  if (!GV->getValueType()->isFunctionTy()) {
-    if (TT.isKnownWindowsMSVCEnvironment())
-      OS << ",DATA";
-    else
-      OS << ",data";
-  }
-}
-
 MCSection *TargetLoweringObjectFileCOFF::getExplicitSectionGlobal(
     const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const {
   int Selection = 0;
   unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
   StringRef Name = GO->getSection();
   StringRef COMDATSymName = "";
   if (GO->hasComdat()) {
     Selection = getSelectionForCOFF(GO);

 MCSection *TargetLoweringObjectFileCOFF::getStaticDtorSection(
     unsigned Priority, const MCSymbol *KeySym) const {
   return getContext().getAssociativeCOFFSection(
       cast<MCSectionCOFF>(StaticDtorSection), KeySym, 0);
 }
 
 void TargetLoweringObjectFileCOFF::emitLinkerFlagsForGlobal(
     raw_ostream &OS, const GlobalValue *GV) const {
-  emitLinkerFlagsForGlobalCOFF(OS, GV, getTargetTriple(), getMangler());
+  Mangler Mang;
+  Mang.getCOFFDLLExportLinkerFlag(OS, GV);
 }
 
 //===----------------------------------------------------------------------===//
 //                                  Wasm
 //===----------------------------------------------------------------------===//
 
 static const Comdat *getWasmComdat(const GlobalValue *GV) {
   const Comdat *C = GV->getComdat();

llvm/lib/IR/Mangler.cpp

 //===-- Mangler.cpp - Self-contained c/asm llvm name mangler --------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Unified name mangler for assembly backends.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/Mangler.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/Triple.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 

 }
 
 void Mangler::getNameWithPrefix(SmallVectorImpl<char> &OutName,
                                 const GlobalValue *GV,
                                 bool CannotUsePrivateLabel) const {
   raw_svector_ostream OS(OutName);
   getNameWithPrefix(OS, GV, CannotUsePrivateLabel);
 }
+
+void Mangler::getCOFFDLLExportLinkerFlag(raw_ostream &OS,
+                                         const GlobalValue *GV) {
+  if (!GV->hasDLLExportStorageClass() || GV->isDeclaration())
+    return;
+
+  Triple TT(GV->getParent()->getTargetTriple());
+  if (TT.isKnownWindowsMSVCEnvironment())
+    OS << " /EXPORT:";
+  else
+    OS << " -export:";
+
+  if (TT.isWindowsGNUEnvironment() || TT.isWindowsCygwinEnvironment()) {
+    std::string Flag;
+    raw_string_ostream FlagOS(Flag);
+    getNameWithPrefix(FlagOS, GV, false);
+    FlagOS.flush();
+    if (Flag[0] == GV->getParent()->getDataLayout().getGlobalPrefix())
+      OS << Flag.substr(1);
+    else
+      OS << Flag;
+  } else {
+    getNameWithPrefix(OS, GV, false);
+  }
+
+  if (!GV->getValueType()->isFunctionTy()) {
+    if (TT.isKnownWindowsMSVCEnvironment())
+      OS << ",DATA";
+    else
+      OS << ",data";
+  }
+}

llvm/lib/LTO/LTO.cpp

for (InputModule &Mod : Mods) {
     }
   }
 
   // Synthesize export flags for symbols with dllexport storage.
   const Triple TT(Mods[0].Mod->getTargetTriple());
   Mangler M;
   for (const ModuleSymbolTable::Symbol &Sym : SymTab.symbols())
     if (auto *GV = Sym.dyn_cast<GlobalValue*>())
-      emitLinkerFlagsForGlobalCOFF(LOS, GV, TT, M);
+      M.getCOFFDLLExportLinkerFlag(LOS, GV);
   LOS.flush();
   return LinkerOpts;
 }
 
 StringRef InputFile::getName() const {
   return Mods[0].BM.getModuleIdentifier();
 }
 

llvm/lib/LTO/LTOModule.cpp

void LTOModule::parseMetadata() {
   // Globals - we only need to do this for COFF.
   const Triple TT(_target->getTargetTriple());
   if (!TT.isOSBinFormatCOFF())
     return;
   Mangler M;
   for (const NameAndAttributes &Sym : _symbols) {
     if (!Sym.symbol)
       continue;
-    emitLinkerFlagsForGlobalCOFF(OS, Sym.symbol, TT, M);
+    M.getCOFFDLLExportLinkerFlag(OS, Sym.symbol);
   }
 
   // Add other interesting metadata here.
 }

llvm/lib/Linker/IRMover.cpp

 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/GVMaterializer.h"
 #include "llvm/IR/Intrinsics.h"
+#include "llvm/IR/Mangler.h"
 #include "llvm/IR/TypeFinder.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include <utility>
 using namespace llvm;
 
 //===----------------------------------------------------------------------===//
 // TypeMap implementation.
class IRLinker {
   Function *copyFunctionProto(const Function *SF);
   GlobalValue *copyGlobalAliasProto(const GlobalAlias *SGA);
 
   /// When importing for ThinLTO, prevent importing of types listed on
   /// the DICompileUnit that we don't need a copy of in the importing
   /// module.
   void prepareCompileUnitsForImport();
   void linkNamedMDNodes();
+  void linkCOFFDLLExportFlags();
 
 public:
   IRLinker(Module &DstM, MDMapT &SharedMDs,
            IRMover::IdentifiedStructTypeSet &Set, std::unique_ptr<Module> SrcM,
            ArrayRef<GlobalValue *> ValuesToLink,
            std::function<void(GlobalValue &, IRMover::ValueAdder)> AddLazyFor,
            bool IsPerformingImport)
       : DstM(DstM), SrcM(std::move(SrcM)), AddLazyFor(std::move(AddLazyFor)),
if (&NMD == SrcModFlags)
       continue;
     NamedMDNode *DestNMD = DstM.getOrInsertNamedMetadata(NMD.getName());
     // Add Src elements into Dest node.
     for (const MDNode *Op : NMD.operands())
       DestNMD->addOperand(Mapper.mapMDNode(*Op));
   }
 }
 
+/// COFF-specific: link dropped dllexport flags into DstM using metadata.
+void IRLinker::linkCOFFDLLExportFlags() {
+  auto *MD = DstM.getOrInsertNamedMetadata("llvm.linker.options");
+  Mangler Mang;
+  auto LinkFlag = [&](GlobalValue *GV) {
+    if (!GV->hasDLLExportStorageClass() || GV->isDeclaration() ||
+        ValuesToLink.count(GV))
+      return;
+
+    std::string Flag;
+    raw_string_ostream OS(Flag);
+    Mang.getCOFFDLLExportLinkerFlag(OS, GV);
+    MD->addOperand(MDNode::get(GV->getContext(),
+                               {MDString::get(GV->getContext(), OS.str())}));
+  };
+
+  for (auto &F : *SrcM)
+    LinkFlag(&F);
+  for (auto &GV : SrcM->globals())
+    LinkFlag(&GV);
+  for (auto &GA : SrcM->aliases())
+    LinkFlag(&GA);
+}
+
 /// Merge the linker flags in Src into the Dest module.
 Error IRLinker::linkModuleFlagsMetadata() {
   // If the source module has no module flags, we are done.
   const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata();
   if (!SrcModFlags)
     return Error::success();
 
   // If the destination module doesn't have module flags yet, then just copy
Error IRLinker::run() {
   DoneLinkingBodies = true;
   Mapper.addFlags(RF_NullMapMissingGlobalValues);
 
   // Remap all of the named MDNodes in Src into the DstM module. We do this
   // after linking GlobalValues so that MDNodes that reference GlobalValues
   // are properly remapped.
   linkNamedMDNodes();
 
+  // COFF-specific: link dropped dllexport flags into DstM.
+  if (SrcTriple.isOSBinFormatCOFF())
+    linkCOFFDLLExportFlags();
+
   // Merge the module flags into the DstM module.
   return linkModuleFlagsMetadata();
 }
 
 IRMover::StructTypeKeyInfo::KeyTy::KeyTy(ArrayRef<Type *> E, bool P)
     : ETypes(E), IsPacked(P) {}
 
 IRMover::StructTypeKeyInfo::KeyTy::KeyTy(const StructType *ST)

llvm/test/LTO/Resolution/X86/dllexport.ll

+; RUN: llvm-as %s -o %t.o
+; RUN: llvm-lto2 -o %t2.o %t.o -r %t.o,f,x -r %t.o,g,x -r %t.o,a,x -save-temps
+; RUN: llvm-dis < %t2.o.0.0.preopt.bc -o - | FileCheck %s
+
+; CHECK-NOT: alias
+; CHECK-NOT: global
+; CHECK-NOT: void
+
+; CHECK: !llvm.linker.options = !{!0, !1, !2}
+; CHECK: !0 = !{!" /EXPORT:f"}
+; CHECK: !1 = !{!" /EXPORT:g,DATA"}
+; CHECK: !2 = !{!" /EXPORT:a,DATA"}
+
+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc"
+
+@a = dllexport alias i8, i8* @g
+
+@g = dllexport global i8 0
+
+define dllexport void @f() {
+  ret void
+}