Move dllimport name mangling to IR mangler.

[pcc]

Summary

This ensures that LTO clients see the correct external symbol name.

[• rafael]

LGTM

llvm/trunk/lib/IR/Mangler.cpp

if (!GV->hasName()) {
     if (ID == 0)
       ID = NextAnonGlobalID++;
 
     // Must mangle the global into a unique ID.
     getNameWithPrefix(OS, "__unnamed_" + Twine(ID), PrefixTy);
     return;
   }
 
+  // dllimported symbols have a __imp_ prefix.
+  if (GV->hasDLLImportStorageClass())
+    OS << "__imp_";
+
   StringRef Name = GV->getName();
   char Prefix = DL->getGlobalPrefix();
 
   // Mangle functions with Microsoft calling conventions specially.  Only do
   // this mangling for x86_64 vectorcall and 32-bit x86.
   const Function *MSFunc = dyn_cast<Function>(GV);
   if (Name.startswith("\01"))
     MSFunc = nullptr; // Don't mangle when \01 is present.

llvm/trunk/lib/Target/ARM/ARMAsmPrinter.cpp

MachineModuleInfoImpl::StubValueTy &StubSym =
                                 : MMIMachO.getGVStubEntry(MCSym);
     if (!StubSym.getPointer())
       StubSym = MachineModuleInfoImpl::StubValueTy(getSymbol(GV),
                                                    !GV->hasInternalLinkage());
     return MCSym;
   } else if (Subtarget->isTargetCOFF()) {
     assert(Subtarget->isTargetWindows() &&
            "Windows is the only supported COFF target");
-
-    bool IsIndirect = (TargetFlags & ARMII::MO_DLLIMPORT);
-    if (!IsIndirect)
-      return getSymbol(GV);
-
-    SmallString<128> Name;
-    Name = "__imp_";
-    getNameWithPrefix(Name, GV);
-
-    return OutContext.getOrCreateSymbol(Name);
   } else if (Subtarget->isTargetELF()) {
     return getSymbol(GV);
   }
   llvm_unreachable("unexpected target");
 }
 
 void ARMAsmPrinter::
 EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) {

llvm/trunk/lib/Target/ARM/ARMISelLowering.cpp

if (isStub && Subtarget->isThumb1Only() && !Subtarget->hasV5TOps()) {
       Callee = DAG.getNode(ARMISD::WrapperPIC, dl, getPointerTy(),
                            DAG.getTargetGlobalAddress(GV, dl, getPointerTy(),
                                                       0, ARMII::MO_NONLAZY));
       Callee = DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(), Callee,
                            MachinePointerInfo::getGOT(), false, false, true, 0);
     } else if (Subtarget->isTargetCOFF()) {
       assert(Subtarget->isTargetWindows() &&
              "Windows is the only supported COFF target");
-      unsigned TargetFlags = GV->hasDLLImportStorageClass()
-                                 ? ARMII::MO_DLLIMPORT
-                                 : ARMII::MO_NO_FLAG;
       Callee = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), /*Offset=*/0,
-                                          TargetFlags);
+                                          ARMII::MO_NO_FLAG);
       if (GV->hasDLLImportStorageClass())
         Callee = DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(),
                              DAG.getNode(ARMISD::Wrapper, dl, getPointerTy(),
                                          Callee), MachinePointerInfo::getGOT(),
                              false, false, false, 0);
     } else {
       // On ELF targets for PIC code, direct calls should go through the PLT
       unsigned OpFlags = 0;

 
 SDValue ARMTargetLowering::LowerGlobalAddressWindows(SDValue Op,
                                                      SelectionDAG &DAG) const {
   assert(Subtarget->isTargetWindows() && "non-Windows COFF is not supported");
   assert(Subtarget->useMovt(DAG.getMachineFunction()) &&
          "Windows on ARM expects to use movw/movt");
 
   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
-  const ARMII::TOF TargetFlags =
-    (GV->hasDLLImportStorageClass() ? ARMII::MO_DLLIMPORT : ARMII::MO_NO_FLAG);
   EVT PtrVT = getPointerTy();
   SDValue Result;
   SDLoc DL(Op);
 
   ++NumMovwMovt;
 
   // FIXME: Once remat is capable of dealing with instructions with register
   // operands, expand this into two nodes.
   Result = DAG.getNode(ARMISD::Wrapper, DL, PtrVT,
                        DAG.getTargetGlobalAddress(GV, DL, PtrVT, /*Offset=*/0,
-                                                  TargetFlags));
+                                                  ARMII::MO_NO_FLAG));
   if (GV->hasDLLImportStorageClass())
     Result = DAG.getLoad(PtrVT, DL, DAG.getEntryNode(), Result,
                          MachinePointerInfo::getGOT(), false, false, false, 0);
   return Result;
 }
 
 SDValue ARMTargetLowering::LowerGLOBAL_OFFSET_TABLE(SDValue Op,
                                                     SelectionDAG &DAG) const {

llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMBaseInfo.h

enum TOF {
     /// MO_PLT - On a symbol operand, this represents an ELF PLT reference on a
     /// call operand.
     MO_PLT = 0x3,
 
     /// MO_OPTION_MASK - Most flags are mutually exclusive; this mask selects
     /// just that part of the flag set.
     MO_OPTION_MASK = 0x3f,
 
-    /// MO_DLLIMPORT - On a symbol operand, this represents that the reference
-    /// to the symbol is for an import stub.  This is used for DLL import
-    /// storage class indication on Windows.
-    MO_DLLIMPORT = 0x40,
-
     /// MO_NONLAZY - This is an independent flag, on a symbol operand "FOO" it
     /// represents a symbol which, if indirect, will get special Darwin mangling
     /// as a non-lazy-ptr indirect symbol (i.e. "L_FOO$non_lazy_ptr"). Can be
     /// combined with MO_LO16, MO_HI16 or MO_NO_FLAG (in a constant-pool, for
     /// example).
-    MO_NONLAZY = 0x80,
+    MO_NONLAZY = 0x40,
 
     // It's undefined behaviour if an enum overflows the range between its
     // smallest and largest values, but since these are |ed together, it can
     // happen. Put a sentinel in (values of this enum are stored as "unsigned
     // char").
     MO_UNUSED_MAXIMUM = 0xff
   };
 

llvm/trunk/lib/Target/X86/X86AsmPrinter.cpp

if (MO.getTargetFlags() == X86II::MO_DARWIN_STUB)
       GVSym = P.getSymbolWithGlobalValueBase(GV, "$stub");
     else if (MO.getTargetFlags() == X86II::MO_DARWIN_NONLAZY ||
              MO.getTargetFlags() == X86II::MO_DARWIN_NONLAZY_PIC_BASE ||
              MO.getTargetFlags() == X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE)
       GVSym = P.getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
     else
       GVSym = P.getSymbol(GV);
 
-    // Handle dllimport linkage.
-    if (MO.getTargetFlags() == X86II::MO_DLLIMPORT)
-      GVSym =
-          P.OutContext.getOrCreateSymbol(Twine("__imp_") + GVSym->getName());
-
     if (MO.getTargetFlags() == X86II::MO_DARWIN_NONLAZY ||
         MO.getTargetFlags() == X86II::MO_DARWIN_NONLAZY_PIC_BASE) {
       MCSymbol *Sym = P.getSymbolWithGlobalValueBase(GV, "$non_lazy_ptr");
       MachineModuleInfoImpl::StubValueTy &StubSym =
           P.MMI->getObjFileInfo<MachineModuleInfoMachO>().getGVStubEntry(Sym);
       if (!StubSym.getPointer())
         StubSym = MachineModuleInfoImpl::
           StubValueTy(P.getSymbol(GV), !GV->hasInternalLinkage());

llvm/trunk/lib/Target/X86/X86MCInstLower.cpp

GetSymbolFromOperand(const MachineOperand &MO) const {
   const DataLayout *DL = TM.getDataLayout();
   assert((MO.isGlobal() || MO.isSymbol() || MO.isMBB()) && "Isn't a symbol reference");
 
   MCSymbol *Sym = nullptr;
   SmallString<128> Name;
   StringRef Suffix;
 
   switch (MO.getTargetFlags()) {
-  case X86II::MO_DLLIMPORT:
-    // Handle dllimport linkage.
-    Name += "__imp_";
-    break;
   case X86II::MO_DARWIN_STUB:
     Suffix = "$stub";
     break;
   case X86II::MO_DARWIN_NONLAZY:
   case X86II::MO_DARWIN_NONLAZY_PIC_BASE:
   case X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE:
     Suffix = "$non_lazy_ptr";
     break;

llvm/trunk/test/Object/dllimport.ll

+; RUN: llvm-as %s -o - | llvm-nm - | FileCheck %s
+
+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc"
+
+; CHECK: U __imp_f
+; CHECK: U __imp_v
+; CHECK: T g
+
+declare dllimport void @f()
+@v = external dllimport global i32
+
+define void @g() {
+  call void @f()
+  store i32 42, i32* @v
+  ret void
+}