[wip] IR: Move linker options to top-level global metadata and remove dllexport storage class.

[pcc]

Summary

dllexport is not actually a global-level attribute. At the object file
level, it is in fact a module-level attribute and is represented with an
/export flag in the directive section. Trying to shoehorn it into being a
global-level attribute creates unnecessary complexity and a burden on the
rest of the compiler and invites bugs.

Independent of whether it is a global- or module-level attribute, it makes
sense to split dllimport from dllexport, as they are somewhat orthogonal. The
meaning of dllexport is similar to ELF symbol visibility, while the meaning
of dllimport is closer to preemptability (see also D20217). With this,
dllimport can potentially receive a meaning in other object formats without
being in the confusing situation where dllexport only has meaning for COFF
and dllimport also has meaning elsewhere.

This patch does three things:

• Moves the linker options from a module flag to top-level module metadata. Storing it as a module flag only makes it harder to manipulate the linker options.
• Causes clang to add an /export flag to the linker options metadata if it is emitting a definition that will be dllexported.
• Removes the dllexport storage class and stores dllimport as a boolean.

Test cases to be updated.

Fixes PR32334.

[rnk]

I'm opposed to getting rid of the dllexport bit on GlobalValue, and so far on the bug, both @majnemer and @rjmccall seem to be opposed to it as well. I also asked @chandlerc about it in person, and he wasn't in favor, although I'm not sure how strong his opinion was.

This change simplifies the job of the COFF linker because it makes the IR more like a COFF object, so I see why it's appealing. I want to rehash what I was saying about LLVM being more than just an object file format, though. LLVM is supposed to be a library. This stands in opposition to the design philosophy of LLD ELF & COFF. LLVM IR is supposed to be an intermediate representation useful for a wide variety of use cases: optimization, symbolic execution, instrumentation, and things we haven't thought of. Maintaining exports in a separate linker flag list makes it hard for these tools to determine which things are exported. Obviously, such tools can never know the true list of exports until link time, but I argue that it is useful for tools to know if *some* things are exported and have workarounds for the rest. You could argue that this is inviting bugs and such a tool needs link time information to be robust, but I'd argue that in practice it's a lot easier to do things at compile time than link time.

As a minor concern, the new representation is less efficient. We would now store mangled symbol names in one more place than we do now before, which might be significant. It seems nice to delay construction of the .drective section until after memory used by ISel has been freed.

Lastly, this is a minor bug in /msvclto, a feature that is only intended to exist until LLD can write PDBs. I feel like it just doesn't justify a representation change. Yes, LLVM IR is not cast in stone and of course should be changed to fix bugs and add features, but there is still a small cost to changing it.

---

I am in favor of moving "Linker Options" to "llvm.linker.options" if you want to do that separately.

[pcc]

Maintaining exports in a separate linker flag list makes it hard for these tools to determine which things are exported.

Only barely: such a (hypothetical) tool can easily enough parse the linker options list.

Lastly, this is a minor bug in /msvclto, a feature that is only intended to exist until LLD can write PDBs. I feel like it just doesn't justify a representation change.

The alternatives that were discussed on the bug were also representational changes, and imposed new burdens on passes. That seems less justifiable for the sake of the /msvclto feature.

[pcc]

It occurred to me that this bug would also affect ThinLTO distributed builds if they work in the same way as they do with gold. The scenario is pretty much the same: distributed backend processes perform LTO and create native object files that are fed into a separate linker process that performs the final link.

[rjmccall]

This is a very disruptive change — it completely changes the IR model for dllexport, thus breaking every single frontend that targets Windows. LLVM should care about the impact on out-of-tree frontends. And I'm not worried about Swift here, because we've got a very motivated community; I'm worried about the dozens of other random language frontends that maintain a Windows port.

Furthermore, by your account, this isn't even the representation we want to end up with. In the long term, we should completely fold dllimport and dllexport into symbol visibility. So you're talking about breaking every Windows frontend twice, for some corner case that doesn't really matter to the vast majority of frontends.

I'm willing to accept your argument that attaching extra meaning to declarations is also disruptive. Fine. The obvious compromise position that doesn't involve completely changing how every Windows frontend works is to take your global metadata idea and have it be an opt-in feature usable on an arbitrary symbol name. But right now, you are proposing a breaking change to IR that will make extra work for a ton of frontend authors, purely for the implementation convenience of the LTO linker. That is not an appropriate trade-off.

[pcc]

Furthermore, by your account, this isn't even the representation we want to end up with. In the long term, we should completely fold dllimport and dllexport into symbol visibility.

That isn't really my position though. dllexport is similar to symbol visibility, but does not have the same merging semantics (see discussion with Rafael). dllimport can be seen as orthogonal to visibility, but I imagine that one possible alternative to D20217 would be to create a visibility that means "default but known DSO-local". So I can understand your perspective with regard to dllimport at least.

The obvious compromise position that doesn't involve completely changing how every Windows frontend works is to take your global metadata idea and have it be an opt-in feature usable on an arbitrary symbol name.

I think that would at least move us in the right direction. I will try changing the IRMover to create metadata for each dllexport symbol that is not linked into the target module.

[rjmccall]

In D31270#710079, @pcc wrote:

Furthermore, by your account, this isn't even the representation we want to end up with. In the long term, we should completely fold dllimport and dllexport into symbol visibility.

That isn't really my position though. dllexport is similar to symbol visibility, but does not have the same merging semantics (see discussion with Rafael).

It doesn't have the same merging semantics *as ELF*. Mach-O uses the maximum visibility, the same as dllexport.

dllimport can be seen as orthogonal to visibility, but I imagine that one possible alternative to D20217 would be to create a visibility that means "default but known DSO-local". So I can understand your perspective with regard to dllimport at least.

FWIW, you can hack around the lack of that visibility today by putting "hidden" on declarations and "default" on definitions. Of course, this trick only works on strong definitions, and it relies on the IR linker discarding declarations without merging visibility, but it does work. It would be better to have that explicit, though.

[pcc]

Sent D31349 and D31352 which implement what we decided on here.

clang/lib/CodeGen/CGBlocks.cpp

if (CGM.getTarget().getTriple().isOSBinFormatCOFF()) {
     const NamedDecl *ND = nullptr;
     for (const auto &Result : DC->lookup(&II))
       if ((ND = dyn_cast<FunctionDecl>(Result)) ||
           (ND = dyn_cast<VarDecl>(Result)))
         break;
 
     // TODO: support static blocks runtime
     if (GV->isDeclaration() && (!ND || !ND->hasAttr<DLLExportAttr>())) {
-      GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
+      GV->setDLLImport(true);
       GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
     } else {
-      GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
       GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
     }
   }
 
   if (!CGM.getLangOpts().BlocksRuntimeOptional)
     return;
 
   if (GV->isDeclaration() && GV->hasExternalLinkage())

clang/lib/CodeGen/CGDecl.cpp

llvm::Constant *CodeGenModule::getOrCreateStaticVarDecl(
   if (supportsCOMDAT() && GV->isWeakForLinker())
     GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
 
   if (D.getTLSKind())
     setTLSMode(GV, D);
 
   if (D.isExternallyVisible()) {
     if (D.hasAttr<DLLImportAttr>())
-      GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
+      GV->setDLLImport(true);
     else if (D.hasAttr<DLLExportAttr>())
-      GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
+      GV->addDLLExportFlag();
   }
 
   // Make sure the result is of the correct type.
   unsigned ExpectedAddrSpace = getContext().getTargetAddressSpace(Ty);
   llvm::Constant *Addr = GV;
   if (AddrSpace != ExpectedAddrSpace) {
     llvm::PointerType *PTy = llvm::PointerType::get(LTy, ExpectedAddrSpace);
     Addr = llvm::ConstantExpr::getAddrSpaceCast(GV, PTy);

clang/lib/CodeGen/CGObjCGNU.cpp

 // This has to perform the lookup every time, since posing and related
 // techniques can modify the name -> class mapping.
 llvm::Value *CGObjCGNU::GetClass(CodeGenFunction &CGF,
                                  const ObjCInterfaceDecl *OID) {
   auto *Value =
       GetClassNamed(CGF, OID->getNameAsString(), OID->isWeakImported());
   if (CGM.getTriple().isOSBinFormatCOFF()) {
     if (auto *ClassSymbol = dyn_cast<llvm::GlobalVariable>(Value)) {
-      auto DLLStorage = llvm::GlobalValue::DefaultStorageClass;
       if (OID->hasAttr<DLLExportAttr>())
-        DLLStorage = llvm::GlobalValue::DLLExportStorageClass;
+        ClassSymbol->addDLLExportFlag();
       else if (OID->hasAttr<DLLImportAttr>())
-        DLLStorage = llvm::GlobalValue::DLLImportStorageClass;
-      ClassSymbol->setDLLStorageClass(DLLStorage);
+        ClassSymbol->setDLLImport(true);
     }
   }
   return Value;
 }
 
 llvm::Value *CGObjCGNU::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
   auto *Value  = GetClassNamed(CGF, "NSAutoreleasePool", false);
   if (CGM.getTriple().isOSBinFormatCOFF()) {
     if (auto *ClassSymbol = dyn_cast<llvm::GlobalVariable>(Value)) {
       IdentifierInfo &II = CGF.CGM.getContext().Idents.get("NSAutoreleasePool");
       TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl();
       DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);
 
       const VarDecl *VD = nullptr;
       for (const auto &Result : DC->lookup(&II))
         if ((VD = dyn_cast<VarDecl>(Result)))
           break;
 
-      auto DLLStorage = llvm::GlobalValue::DefaultStorageClass;
       if (!VD || VD->hasAttr<DLLImportAttr>())
-        DLLStorage = llvm::GlobalValue::DLLImportStorageClass;
+        ClassSymbol->setDLLImport(true);
       else if (VD->hasAttr<DLLExportAttr>())
-        DLLStorage = llvm::GlobalValue::DLLExportStorageClass;
-
-      ClassSymbol->setDLLStorageClass(DLLStorage);
+        ClassSymbol->addDLLExportFlag();
     }
   }
   return Value;
 }
 
 llvm::Value *CGObjCGNU::GetSelector(CodeGenFunction &CGF, Selector Sel,
                                     const std::string &TypeEncoding) {
   SmallVectorImpl<TypedSelector> &Types = SelectorTable[Sel];
void CGObjCGNU::GenerateClass(const ObjCImplementationDecl *OID) {
   llvm::Constant *ZeroPtr = llvm::ConstantInt::get(IntPtrTy, 0);
 
   //Generate metaclass for class methods
   llvm::Constant *MetaClassStruct = GenerateClassStructure(
       NULLPtr, NULLPtr, 0x12L, ClassName.c_str(), nullptr, Zeros[0],
       GenerateIvarList(empty, empty, empty), ClassMethodList, NULLPtr, NULLPtr,
       NULLPtr, ZeroPtr, ZeroPtr, true);
   if (CGM.getTriple().isOSBinFormatCOFF()) {
-    auto Storage = llvm::GlobalValue::DefaultStorageClass;
     if (OID->getClassInterface()->hasAttr<DLLImportAttr>())
-      Storage = llvm::GlobalValue::DLLImportStorageClass;
+      cast<llvm::GlobalValue>(MetaClassStruct)
+          ->setDLLImport(true);
     else if (OID->getClassInterface()->hasAttr<DLLExportAttr>())
-      Storage = llvm::GlobalValue::DLLExportStorageClass;
-    cast<llvm::GlobalValue>(MetaClassStruct)->setDLLStorageClass(Storage);
+      cast<llvm::GlobalValue>(MetaClassStruct)->addDLLExportFlag();
   }
 
   // Generate the class structure
   llvm::Constant *ClassStruct = GenerateClassStructure(
       MetaClassStruct, SuperClass, 0x11L, ClassName.c_str(), nullptr,
       llvm::ConstantInt::get(LongTy, instanceSize), IvarList, MethodList,
       GenerateProtocolList(Protocols), IvarOffsetArray, Properties,
       StrongIvarBitmap, WeakIvarBitmap);
   if (CGM.getTriple().isOSBinFormatCOFF()) {
-    auto Storage = llvm::GlobalValue::DefaultStorageClass;
     if (OID->getClassInterface()->hasAttr<DLLImportAttr>())
-      Storage = llvm::GlobalValue::DLLImportStorageClass;
+      cast<llvm::GlobalValue>(MetaClassStruct)
+          ->setDLLImport(true);
     else if (OID->getClassInterface()->hasAttr<DLLExportAttr>())
-      Storage = llvm::GlobalValue::DLLExportStorageClass;
-    cast<llvm::GlobalValue>(ClassStruct)->setDLLStorageClass(Storage);
+      cast<llvm::GlobalValue>(MetaClassStruct)->addDLLExportFlag();
   }
 
   // Resolve the class aliases, if they exist.
   if (ClassPtrAlias) {
     ClassPtrAlias->replaceAllUsesWith(
         llvm::ConstantExpr::getBitCast(ClassStruct, IdTy));
     ClassPtrAlias->eraseFromParent();
     ClassPtrAlias = nullptr;

clang/lib/CodeGen/CGObjCMac.cpp

void CGObjCNonFragileABIMac::GetClassSizeInfo(const ObjCImplementationDecl *OID,
 
   // If there are no fields, the start is the same as the end.
   if (!RL.getFieldCount())
     InstanceStart = InstanceSize;
   else
     InstanceStart = RL.getFieldOffset(0) / CGM.getContext().getCharWidth();
 }
 
-static llvm::GlobalValue::DLLStorageClassTypes getStorage(CodeGenModule &CGM,
-                                                          StringRef Name) {
-  IdentifierInfo &II = CGM.getContext().Idents.get(Name);
+static void setDLLStorage(CodeGenModule &CGM, llvm::GlobalValue *GV) {
+  IdentifierInfo &II = CGM.getContext().Idents.get(GV->getName());
   TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl();
   DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);
 
   const VarDecl *VD = nullptr;
   for (const auto &Result : DC->lookup(&II))
     if ((VD = dyn_cast<VarDecl>(Result)))
       break;
 
-  if (!VD)
-    return llvm::GlobalValue::DLLImportStorageClass;
-  if (VD->hasAttr<DLLExportAttr>())
-    return llvm::GlobalValue::DLLExportStorageClass;
-  if (VD->hasAttr<DLLImportAttr>())
-    return llvm::GlobalValue::DLLImportStorageClass;
-  return llvm::GlobalValue::DefaultStorageClass;
+  if (!VD) {
+    GV->setDLLImport(true);
+    return;
+  }
+  if (VD->hasAttr<DLLExportAttr>()) {
+    GV->addDLLExportFlag();
+    return;
+  }
+  if (VD->hasAttr<DLLImportAttr>()) {
+    GV->setDLLImport(true);
+    return;
+  }
 }
 
 void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) {
   if (!ObjCEmptyCacheVar) {
     ObjCEmptyCacheVar =
         new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.CacheTy, false,
                                  llvm::GlobalValue::ExternalLinkage, nullptr,
                                  "_objc_empty_cache");
     if (CGM.getTriple().isOSBinFormatCOFF())
-      ObjCEmptyCacheVar->setDLLStorageClass(getStorage(CGM, "_objc_empty_cache"));
+      setDLLStorage(CGM, ObjCEmptyCacheVar);
 
     // Only OS X with deployment version <10.9 use the empty vtable symbol
     const llvm::Triple &Triple = CGM.getTarget().getTriple();
     if (Triple.isMacOSX() && Triple.isMacOSXVersionLT(10, 9))
       ObjCEmptyVtableVar =
           new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ImpnfABITy, false,
                                    llvm::GlobalValue::ExternalLinkage, nullptr,
                                    "_objc_empty_vtable");
void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) {
   llvm::GlobalVariable *CLASS_RO_GV =
       BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID);
 
   llvm::GlobalVariable *MetaTClass =
     BuildClassObject(CI, /*metaclass*/ true,
                      IsAGV, SuperClassGV, CLASS_RO_GV, classIsHidden);
   if (CGM.getTriple().isOSBinFormatCOFF())
     if (CI->hasAttr<DLLExportAttr>())
-      MetaTClass->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
+      MetaTClass->addDLLExportFlag();
   DefinedMetaClasses.push_back(MetaTClass);
 
   // Metadata for the class
   flags = 0;
   if (classIsHidden)
     flags |= NonFragileABI_Class_Hidden;
 
   if (ID->hasNonZeroConstructors() || ID->hasDestructors()) {
void CGObjCNonFragileABIMac::GenerateClass(const ObjCImplementationDecl *ID) {
   CLASS_RO_GV =
       BuildClassRoTInitializer(flags, InstanceStart, InstanceSize, ID);
 
   llvm::GlobalVariable *ClassMD =
     BuildClassObject(CI, /*metaclass*/ false,
                      MetaTClass, SuperClassGV, CLASS_RO_GV, classIsHidden);
   if (CGM.getTriple().isOSBinFormatCOFF())
     if (CI->hasAttr<DLLExportAttr>())
-      ClassMD->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
+      ClassMD->addDLLExportFlag();
   DefinedClasses.push_back(ClassMD);
   ImplementedClasses.push_back(CI);
 
   // Determine if this class is also "non-lazy".
   if (ImplementationIsNonLazy(ID))
     DefinedNonLazyClasses.push_back(ClassMD);
 
   // Force the definition of the EHType if necessary.
IvarOffsetGV =
                                  false, llvm::GlobalValue::ExternalLinkage,
                                  nullptr, Name.str());
     if (CGM.getTriple().isOSBinFormatCOFF()) {
       bool IsPrivateOrPackage =
           Ivar->getAccessControl() == ObjCIvarDecl::Private ||
           Ivar->getAccessControl() == ObjCIvarDecl::Package;
 
       if (ID->hasAttr<DLLExportAttr>() && !IsPrivateOrPackage)
-        IvarOffsetGV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
+        IvarOffsetGV->addDLLExportFlag();
       else if (ID->hasAttr<DLLImportAttr>())
-        IvarOffsetGV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
+        IvarOffsetGV->setDLLImport(true);
     }
   }
   return IvarOffsetGV;
 }
 
 llvm::Constant *
 CGObjCNonFragileABIMac::EmitIvarOffsetVar(const ObjCInterfaceDecl *ID,
                                           const ObjCIvarDecl *Ivar,
CGObjCNonFragileABIMac::GetClassGlobal(StringRef Name,
 
 
   llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
   if (!GV) {
     GV = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.ClassnfABITy,
                                   false, L, nullptr, Name);
 
     if (DLLImport)
-      GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
+      GV->setDLLImport(true);
   }
 
   assert(GV->getLinkage() == L);
   return GV;
 }
 
 llvm::Value *
 CGObjCNonFragileABIMac::EmitClassRefFromId(CodeGenFunction &CGF,
CGObjCNonFragileABIMac::GetEHType(QualType T) {
   if (T->isObjCIdType() || T->isObjCQualifiedIdType()) {
     auto *IDEHType = CGM.getModule().getGlobalVariable("OBJC_EHTYPE_id");
     if (!IDEHType) {
       IDEHType =
           new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy, false,
                                    llvm::GlobalValue::ExternalLinkage, nullptr,
                                    "OBJC_EHTYPE_id");
       if (CGM.getTriple().isOSBinFormatCOFF())
-        IDEHType->setDLLStorageClass(getStorage(CGM, "OBJC_EHTYPE_id"));
+        setDLLStorage(CGM, IDEHType);
     }
     return IDEHType;
   }
 
   // All other types should be Objective-C interface pointer types.
   const ObjCObjectPointerType *PT = T->getAs<ObjCObjectPointerType>();
   assert(PT && "Invalid @catch type.");
 
if (!IsForDefinition) {
     // attribute, emit an external reference.
     if (hasObjCExceptionAttribute(CGM.getContext(), ID)) {
       std::string EHTypeName = ("OBJC_EHTYPE_$_" + ClassName).str();
       Entry = new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.EHTypeTy,
                                        false, llvm::GlobalValue::ExternalLinkage,
                                        nullptr, EHTypeName);
       if (CGM.getTriple().isOSBinFormatCOFF()) {
         if (ID->hasAttr<DLLExportAttr>())
-          Entry->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
+          Entry->addDLLExportFlag();
         else if (ID->hasAttr<DLLImportAttr>())
-          Entry->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
+          Entry->setDLLImport(true);
       }
       return Entry;
     }
   }
 
   // Otherwise we need to either make a new entry or fill in the initializer.
   assert((!Entry || !Entry->hasInitializer()) && "Duplicate EHType definition");
 
   std::string VTableName = "objc_ehtype_vtable";
   auto *VTableGV = CGM.getModule().getGlobalVariable(VTableName);
   if (!VTableGV) {
     VTableGV =
         new llvm::GlobalVariable(CGM.getModule(), ObjCTypes.Int8PtrTy, false,
                                  llvm::GlobalValue::ExternalLinkage, nullptr,
                                  VTableName);
     if (CGM.getTriple().isOSBinFormatCOFF())
-      VTableGV->setDLLStorageClass(getStorage(CGM, VTableName));
+      setDLLStorage(CGM, VTableGV);
   }
 
   llvm::Value *VTableIdx = llvm::ConstantInt::get(CGM.Int32Ty, 2);
   ConstantInitBuilder builder(CGM);
   auto values = builder.beginStruct(ObjCTypes.EHTypeTy);
   values.add(llvm::ConstantExpr::getGetElementPtr(VTableGV->getValueType(),
                                                   VTableGV, VTableIdx));
   values.add(GetClassName(ClassName));
   values.add(GetClassGlobal(ID, /*metaclass*/ false, NotForDefinition));
 
   llvm::GlobalValue::LinkageTypes L = IsForDefinition
                                           ? llvm::GlobalValue::ExternalLinkage
                                           : llvm::GlobalValue::WeakAnyLinkage;
   if (Entry) {
     values.finishAndSetAsInitializer(Entry);
     Entry->setAlignment(CGM.getPointerAlign().getQuantity());
   } else {
     Entry = values.finishAndCreateGlobal("OBJC_EHTYPE_$_" + ClassName,
                                          CGM.getPointerAlign(),
                                          /*constant*/ false,
                                          L);
     if (CGM.getTriple().isOSBinFormatCOFF())
       if (hasObjCExceptionAttribute(CGM.getContext(), ID))
         if (ID->hasAttr<DLLExportAttr>())
-          Entry->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
+          Entry->addDLLExportFlag();
   }
   assert(Entry->getLinkage() == L);
 
   if (!CGM.getTriple().isOSBinFormatCOFF())
     if (ID->getVisibility() == HiddenVisibility)
       Entry->setVisibility(llvm::GlobalValue::HiddenVisibility);
 
   if (IsForDefinition)

clang/lib/CodeGen/CodeGenModule.h

private:
   /// \brief The complete set of modules that has been imported.
   llvm::SetVector<clang::Module *> ImportedModules;
 
   /// \brief The set of modules for which the module initializers
   /// have been emitted.
   llvm::SmallPtrSet<clang::Module *, 16> EmittedModuleInitializers;
 
   /// \brief A vector of metadata strings.
-  SmallVector<llvm::Metadata *, 16> LinkerOptionsMetadata;
+  SmallVector<llvm::MDNode *, 16> LinkerOptionsMetadata;
 
   /// @name Cache for Objective-C runtime types
   /// @{
 
   /// Cached reference to the class for constant strings. This value has type
   /// int * but is actually an Obj-C class pointer.
   llvm::WeakVH CFConstantStringClassRef;
 

clang/lib/CodeGen/CodeGenModule.cpp

 }
 
 void CodeGenModule::setFunctionDLLStorageClass(GlobalDecl GD, llvm::Function *F) {
   const auto *FD = cast<FunctionDecl>(GD.getDecl());
 
   if (const auto *Dtor = dyn_cast_or_null<CXXDestructorDecl>(FD)) {
     if (getCXXABI().useThunkForDtorVariant(Dtor, GD.getDtorType())) {
       // Don't dllexport/import destructor thunks.
-      F->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
+      F->setDLLImport(false);
       return;
     }
   }
 
   if (FD->hasAttr<DLLImportAttr>())
-    F->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
+    F->setDLLImport(true);
   else if (FD->hasAttr<DLLExportAttr>())
-    F->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
+    F->addDLLExportFlag();
   else
-    F->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
+    F->setDLLImport(false);
 }
 
 llvm::ConstantInt *CodeGenModule::CreateCrossDsoCfiTypeId(llvm::Metadata *MD) {
   llvm::MDString *MDS = dyn_cast<llvm::MDString>(MD);
   if (!MDS) return nullptr;
 
   return llvm::ConstantInt::get(Int64Ty, llvm::MD5Hash(MDS->getString()));
 }

 
 void CodeGenModule::setAliasAttributes(const Decl *D,
                                        llvm::GlobalValue *GV) {
   SetCommonAttributes(D, GV);
 
   // Process the dllexport attribute based on whether the original definition
   // (not necessarily the aliasee) was exported.
   if (D->hasAttr<DLLExportAttr>())
-    GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
+    GV->addDLLExportFlag();
 }
 
 void CodeGenModule::setNonAliasAttributes(const Decl *D,
                                           llvm::GlobalObject *GO) {
   SetCommonAttributes(D, GO);
 
   if (D)
     if (const SectionAttr *SA = D->getAttr<SectionAttr>())
static void setLinkageAndVisibilityForGV(llvm::GlobalValue *GV,
                                          const NamedDecl *ND) {
   // Set linkage and visibility in case we never see a definition.
   LinkageInfo LV = ND->getLinkageAndVisibility();
   if (LV.getLinkage() != ExternalLinkage) {
     // Don't set internal linkage on declarations.
   } else {
     if (ND->hasAttr<DLLImportAttr>()) {
       GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
-      GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
+      GV->setDLLImport(true);
     } else if (ND->hasAttr<DLLExportAttr>()) {
       GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
-      GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
     } else if (ND->hasAttr<WeakAttr>() || ND->isWeakImported()) {
       // "extern_weak" is overloaded in LLVM; we probably should have
       // separate linkage types for this.
       GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
     }
 
     // Set visibility on a declaration only if it's explicit.
     if (LV.isVisibilityExplicit())
void CodeGenModule::AddDependentLib(StringRef Lib) {
   getTargetCodeGenInfo().getDependentLibraryOption(Lib, Opt);
   auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt);
   LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
 }
 
 /// \brief Add link options implied by the given module, including modules
 /// it depends on, using a postorder walk.
 static void addLinkOptionsPostorder(CodeGenModule &CGM, Module *Mod,
-                                    SmallVectorImpl<llvm::Metadata *> &Metadata,
+                                    SmallVectorImpl<llvm::MDNode *> &Metadata,
                                     llvm::SmallPtrSet<Module *, 16> &Visited) {
   // Import this module's parent.
   if (Mod->Parent && Visited.insert(Mod->Parent).second) {
     addLinkOptionsPostorder(CGM, Mod->Parent, Metadata, Visited);
   }
 
   // Import this module's dependencies.
   for (unsigned I = Mod->Imports.size(); I > 0; --I) {
while (!Stack.empty()) {
     if (!AnyChildren) {
       LinkModules.insert(Mod);
     }
   }
 
   // Add link options for all of the imported modules in reverse topological
   // order.  We don't do anything to try to order import link flags with respect
   // to linker options inserted by things like #pragma comment().
-  SmallVector<llvm::Metadata *, 16> MetadataArgs;
+  SmallVector<llvm::MDNode *, 16> MetadataArgs;
   Visited.clear();
   for (Module *M : LinkModules)
     if (Visited.insert(M).second)
       addLinkOptionsPostorder(*this, M, MetadataArgs, Visited);
   std::reverse(MetadataArgs.begin(), MetadataArgs.end());
   LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end());
 
   // Add the linker options metadata flag.
-  getModule().addModuleFlag(llvm::Module::AppendUnique, "Linker Options",
-                            llvm::MDNode::get(getLLVMContext(),
-                                              LinkerOptionsMetadata));
+  auto *NMD = getModule().getOrInsertNamedMetadata("llvm.linker.options");
+  for (auto *MD : LinkerOptionsMetadata)
+    NMD->addOperand(MD);
 }
 
 void CodeGenModule::EmitDeferred() {
   // Emit code for any potentially referenced deferred decls.  Since a
   // previously unused static decl may become used during the generation of code
   // for a static function, iterate until no changes are made.
 
   if (!DeferredVTables.empty()) {
CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName,
   if (Entry) {
     if (WeakRefReferences.erase(Entry)) {
       const FunctionDecl *FD = cast_or_null<FunctionDecl>(D);
       if (FD && !FD->hasAttr<WeakAttr>())
         Entry->setLinkage(llvm::Function::ExternalLinkage);
     }
 
     // Handle dropped DLL attributes.
-    if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>())
-      Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
+    if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>()) {
+      Entry->setDLLImport(false);
+    }
 
     // If there are two attempts to define the same mangled name, issue an
     // error.
     if (IsForDefinition && !Entry->isDeclaration()) {
       GlobalDecl OtherGD;
       // Check that GD is not yet in DiagnosedConflictingDefinitions is required
       // to make sure that we issue an error only once.
       if (lookupRepresentativeDecl(MangledName, OtherGD) &&
CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy, StringRef Name,
   if (auto *F = dyn_cast<llvm::Function>(C)) {
     if (F->empty()) {
       F->setCallingConv(getRuntimeCC());
 
       if (!Local && getTriple().isOSBinFormatCOFF() &&
           !getCodeGenOpts().LTOVisibilityPublicStd) {
         const FunctionDecl *FD = GetRuntimeFunctionDecl(Context, Name);
         if (!FD || FD->hasAttr<DLLImportAttr>()) {
-          F->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
+          F->setDLLImport(true);
           F->setLinkage(llvm::GlobalValue::ExternalLinkage);
         }
       }
     }
   }
 
   return C;
 }
CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName,
   llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
   if (Entry) {
     if (WeakRefReferences.erase(Entry)) {
       if (D && !D->hasAttr<WeakAttr>())
         Entry->setLinkage(llvm::Function::ExternalLinkage);
     }
 
     // Handle dropped DLL attributes.
-    if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>())
-      Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
+    if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>()) {
+      Entry->setDLLImport(false);
+    }
 
     if (Entry->getType() == Ty)
       return Entry;
 
     // If there are two attempts to define the same mangled name, issue an
     // error.
     if (IsForDefinition && !Entry->isDeclaration()) {
       GlobalDecl OtherGD;
void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D,
   if (!D->isStaticLocal() && D->getTLSKind() == VarDecl::TLS_Dynamic &&
       Context.getTargetInfo().getTriple().isOSDarwin() &&
       !llvm::GlobalVariable::isLinkOnceLinkage(Linkage) &&
       !llvm::GlobalVariable::isWeakLinkage(Linkage))
     Linkage = llvm::GlobalValue::InternalLinkage;
 
   GV->setLinkage(Linkage);
   if (D->hasAttr<DLLImportAttr>())
-    GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
+    GV->setDLLImport(true);
   else if (D->hasAttr<DLLExportAttr>())
-    GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
+    GV->addDLLExportFlag();
   else
-    GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
+    GV->setDLLImport(false);
 
   if (Linkage == llvm::GlobalVariable::CommonLinkage) {
     // common vars aren't constant even if declared const.
     GV->setConstant(false);
     // Tentative definition of global variables may be initialized with
     // non-zero null pointers. In this case they should have weak linkage
     // since common linkage must have zero initializer and must not have
     // explicit section therefore cannot have non-zero initial value.
if (getTriple().isOSBinFormatCOFF()) {
       llvm::GlobalValue *CGV = cast<llvm::GlobalValue>(GV);
 
       const VarDecl *VD = nullptr;
       for (const auto &Result : DC->lookup(&II))
         if ((VD = dyn_cast<VarDecl>(Result)))
           break;
 
       if (!VD || !VD->hasAttr<DLLExportAttr>()) {
-        CGV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
+        CGV->setDLLImport(true);
         CGV->setLinkage(llvm::GlobalValue::ExternalLinkage);
       } else {
-        CGV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
+        CGV->addDLLExportFlag();
         CGV->setLinkage(llvm::GlobalValue::ExternalLinkage);
       }
     }
 
     // Decay array -> ptr
     CFConstantStringClassRef =
         llvm::ConstantExpr::getGetElementPtr(Ty, GV, Zeros);
   }

clang/lib/CodeGen/ItaniumCXXABI.cpp

const VTableLayout &VTLayout =
       CGM.getItaniumVTableContext().getVTableLayout(RD);
   llvm::Type *VTableType = CGM.getVTables().getVTableType(VTLayout);
 
   VTable = CGM.CreateOrReplaceCXXRuntimeVariable(
       Name, VTableType, llvm::GlobalValue::ExternalLinkage);
   VTable->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
 
   if (RD->hasAttr<DLLImportAttr>())
-    VTable->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
+    VTable->setDLLImport(true);
   else if (RD->hasAttr<DLLExportAttr>())
-    VTable->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
+    VTable->addDLLExportFlag();
 
   return VTable;
 }
 
 CGCallee ItaniumCXXABI::getVirtualFunctionPointer(CodeGenFunction &CGF,
                                                   GlobalDecl GD,
                                                   Address This,
                                                   llvm::Type *Ty,
if (!GV) {
     // Create a new global variable.
     GV = new llvm::GlobalVariable(CGM.getModule(), CGM.Int8PtrTy,
                                   /*Constant=*/true,
                                   llvm::GlobalValue::ExternalLinkage, nullptr,
                                   Name);
     if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) {
       const CXXRecordDecl *RD = cast<CXXRecordDecl>(RecordTy->getDecl());
       if (RD->hasAttr<DLLImportAttr>())
-        GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
+        GV->setDLLImport(true);
     }
   }
 
   return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy);
 }
 
 /// TypeInfoIsInStandardLibrary - Given a builtin type, returns whether the type
 /// info for that type is defined in the standard library.
else
     llvmVisibility = CodeGenModule::GetLLVMVisibility(Ty->getVisibility());
 
   TypeName->setVisibility(llvmVisibility);
   GV->setVisibility(llvmVisibility);
 
   if (CGM.getTriple().isWindowsItaniumEnvironment()) {
     auto RD = Ty->getAsCXXRecordDecl();
     if (DLLExport || (RD && RD->hasAttr<DLLExportAttr>())) {
-      TypeName->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
-      GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
+      TypeName->addDLLExportFlag();
+      GV->addDLLExportFlag();
     } else if (CGM.getLangOpts().RTTI && RD && RD->hasAttr<DLLImportAttr>()) {
-      TypeName->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
-      GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
+      TypeName->setDLLImport(true);
+      GV->setDLLImport(true);
 
       // Because the typename and the typeinfo are DLL import, convert them to
       // declarations rather than definitions.  The initializers still need to
       // be constructed to calculate the type for the declarations.
       TypeName->setInitializer(nullptr);
       GV->setInitializer(nullptr);
     }
   }

clang/lib/CodeGen/MicrosoftCXXABI.cpp

getAddrOfVirtualDisplacementMap(const CXXRecordDecl *SrcRD,
     return VDispMap;
   }
 
   void emitVBTableDefinition(const VPtrInfo &VBT, const CXXRecordDecl *RD,
                              llvm::GlobalVariable *GV) const;
 
   void setThunkLinkage(llvm::Function *Thunk, bool ForVTable,
                        GlobalDecl GD, bool ReturnAdjustment) override {
-    // Never dllimport/dllexport thunks.
-    Thunk->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
+    // Never dllimport thunks.
+    Thunk->setDLLImport(false);
 
     GVALinkage Linkage =
         getContext().GetGVALinkageForFunction(cast<FunctionDecl>(GD.getDecl()));
 
     if (Linkage == GVA_Internal)
       Thunk->setLinkage(llvm::GlobalValue::InternalLinkage);
     else if (ReturnAdjustment)
       Thunk->setLinkage(llvm::GlobalValue::WeakODRLinkage);
void MicrosoftCXXABI::EmitCXXConstructors(const CXXConstructorDecl *D) {
   // Exported default constructors either have a simple call-site where they use
   // the typical calling convention and have a single 'this' pointer for an
   // argument -or- they get a wrapper function which appropriately thunks to the
   // real default constructor.  This thunk is the default constructor closure.
   if (D->hasAttr<DLLExportAttr>() && D->isDefaultConstructor())
     if (!hasDefaultCXXMethodCC(getContext(), D) || D->getNumParams() != 0) {
       llvm::Function *Fn = getAddrOfCXXCtorClosure(D, Ctor_DefaultClosure);
       Fn->setLinkage(llvm::GlobalValue::WeakODRLinkage);
-      Fn->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
+      Fn->addDLLExportFlag();
     }
 }
 
 void MicrosoftCXXABI::EmitVBPtrStores(CodeGenFunction &CGF,
                                       const CXXRecordDecl *RD) {
   Address This = getThisAddress(CGF);
   This = CGF.Builder.CreateElementBitCast(This, CGM.Int8Ty, "this.int8");
   const ASTContext &Context = getContext();
if (VTableAliasIsRequred) {
     // The GlobalVariable will end up being an appropriate definition of the
     // VFTable.
     VFTable = VTable;
   }
   if (C)
     VTable->setComdat(C);
 
   if (RD->hasAttr<DLLExportAttr>())
-    VFTable->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
+    VFTable->addDLLExportFlag();
 
   VFTablesMap[ID] = VFTable;
   return VTable;
 }
 
 CGCallee MicrosoftCXXABI::getVirtualFunctionPointer(CodeGenFunction &CGF,
                                                     GlobalDecl GD,
                                                     Address This,
MicrosoftCXXABI::getAddrOfVBTable(const VPtrInfo &VBT, const CXXRecordDecl *RD,
 
   assert(!CGM.getModule().getNamedGlobal(Name) &&
          "vbtable with this name already exists: mangling bug?");
   llvm::GlobalVariable *GV =
       CGM.CreateOrReplaceCXXRuntimeVariable(Name, VBTableType, Linkage);
   GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
 
   if (RD->hasAttr<DLLImportAttr>())
-    GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
+    GV->setDLLImport(true);
   else if (RD->hasAttr<DLLExportAttr>())
-    GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
+    GV->addDLLExportFlag();
 
   if (!GV->hasExternalLinkage())
     emitVBTableDefinition(VBT, RD, GV);
 
   return GV;
 }
 
 void MicrosoftCXXABI::emitVBTableDefinition(const VPtrInfo &VBT,
if (!GuardVar) {
     }
 
     // Create the guard variable with a zero-initializer. Just absorb linkage,
     // visibility and dll storage class from the guarded variable.
     GuardVar =
         new llvm::GlobalVariable(CGM.getModule(), GuardTy, /*isConstant=*/false,
                                  GV->getLinkage(), Zero, GuardName.str());
     GuardVar->setVisibility(GV->getVisibility());
-    GuardVar->setDLLStorageClass(GV->getDLLStorageClass());
+    GuardVar->setDLLImport(GV->isDLLImport());
+    if (D.hasAttr<DLLExportAttr>() && !GV->hasLocalLinkage())
+      GV->addDLLExportFlag();
     GuardVar->setAlignment(GuardAlign.getQuantity());
     if (GuardVar->isWeakForLinker())
       GuardVar->setComdat(
           CGM.getModule().getOrInsertComdat(GuardVar->getName()));
     if (D.getTLSKind())
       GuardVar->setThreadLocal(true);
     if (GI && !HasPerVariableGuard)
       GI->Guard = GuardVar;

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

 class TargetLoweringObjectFileMachO : public TargetLoweringObjectFile {
 public:
   TargetLoweringObjectFileMachO();
   ~TargetLoweringObjectFileMachO() override = default;
 
   void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
 
   /// Emit the module flags that specify the garbage collection information.
-  void emitModuleFlags(MCStreamer &Streamer,
-                       ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
+  void emitModuleMetadata(MCStreamer &Streamer, Module &M,
                           const TargetMachine &TM) const override;
 
   MCSection *SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind,
                                     const TargetMachine &TM) const override;
 
   MCSection *getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind,
                                       const TargetMachine &TM) const override;
 
   MCSection *getSectionForConstant(const DataLayout &DL, SectionKind Kind,
MCSection *SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind,
                                     const TargetMachine &TM) const override;
 
   void getNameWithPrefix(SmallVectorImpl<char> &OutName, const GlobalValue *GV,
                          const TargetMachine &TM) const override;
 
   MCSection *getSectionForJumpTable(const Function &F,
                                     const TargetMachine &TM) const override;
 
-  /// Emit Obj-C garbage collection and linker options. Only linker option
-  /// emission is implemented for COFF.
-  void emitModuleFlags(MCStreamer &Streamer,
-                       ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
+  /// Emit linker options.
+  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;
 };
 
 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/GlobalValue.h

public:
 
   /// @brief An enumeration for the kinds of visibility of global values.
   enum VisibilityTypes {
     DefaultVisibility = 0,  ///< The GV is visible
     HiddenVisibility,       ///< The GV is hidden
     ProtectedVisibility     ///< The GV is protected
   };
 
-  /// @brief Storage classes of global values for PE targets.
-  enum DLLStorageClassTypes {
-    DefaultStorageClass   = 0,
-    DLLImportStorageClass = 1, ///< Function to be imported from DLL
-    DLLExportStorageClass = 2  ///< Function to be accessible from DLL.
-  };
-
 protected:
   GlobalValue(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
               LinkageTypes Linkage, const Twine &Name, unsigned AddressSpace)
       : Constant(PointerType::get(Ty, AddressSpace), VTy, Ops, NumOps),
         ValueType(Ty), Linkage(Linkage), Visibility(DefaultVisibility),
-        UnnamedAddrVal(unsigned(UnnamedAddr::None)),
-        DllStorageClass(DefaultStorageClass), ThreadLocal(NotThreadLocal),
-        HasLLVMReservedName(false), IntID((Intrinsic::ID)0U), Parent(nullptr) {
+        UnnamedAddrVal(unsigned(UnnamedAddr::None)), DllImport(false),
+        ThreadLocal(NotThreadLocal), HasLLVMReservedName(false),
+        IntID((Intrinsic::ID)0U), Parent(nullptr) {
     setName(Name);
   }
 
   Type *ValueType;
 
   static const unsigned GlobalValueSubClassDataBits = 18;
 
   // All bitfields use unsigned as the underlying type so that MSVC will pack
   // them.
   unsigned Linkage : 4;       // The linkage of this global
   unsigned Visibility : 2;    // The visibility style of this global
   unsigned UnnamedAddrVal : 2; // This value's address is not significant
-  unsigned DllStorageClass : 2; // DLL storage class
+  unsigned DllImport : 1;
 
   unsigned ThreadLocal : 3; // Is this symbol "Thread Local", if so, what is
                             // the desired model?
 
   /// True if the function's name starts with "llvm.".  This corresponds to the
   /// value of Function::isIntrinsic(), which may be true even if
   /// Function::intrinsicID() returns Intrinsic::not_intrinsic.
   unsigned HasLLVMReservedName : 1;
public:
   void setThreadLocalMode(ThreadLocalMode Val) {
     assert(Val == NotThreadLocal || getValueID() != Value::FunctionVal);
     ThreadLocal = Val;
   }
   ThreadLocalMode getThreadLocalMode() const {
     return static_cast<ThreadLocalMode>(ThreadLocal);
   }
 
-  DLLStorageClassTypes getDLLStorageClass() const {
-    return DLLStorageClassTypes(DllStorageClass);
-  }
-  bool hasDLLImportStorageClass() const {
-    return DllStorageClass == DLLImportStorageClass;
+  bool isDLLImport() const {
+    return DllImport;
   }
-  bool hasDLLExportStorageClass() const {
-    return DllStorageClass == DLLExportStorageClass;
-  }
-  void setDLLStorageClass(DLLStorageClassTypes C) { DllStorageClass = C; }
+  void setDLLImport(bool b) { DllImport = b; }
+
+  void addDLLExportFlag();
 
   bool hasSection() const { return !getSection().empty(); }
   StringRef getSection() const;
 
   /// Global values are always pointers.
   PointerType *getType() const { return cast<PointerType>(User::getType()); }
 
   Type *getValueType() const { return ValueType; }

llvm/include/llvm/Target/TargetLoweringObjectFile.h

public:
   /// This method must be called before any actual lowering is done.  This
   /// specifies the current context for codegen, and gives the lowering
   /// implementations a chance to set up their default sections.
   virtual void Initialize(MCContext &ctx, const TargetMachine &TM);
 
   virtual void emitPersonalityValue(MCStreamer &Streamer, const DataLayout &TM,
                                     const MCSymbol *Sym) const;
 
-  /// Emit the module flags that the platform cares about.
-  virtual void emitModuleFlags(MCStreamer &Streamer,
-                               ArrayRef<Module::ModuleFlagEntry> Flags,
+  /// Emit the module-level metadata that the platform cares about.
+  virtual void emitModuleMetadata(MCStreamer &Streamer, Module &M,
                                   const TargetMachine &TM) const {}
 
   /// Given a constant with the SectionKind, return a section that it should be
   /// placed in.
   virtual MCSection *getSectionForConstant(const DataLayout &DL,
                                            SectionKind Kind,
                                            const Constant *C,
                                            unsigned &Align) const;
 
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/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
   KEYWORD(internal);
   KEYWORD(available_externally);
   KEYWORD(linkonce);
   KEYWORD(linkonce_odr);
   KEYWORD(weak); // Use as a linkage, and a modifier for "cmpxchg".
   KEYWORD(weak_odr);
   KEYWORD(appending);
   KEYWORD(dllimport);
-  KEYWORD(dllexport);
   KEYWORD(common);
   KEYWORD(default);
   KEYWORD(hidden);
   KEYWORD(protected);
   KEYWORD(unnamed_addr);
   KEYWORD(local_unnamed_addr);
   KEYWORD(externally_initialized);
   KEYWORD(extern_weak);

llvm/lib/AsmParser/LLParser.h

private:
 
     bool ParseTLSModel(GlobalVariable::ThreadLocalMode &TLM);
     bool ParseOptionalThreadLocal(GlobalVariable::ThreadLocalMode &TLM);
     bool ParseOptionalUnnamedAddr(GlobalVariable::UnnamedAddr &UnnamedAddr);
     bool ParseOptionalAddrSpace(unsigned &AddrSpace);
     bool ParseOptionalParamAttrs(AttrBuilder &B);
     bool ParseOptionalReturnAttrs(AttrBuilder &B);
     bool ParseOptionalLinkage(unsigned &Linkage, bool &HasLinkage,
-                              unsigned &Visibility, unsigned &DLLStorageClass);
+                              unsigned &Visibility, bool &DLLImport);
     void ParseOptionalVisibility(unsigned &Visibility);
-    void ParseOptionalDLLStorageClass(unsigned &DLLStorageClass);
     bool ParseOptionalCallingConv(unsigned &CC);
     bool ParseOptionalAlignment(unsigned &Alignment);
     bool ParseOptionalDerefAttrBytes(lltok::Kind AttrKind, uint64_t &Bytes);
     bool ParseScopeAndOrdering(bool isAtomic, SynchronizationScope &Scope,
                                AtomicOrdering &Ordering);
     bool ParseOrdering(AtomicOrdering &Ordering);
     bool ParseOptionalStackAlignment(unsigned &Alignment);
     bool ParseOptionalCommaAlign(unsigned &Alignment, bool &AteExtraComma);
private:
     bool ParseNamedType();
     bool ParseDeclare();
     bool ParseDefine();
 
     bool ParseGlobalType(bool &IsConstant);
     bool ParseUnnamedGlobal();
     bool ParseNamedGlobal();
     bool ParseGlobal(const std::string &Name, LocTy Loc, unsigned Linkage,
-                     bool HasLinkage, unsigned Visibility,
-                     unsigned DLLStorageClass,
+                     bool HasLinkage, unsigned Visibility, bool DLLImport,
                      GlobalVariable::ThreadLocalMode TLM,
                      GlobalVariable::UnnamedAddr UnnamedAddr);
     bool parseIndirectSymbol(const std::string &Name, LocTy Loc,
                              unsigned Linkage, unsigned Visibility,
-                             unsigned DLLStorageClass,
+                             bool DLLImport,
                              GlobalVariable::ThreadLocalMode TLM,
                              GlobalVariable::UnnamedAddr UnnamedAddr);
     bool parseComdat();
     bool ParseStandaloneMetadata();
     bool ParseNamedMetadata();
     bool ParseMDString(MDString *&Result);
     bool ParseMDNodeID(MDNode *&Result);
     bool ParseUnnamedAttrGrp();

llvm/lib/AsmParser/LLParser.cpp

if (Lex.getUIntVal() != VarID)
       return Error(Lex.getLoc(), "variable expected to be numbered '%" +
                    Twine(VarID) + "'");
     Lex.Lex(); // eat GlobalID;
 
     if (ParseToken(lltok::equal, "expected '=' after name"))
       return true;
   }
 
-  bool HasLinkage;
-  unsigned Linkage, Visibility, DLLStorageClass;
+  bool HasLinkage, DLLImport;
+  unsigned Linkage, Visibility;
   GlobalVariable::ThreadLocalMode TLM;
   GlobalVariable::UnnamedAddr UnnamedAddr;
-  if (ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass) ||
+  if (ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLImport) ||
       ParseOptionalThreadLocal(TLM) || ParseOptionalUnnamedAddr(UnnamedAddr))
     return true;
 
   if (Lex.getKind() != lltok::kw_alias && Lex.getKind() != lltok::kw_ifunc)
     return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
-                       DLLStorageClass, TLM, UnnamedAddr);
+                       DLLImport, TLM, UnnamedAddr);
 
   return parseIndirectSymbol(Name, NameLoc, Linkage, Visibility,
-                             DLLStorageClass, TLM, UnnamedAddr);
+                             DLLImport, TLM, UnnamedAddr);
 }
 
 /// ParseNamedGlobal:
 ///   GlobalVar '=' OptionalVisibility (ALIAS | IFUNC) ...
 ///   GlobalVar '=' OptionalLinkage OptionalVisibility OptionalDLLStorageClass
 ///                                                     ...   -> global variable
 bool LLParser::ParseNamedGlobal() {
   assert(Lex.getKind() == lltok::GlobalVar);
   LocTy NameLoc = Lex.getLoc();
   std::string Name = Lex.getStrVal();
   Lex.Lex();
 
-  bool HasLinkage;
-  unsigned Linkage, Visibility, DLLStorageClass;
+  bool HasLinkage, DLLImport;
+  unsigned Linkage, Visibility;
   GlobalVariable::ThreadLocalMode TLM;
   GlobalVariable::UnnamedAddr UnnamedAddr;
   if (ParseToken(lltok::equal, "expected '=' in global variable") ||
-      ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass) ||
+      ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLImport) ||
       ParseOptionalThreadLocal(TLM) || ParseOptionalUnnamedAddr(UnnamedAddr))
     return true;
 
   if (Lex.getKind() != lltok::kw_alias && Lex.getKind() != lltok::kw_ifunc)
     return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility,
-                       DLLStorageClass, TLM, UnnamedAddr);
+                       DLLImport, TLM, UnnamedAddr);
 
   return parseIndirectSymbol(Name, NameLoc, Linkage, Visibility,
-                             DLLStorageClass, TLM, UnnamedAddr);
+                             DLLImport, TLM, UnnamedAddr);
 }
 
 bool LLParser::parseComdat() {
   assert(Lex.getKind() == lltok::ComdatVar);
   std::string Name = Lex.getStrVal();
   LocTy NameLoc = Lex.getLoc();
   Lex.Lex();
 

 ///
 /// IndirectSymbol
 ///   ::= TypeAndValue
 ///
 /// Everything through OptionalUnnamedAddr has already been parsed.
 ///
 bool LLParser::parseIndirectSymbol(
     const std::string &Name, LocTy NameLoc, unsigned L, unsigned Visibility,
-    unsigned DLLStorageClass, GlobalVariable::ThreadLocalMode TLM,
+    bool DLLImport, GlobalVariable::ThreadLocalMode TLM,
     GlobalVariable::UnnamedAddr UnnamedAddr) {
   bool IsAlias;
   if (Lex.getKind() == lltok::kw_alias)
     IsAlias = true;
   else if (Lex.getKind() == lltok::kw_ifunc)
     IsAlias = false;
   else
     llvm_unreachable("Not an alias or ifunc!");
GA.reset(GlobalAlias::create(Ty, AddrSpace,
                                  (GlobalValue::LinkageTypes)Linkage, Name,
                                  Aliasee, /*Parent*/ nullptr));
   else
     GA.reset(GlobalIFunc::create(Ty, AddrSpace,
                                  (GlobalValue::LinkageTypes)Linkage, Name,
                                  Aliasee, /*Parent*/ nullptr));
   GA->setThreadLocalMode(TLM);
   GA->setVisibility((GlobalValue::VisibilityTypes)Visibility);
-  GA->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
+  GA->setDLLImport(DLLImport);
   GA->setUnnamedAddr(UnnamedAddr);
 
   if (Name.empty())
     NumberedVals.push_back(GA.get());
 
   if (GVal) {
     // Verify that types agree.
     if (GVal->getType() != GA->getType())

 ///       OptionalThreadLocal OptionalUnnamedAddr OptionalAddrSpace
 ///       OptionalExternallyInitialized GlobalType Type Const
 ///
 /// Everything up to and including OptionalUnnamedAddr has been parsed
 /// already.
 ///
 bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc,
                            unsigned Linkage, bool HasLinkage,
-                           unsigned Visibility, unsigned DLLStorageClass,
+                           unsigned Visibility, bool DLLImport,
                            GlobalVariable::ThreadLocalMode TLM,
                            GlobalVariable::UnnamedAddr UnnamedAddr) {
   if (!isValidVisibilityForLinkage(Visibility, Linkage))
     return Error(NameLoc,
                  "symbol with local linkage must have default visibility");
 
   unsigned AddrSpace;
   bool IsConstant, IsExternallyInitialized;
if (Name.empty())
     NumberedVals.push_back(GV);
 
   // Set the parsed properties on the global.
   if (Init)
     GV->setInitializer(Init);
   GV->setConstant(IsConstant);
   GV->setLinkage((GlobalValue::LinkageTypes)Linkage);
   GV->setVisibility((GlobalValue::VisibilityTypes)Visibility);
-  GV->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
+  GV->setDLLImport(DLLImport);
   GV->setExternallyInitialized(IsExternallyInitialized);
   GV->setThreadLocalMode(TLM);
   GV->setUnnamedAddr(UnnamedAddr);
 
   // Parse attributes on the global.
   while (Lex.getKind() == lltok::comma) {
     Lex.Lex();
 

 ///   ::= 'linkonce_odr'
 ///   ::= 'available_externally'
 ///   ::= 'appending'
 ///   ::= 'common'
 ///   ::= 'extern_weak'
 ///   ::= 'external'
 bool LLParser::ParseOptionalLinkage(unsigned &Res, bool &HasLinkage,
                                     unsigned &Visibility,
-                                    unsigned &DLLStorageClass) {
+                                    bool &DLLImport) {
   Res = parseOptionalLinkageAux(Lex.getKind(), HasLinkage);
   if (HasLinkage)
     Lex.Lex();
   ParseOptionalVisibility(Visibility);
-  ParseOptionalDLLStorageClass(DLLStorageClass);
+  DLLImport = EatIfPresent(lltok::kw_dllimport);
   return false;
 }
 
 /// ParseOptionalVisibility
 ///   ::= /*empty*/
 ///   ::= 'default'
 ///   ::= 'hidden'
 ///   ::= 'protected'
case lltok::kw_hidden:
     break;
   case lltok::kw_protected:
     Res = GlobalValue::ProtectedVisibility;
     break;
   }
   Lex.Lex();
 }
 
-/// ParseOptionalDLLStorageClass
-///   ::= /*empty*/
-///   ::= 'dllimport'
-///   ::= 'dllexport'
-///
-void LLParser::ParseOptionalDLLStorageClass(unsigned &Res) {
-  switch (Lex.getKind()) {
-  default:
-    Res = GlobalValue::DefaultStorageClass;
-    return;
-  case lltok::kw_dllimport:
-    Res = GlobalValue::DLLImportStorageClass;
-    break;
-  case lltok::kw_dllexport:
-    Res = GlobalValue::DLLExportStorageClass;
-    break;
-  }
-  Lex.Lex();
-}
-
 /// ParseOptionalCallingConv
 ///   ::= /*empty*/
 ///   ::= 'ccc'
 ///   ::= 'fastcc'
 ///   ::= 'intel_ocl_bicc'
 ///   ::= 'coldcc'
 ///   ::= 'x86_stdcallcc'
 ///   ::= 'x86_fastcallcc'

 ///       OptUnnamedAddr Type GlobalName '(' ArgList ')' OptFuncAttrs OptSection
 ///       OptionalAlign OptGC OptionalPrefix OptionalPrologue OptPersonalityFn
 bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
   // Parse the linkage.
   LocTy LinkageLoc = Lex.getLoc();
   unsigned Linkage;
 
   unsigned Visibility;
-  unsigned DLLStorageClass;
+  bool DLLImport;
   AttrBuilder RetAttrs;
   unsigned CC;
   bool HasLinkage;
   Type *RetType = nullptr;
   LocTy RetTypeLoc = Lex.getLoc();
-  if (ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass) ||
+  if (ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLImport) ||
       ParseOptionalCallingConv(CC) || ParseOptionalReturnAttrs(RetAttrs) ||
       ParseType(RetType, RetTypeLoc, true /*void allowed*/))
     return true;
 
   // Verify that the linkage is ok.
   switch ((GlobalValue::LinkageTypes)Linkage) {
   case GlobalValue::ExternalLinkage:
     break; // always ok.
bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
   else // Move the forward-reference to the correct spot in the module.
     M->getFunctionList().splice(M->end(), M->getFunctionList(), Fn);
 
   if (FunctionName.empty())
     NumberedVals.push_back(Fn);
 
   Fn->setLinkage((GlobalValue::LinkageTypes)Linkage);
   Fn->setVisibility((GlobalValue::VisibilityTypes)Visibility);
-  Fn->setDLLStorageClass((GlobalValue::DLLStorageClassTypes)DLLStorageClass);
+  Fn->setDLLImport(DLLImport);
   Fn->setCallingConv(CC);
   Fn->setAttributes(PAL);
   Fn->setUnnamedAddr(UnnamedAddr);
   Fn->setAlignment(Alignment);
   Fn->setSection(Section);
   Fn->setComdat(C);
   Fn->setPersonalityFn(PersonalityFn);
   if (!GC.empty()) Fn->setGC(GC);

llvm/lib/AsmParser/LLToken.h

enum Kind {
   kw_private,
   kw_internal,
   kw_linkonce,
   kw_linkonce_odr,
   kw_weak, // Used as a linkage, and a modifier for "cmpxchg".
   kw_weak_odr,
   kw_appending,
   kw_dllimport,
-  kw_dllexport,
   kw_common,
   kw_available_externally,
   kw_default,
   kw_hidden,
   kw_protected,
   kw_unnamed_addr,
   kw_local_unnamed_addr,
   kw_externally_initialized,

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

class BitcodeReader : public BitcodeReaderBase, public GVMaterializer {
   /// where to find deferred function body in the stream.
   DenseMap<Function*, uint64_t> DeferredFunctionInfo;
 
   /// When Metadata block is initially scanned when parsing the module, we may
   /// choose to defer parsing of the metadata. This vector contains info about
   /// which Metadata blocks are deferred.
   std::vector<uint64_t> DeferredMetadataInfo;
 
+  /// This vector stores the list of globals with the historical dllexport
+  /// storage class. We need to create metadata for each of them after we
+  /// materialize the metadata.
+  std::vector<GlobalValue *> DeferredDLLExportedGlobals;
+
   /// These are basic blocks forward-referenced by block addresses.  They are
   /// inserted lazily into functions when they're loaded.  The basic block ID is
   /// its index into the vector.
   DenseMap<Function *, std::vector<BasicBlock *>> BasicBlockFwdRefs;
   std::deque<Function *> BasicBlockFwdRefQueue;
 
   /// Indicates that we are using a new encoding for instruction operands where
   /// most operands in the current FUNCTION_BLOCK are encoded relative to the
public:
   static uint64_t decodeSignRotatedValue(uint64_t V);
 
   /// Materialize any deferred Metadata block.
   Error materializeMetadata() override;
 
   void setStripDebugInfo() override;
 
 private:
+  void upgradeDLLStorageClass(GlobalValue *GV, unsigned Val);
+  void upgradeDLLImportExportLinkage(GlobalValue *GV, unsigned Val);
+
   std::vector<StructType *> IdentifiedStructTypes;
   StructType *createIdentifiedStructType(LLVMContext &Context, StringRef Name);
   StructType *createIdentifiedStructType(LLVMContext &Context);
 
   Type *getTypeByID(unsigned ID);
 
   Value *getFnValueByID(unsigned ID, Type *Ty) {
     if (Ty && Ty->isMetadataTy())
static GlobalValue::VisibilityTypes getDecodedVisibility(unsigned Val) {
   switch (Val) {
   default: // Map unknown visibilities to default.
   case 0: return GlobalValue::DefaultVisibility;
   case 1: return GlobalValue::HiddenVisibility;
   case 2: return GlobalValue::ProtectedVisibility;
   }
 }
 
-static GlobalValue::DLLStorageClassTypes
-getDecodedDLLStorageClass(unsigned Val) {
+void BitcodeReader::upgradeDLLStorageClass(GlobalValue *GV, unsigned Val) {
   switch (Val) {
   default: // Map unknown values to default.
-  case 0: return GlobalValue::DefaultStorageClass;
-  case 1: return GlobalValue::DLLImportStorageClass;
-  case 2: return GlobalValue::DLLExportStorageClass;
+  case 0: break;
+  case 1: GV->setDLLImport(true); break;
+  case 2: DeferredDLLExportedGlobals.push_back(GV); break;
   }
 }
 
 static GlobalVariable::ThreadLocalMode getDecodedThreadLocalMode(unsigned Val) {
   switch (Val) {
     case 0: return GlobalVariable::NotThreadLocal;
     default: // Map unknown non-zero value to general dynamic.
     case 1: return GlobalVariable::GeneralDynamicTLSModel;
if (0 != (Val & FastMathFlags::NoInfs))
     FMF.setNoInfs();
   if (0 != (Val & FastMathFlags::NoSignedZeros))
     FMF.setNoSignedZeros();
   if (0 != (Val & FastMathFlags::AllowReciprocal))
     FMF.setAllowReciprocal();
   return FMF;
 }
 
-static void upgradeDLLImportExportLinkage(GlobalValue *GV, unsigned Val) {
+void BitcodeReader::upgradeDLLImportExportLinkage(GlobalValue *GV,
+                                                  unsigned Val) {
   switch (Val) {
-  case 5: GV->setDLLStorageClass(GlobalValue::DLLImportStorageClass); break;
-  case 6: GV->setDLLStorageClass(GlobalValue::DLLExportStorageClass); break;
+  case 5: GV->setDLLImport(true); break;
+  case 6: DeferredDLLExportedGlobals.push_back(GV); break;
   }
 }
 
 
 Type *BitcodeReader::getTypeByID(unsigned ID) {
   // The type table size is always specified correctly.
   if (ID >= TypeList.size())
     return nullptr;

 
 Error BitcodeReader::materializeMetadata() {
   for (uint64_t BitPos : DeferredMetadataInfo) {
     // Move the bit stream to the saved position.
     Stream.JumpToBit(BitPos);
     if (Error Err = MDLoader->parseModuleMetadata())
       return Err;
   }
+  if (Metadata *Val = TheModule->getModuleFlag("Linker Options")) {
+    NamedMDNode *LinkerOpts =
+        TheModule->getOrInsertNamedMetadata("llvm.linker.options");
+    for (const MDOperand &MDOptions : cast<MDNode>(Val)->operands())
+      LinkerOpts->addOperand(cast<MDNode>(MDOptions));
+  }
+  for (auto *GV : DeferredDLLExportedGlobals)
+    GV->addDLLExportFlag();
   DeferredMetadataInfo.clear();
   return Error::success();
 }
 
 void BitcodeReader::setStripDebugInfo() { StripDebugInfo = true; }
 
 /// When we see the block for a function body, remember where it is and then
 /// skip it.  This lets us lazily deserialize the functions.
case bitc::MODULE_CODE_GLOBALVAR: {
                            TLM, AddressSpace, ExternallyInitialized);
       NewGV->setAlignment(Alignment);
       if (!Section.empty())
         NewGV->setSection(Section);
       NewGV->setVisibility(Visibility);
       NewGV->setUnnamedAddr(UnnamedAddr);
 
       if (Record.size() > 10)
-        NewGV->setDLLStorageClass(getDecodedDLLStorageClass(Record[10]));
+        upgradeDLLStorageClass(NewGV, Record[10]);
       else
         upgradeDLLImportExportLinkage(NewGV, RawLinkage);
 
       ValueList.push_back(NewGV);
 
       // Remember which value to use for the global initializer.
       if (unsigned InitID = Record[2])
         GlobalInits.push_back(std::make_pair(NewGV, InitID-1));
case bitc::MODULE_CODE_FUNCTION: {
       GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::UnnamedAddr::None;
       if (Record.size() > 9)
         UnnamedAddr = getDecodedUnnamedAddrType(Record[9]);
       Func->setUnnamedAddr(UnnamedAddr);
       if (Record.size() > 10 && Record[10] != 0)
         FunctionPrologues.push_back(std::make_pair(Func, Record[10]-1));
 
       if (Record.size() > 11)
-        Func->setDLLStorageClass(getDecodedDLLStorageClass(Record[11]));
+        upgradeDLLStorageClass(Func, Record[11]);
       else
         upgradeDLLImportExportLinkage(Func, RawLinkage);
 
       if (Record.size() > 12) {
         if (unsigned ComdatID = Record[12]) {
           if (ComdatID > ComdatList.size())
             return error("Invalid function comdat ID");
           Func->setComdat(ComdatList[ComdatID - 1]);
case bitc::MODULE_CODE_ALIAS_OLD: {
       // Local linkage must have default visibility.
       if (OpNum != Record.size()) {
         auto VisInd = OpNum++;
         if (!NewGA->hasLocalLinkage())
           // FIXME: Change to an error if non-default in 4.0.
           NewGA->setVisibility(getDecodedVisibility(Record[VisInd]));
       }
       if (OpNum != Record.size())
-        NewGA->setDLLStorageClass(getDecodedDLLStorageClass(Record[OpNum++]));
+        upgradeDLLStorageClass(NewGA, Linkage);
       else
         upgradeDLLImportExportLinkage(NewGA, Linkage);
       if (OpNum != Record.size())
         NewGA->setThreadLocalMode(getDecodedThreadLocalMode(Record[OpNum++]));
       if (OpNum != Record.size())
         NewGA->setUnnamedAddr(getDecodedUnnamedAddrType(Record[OpNum++]));
       ValueList.push_back(NewGA);
       IndirectSymbolInits.push_back(std::make_pair(NewGA, Val));

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

static unsigned getEncodedVisibility(const GlobalValue &GV) {
   switch (GV.getVisibility()) {
   case GlobalValue::DefaultVisibility:   return 0;
   case GlobalValue::HiddenVisibility:    return 1;
   case GlobalValue::ProtectedVisibility: return 2;
   }
   llvm_unreachable("Invalid visibility");
 }
 
-static unsigned getEncodedDLLStorageClass(const GlobalValue &GV) {
-  switch (GV.getDLLStorageClass()) {
-  case GlobalValue::DefaultStorageClass:   return 0;
-  case GlobalValue::DLLImportStorageClass: return 1;
-  case GlobalValue::DLLExportStorageClass: return 2;
-  }
-  llvm_unreachable("Invalid DLL storage class");
-}
-
 static unsigned getEncodedThreadLocalMode(const GlobalValue &GV) {
   switch (GV.getThreadLocalMode()) {
     case GlobalVariable::NotThreadLocal:         return 0;
     case GlobalVariable::GeneralDynamicTLSModel: return 1;
     case GlobalVariable::LocalDynamicTLSModel:   return 2;
     case GlobalVariable::InitialExecTLSModel:    return 3;
     case GlobalVariable::LocalExecTLSModel:      return 4;
   }
for (const GlobalVariable &GV : M.globals()) {
     Vals.push_back(GV.isDeclaration() ? 0 :
                    (VE.getValueID(GV.getInitializer()) + 1));
     Vals.push_back(getEncodedLinkage(GV));
     Vals.push_back(Log2_32(GV.getAlignment())+1);
     Vals.push_back(GV.hasSection() ? SectionMap[GV.getSection()] : 0);
     if (GV.isThreadLocal() ||
         GV.getVisibility() != GlobalValue::DefaultVisibility ||
         GV.getUnnamedAddr() != GlobalValue::UnnamedAddr::None ||
-        GV.isExternallyInitialized() ||
-        GV.getDLLStorageClass() != GlobalValue::DefaultStorageClass ||
-        GV.hasComdat()) {
+        GV.isExternallyInitialized() || GV.isDLLImport() || GV.hasComdat()) {
       Vals.push_back(getEncodedVisibility(GV));
       Vals.push_back(getEncodedThreadLocalMode(GV));
       Vals.push_back(getEncodedUnnamedAddr(GV));
       Vals.push_back(GV.isExternallyInitialized());
-      Vals.push_back(getEncodedDLLStorageClass(GV));
+      Vals.push_back(GV.isDLLImport());
       Vals.push_back(GV.hasComdat() ? VE.getComdatID(GV.getComdat()) : 0);
     } else {
       AbbrevToUse = SimpleGVarAbbrev;
     }
 
     Stream.EmitRecord(bitc::MODULE_CODE_GLOBALVAR, Vals, AbbrevToUse);
     Vals.clear();
   }
for (const Function &F : M) {
     Vals.push_back(VE.getAttributeID(F.getAttributes()));
     Vals.push_back(Log2_32(F.getAlignment())+1);
     Vals.push_back(F.hasSection() ? SectionMap[F.getSection()] : 0);
     Vals.push_back(getEncodedVisibility(F));
     Vals.push_back(F.hasGC() ? GCMap[F.getGC()] : 0);
     Vals.push_back(getEncodedUnnamedAddr(F));
     Vals.push_back(F.hasPrologueData() ? (VE.getValueID(F.getPrologueData()) + 1)
                                        : 0);
-    Vals.push_back(getEncodedDLLStorageClass(F));
+    Vals.push_back(F.isDLLImport());
     Vals.push_back(F.hasComdat() ? VE.getComdatID(F.getComdat()) : 0);
     Vals.push_back(F.hasPrefixData() ? (VE.getValueID(F.getPrefixData()) + 1)
                                      : 0);
     Vals.push_back(
         F.hasPersonalityFn() ? (VE.getValueID(F.getPersonalityFn()) + 1) : 0);
 
     unsigned AbbrevToUse = 0;
     Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals, AbbrevToUse);
     Vals.clear();
   }
 
   // Emit the alias information.
   for (const GlobalAlias &A : M.aliases()) {
     // ALIAS: [alias type, aliasee val#, linkage, visibility, dllstorageclass,
     //         threadlocal, unnamed_addr]
     Vals.push_back(VE.getTypeID(A.getValueType()));
     Vals.push_back(A.getType()->getAddressSpace());
     Vals.push_back(VE.getValueID(A.getAliasee()));
     Vals.push_back(getEncodedLinkage(A));
     Vals.push_back(getEncodedVisibility(A));
-    Vals.push_back(getEncodedDLLStorageClass(A));
+    Vals.push_back(A.isDLLImport());
     Vals.push_back(getEncodedThreadLocalMode(A));
     Vals.push_back(getEncodedUnnamedAddr(A));
     unsigned AbbrevToUse = 0;
     Stream.EmitRecord(bitc::MODULE_CODE_ALIAS, Vals, AbbrevToUse);
     Vals.clear();
   }
 
   // Emit the ifunc information.

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

if (V == GlobalValue::DefaultVisibility)
       continue;
 
     MCSymbol *Name = getSymbol(&F);
     EmitVisibility(Name, V, false);
   }
 
   const TargetLoweringObjectFile &TLOF = getObjFileLowering();
 
-  // Emit module flags.
-  SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
-  M.getModuleFlagsMetadata(ModuleFlags);
-  if (!ModuleFlags.empty())
-    TLOF.emitModuleFlags(*OutStreamer, ModuleFlags, TM);
+  TLOF.emitModuleMetadata(*OutStreamer, M, TM);
 
   if (TM.getTargetTriple().isOSBinFormatELF()) {
     MachineModuleInfoELF &MMIELF = MMI->getObjFileInfo<MachineModuleInfoELF>();
 
     // Output stubs for external and common global variables.
     MachineModuleInfoELF::SymbolListTy Stubs = MMIELF.GetGVStubList();
     if (!Stubs.empty()) {
       OutStreamer->SwitchSection(TLOF.getDataSection());

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

for (const auto &GE : GlobalExprs) {
     const DIExpression *Expr = GE.Expr;
     // For compatibility with DWARF 3 and earlier,
     // DW_AT_location(DW_OP_constu, X, DW_OP_stack_value) becomes
     // DW_AT_const_value(X).
     if (GlobalExprs.size() == 1 && Expr && Expr->isConstant()) {
       addConstantValue(*VariableDIE, /*Unsigned=*/true, Expr->getElement(1));
       // We cannot describe the location of dllimport'd variables: the
       // computation of their address requires loads from the IAT.
-    } else if ((Global && !Global->hasDLLImportStorageClass()) || AllConstant) {
+    } else if ((Global && !Global->isDLLImport()) || AllConstant) {
       if (!Loc) {
         Loc = new (DIEValueAllocator) DIELoc;
         DwarfExpr = llvm::make_unique<DIEDwarfExpression>(*Asm, *this, *Loc);
       }
       addToAccelTable = true;
       if (Global) {
         const MCSymbol *Sym = Asm->getSymbol(Global);
         if (Global->isThreadLocal()) {

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

void DwarfUnit::constructTemplateValueParameterDIE(
   if (!VP->getName().empty())
     addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
   if (Metadata *Val = VP->getValue()) {
     if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
       addConstantValue(ParamDIE, CI, resolve(VP->getType()));
     else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
       // We cannot describe the location of dllimport'd entities: the
       // computation of their address requires loads from the IAT.
-      if (!GV->hasDLLImportStorageClass()) {
+      if (!GV->isDLLImport()) {
         // For declaration non-type template parameters (such as global values
         // and functions)
         DIELoc *Loc = new (DIEValueAllocator) DIELoc;
         addOpAddress(*Loc, Asm->getSymbol(GV));
         // Emit DW_OP_stack_value to use the address as the immediate value of
         // the parameter, rather than a pointer to it.
         addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
         addBlock(ParamDIE, dwarf::DW_AT_location, Loc);

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

StaticCtorSection = Ctx.getMachOSection("__DATA", "__mod_init_func",
                                             MachO::S_MOD_INIT_FUNC_POINTERS,
                                             SectionKind::getData());
     StaticDtorSection = Ctx.getMachOSection("__DATA", "__mod_term_func",
                                             MachO::S_MOD_TERM_FUNC_POINTERS,
                                             SectionKind::getData());
   }
 }
 
-/// emitModuleFlags - Perform code emission for module flags.
-void TargetLoweringObjectFileMachO::emitModuleFlags(
-    MCStreamer &Streamer, ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
-    const TargetMachine &TM) const {
+void TargetLoweringObjectFileMachO::emitModuleMetadata(
+    MCStreamer &Streamer, Module &M, const TargetMachine &TM) const {
+  // Emit the linker options if present.
+  if (auto *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
+    for (const auto &Option : LinkerOptions->operands()) {
+      SmallVector<std::string, 4> StrOptions;
+      for (const auto &Piece : cast<MDNode>(Option)->operands())
+        StrOptions.push_back(cast<MDString>(Piece)->getString());
+      Streamer.EmitLinkerOptions(StrOptions);
+    }
+  }
+
   unsigned VersionVal = 0;
   unsigned ImageInfoFlags = 0;
-  MDNode *LinkerOptions = nullptr;
   StringRef SectionVal;
 
+  SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
+  M.getModuleFlagsMetadata(ModuleFlags);
   for (const auto &MFE : ModuleFlags) {
     // Ignore flags with 'Require' behavior.
     if (MFE.Behavior == Module::Require)
       continue;
 
     StringRef Key = MFE.Key->getString();
     Metadata *Val = MFE.Val;
 
     if (Key == "Objective-C Image Info Version") {
       VersionVal = mdconst::extract<ConstantInt>(Val)->getZExtValue();
     } else if (Key == "Objective-C Garbage Collection" ||
                Key == "Objective-C GC Only" ||
                Key == "Objective-C Is Simulated" ||
                Key == "Objective-C Class Properties" ||
                Key == "Objective-C Image Swift Version") {
       ImageInfoFlags |= mdconst::extract<ConstantInt>(Val)->getZExtValue();
     } else if (Key == "Objective-C Image Info Section") {
       SectionVal = cast<MDString>(Val)->getString();
-    } else if (Key == "Linker Options") {
-      LinkerOptions = cast<MDNode>(Val);
-    }
-  }
-
-  // Emit the linker options if present.
-  if (LinkerOptions) {
-    for (const auto &Option : LinkerOptions->operands()) {
-      SmallVector<std::string, 4> StrOptions;
-      for (const auto &Piece : cast<MDNode>(Option)->operands())
-        StrOptions.push_back(cast<MDString>(Piece)->getString());
-      Streamer.EmitLinkerOptions(StrOptions);
     }
   }
 
   // The section is mandatory. If we don't have it, then we don't have GC info.
   if (SectionVal.empty()) return;
 
   StringRef Segment, Section;
   unsigned TAA = 0, StubSize = 0;
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::getSectionForJumpTable(
   unsigned Characteristics = getCOFFSectionFlags(Kind, TM);
   Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
   unsigned UniqueID = NextUniqueID++;
 
   return getContext().getCOFFSection(Name, Characteristics, Kind, COMDATSymName,
                                      COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE, UniqueID);
 }
 
-void TargetLoweringObjectFileCOFF::emitModuleFlags(
-    MCStreamer &Streamer, ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
-    const TargetMachine &TM) const {
-  MDNode *LinkerOptions = nullptr;
-
-  for (const auto &MFE : ModuleFlags) {
+void TargetLoweringObjectFileCOFF::emitModuleMetadata(
+    MCStreamer &Streamer, Module &M, const TargetMachine &TM) const {
+  NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options");
+  if (!LinkerOptions)
+    return;