[GlobalMerge] Allow merging of dllexported variables

[mstorsjo]

Summary

If merging them, the dllexport attribute needs to be brought along to the new GlobalAlias.

This is a follow-up to D42127 (which just turned off merging of dllexported variables). Handling it properly turned out to be very straightforward after all. I hadn't noticed before that GlobalAlias handily was a GlobalValue subclass - otherwise this would have end up as a much larger change.

lib/CodeGen/GlobalMerge.cpp

auto *MergedGV = new GlobalVariable(
         M, MergedTy, isConst, MergedLinkage, MergedInit, MergedName, nullptr,
         GlobalVariable::NotThreadLocal, AddrSpace);
 
     const StructLayout *MergedLayout = DL.getStructLayout(MergedTy);
 
     for (ssize_t k = i, idx = 0; k != j; k = GlobalSet.find_next(k), ++idx) {
       GlobalValue::LinkageTypes Linkage = Globals[k]->getLinkage();
       std::string Name = Globals[k]->getName();
+      GlobalValue::DLLStorageClassTypes DLLStorage =
+          Globals[k]->getDLLStorageClass();
 
       // Copy metadata while adjusting any debug info metadata by the original
       // global's offset within the merged global.
       MergedGV->copyMetadata(Globals[k], MergedLayout->getElementOffset(idx));
 
       Constant *Idx[2] = {
         ConstantInt::get(Int32Ty, 0),
         ConstantInt::get(Int32Ty, idx),
       };
       Constant *GEP =
           ConstantExpr::getInBoundsGetElementPtr(MergedTy, MergedGV, Idx);
       Globals[k]->replaceAllUsesWith(GEP);
       Globals[k]->eraseFromParent();
 
       // When the linkage is not internal we must emit an alias for the original
       // variable name as it may be accessed from another object. On non-Mach-O
       // we can also emit an alias for internal linkage as it's safe to do so.
       // It's not safe on Mach-O as the alias (and thus the portion of the
       // MergedGlobals variable) may be dead stripped at link time.
       if (Linkage != GlobalValue::InternalLinkage || !IsMachO) {
+        GlobalAlias *GA =
             GlobalAlias::create(Tys[idx], AddrSpace, Linkage, Name, GEP, &M);
+        GA->setDLLStorageClass(DLLStorage);
       }
 
       NumMerged++;
     }
     i = j;
   }
 
   return true;
DenseMap<unsigned, SmallVector<GlobalVariable *, 16>> Globals, ConstGlobals,
                                                         BSSGlobals;
   bool Changed = false;
   setMustKeepGlobalVariables(M);
 
   // Grab all non-const globals.
   for (auto &GV : M.globals()) {
     // Merge is safe for "normal" internal or external globals only
     if (GV.isDeclaration() || GV.isThreadLocal() ||
-        GV.hasSection() || GV.hasImplicitSection() ||
-        GV.hasDLLExportStorageClass())
+        GV.hasSection() || GV.hasImplicitSection())
       continue;
 
     // It's not safe to merge globals that may be preempted
     if (TM && !TM->shouldAssumeDSOLocal(M, &GV))
       continue;
 
     if (!(MergeExternalGlobals && GV.hasExternalLinkage()) &&
         !GV.hasInternalLinkage())

test/CodeGen/ARM/global-merge-dllexport.ll

 ; RUN: llc < %s -mtriple=thumbv7-win32 -arm-global-merge | FileCheck %s
 
 @x = global i32 0, align 4
 @y = dllexport global i32 0, align 4
 
 define void @f1(i32 %a1, i32 %a2) {
 ; CHECK: f1:
-; CHECK: movw [[REG1:r[0-9]+]], :lower16:x
-; CHECK: movt [[REG1]], :upper16:x
+; CHECK: movw [[REG1:r[0-9]+]], :lower16:.L_MergedGlobals
+; CHECK: movt [[REG1]], :upper16:.L_MergedGlobals
   store i32 %a1, i32* @x, align 4
   store i32 %a2, i32* @y, align 4
   ret void
 }
 
-; CHECK-NOT: .L_MergedGlobals
+; CHECK: .lcomm .L_MergedGlobals,8,4
+; CHECK: .globl x
+; CHECK: x = .L_MergedGlobals
+; CHECK: .globl y
+; CHECK: y = .L_MergedGlobals+4
+; CHECK: .section .drectve,"yn"
+; CHECK: .ascii " /EXPORT:y,DATA"