[MinGW] [X86] Add stubs for references to data variables that might end up imported from a dll

[mstorsjo]

Summary

Variables declared with the dllimport attribute are accessed via a stub variable named __imp_<var>. In MinGW configurations, variables that aren't declared with a dllimport attribute might still end up imported from another DLL with runtime pseudo relocs.

For x86_64, this avoids the risk that the target is out of range for a 32 bit PC relative reference, in case the target DLL is loaded further than 4 GB from the reference. It also avoids having to make the text section writable at runtime when doing the runtime fixups, which makes it worthwhile to do for i386 as well.

Add stub variables for all dso local data references where a definition of the variable isn't visible within the module, since the DLL data autoimporting might make them imported even though they are marked as dso local within LLVM.

Don't do this for variables that actually are defined within the same module, since we then know for sure that it actually is dso local.

Don't do this for references to functions, since there's no need for runtime pseudo relocations for autoimporting them; if a function from a different DLL is called without the appropriate dllimport attribute, the call just gets routed via a thunk instead.

GCC does something similar since 4.9 (when compiling with -mcmodel=medium or large; from that version, medium is the default code model for x86_64 mingw), but only for x86_64.

This patch both adds the generic support for COFF pointer stubs, and implements it for X86. Later patches implements the same for ARM and AArch64.

[rnk]

I think you need to change clang lib/CodeGen/CodeGenModule.cpp shouldAssumeDSOLocal to stop marking these things as dso_local, and then shouldAssumeDSOLocal will return false, and you can apply your MO_COFFSTUB flag in classifyGlobalReference. Hopefully then everything will make a little more sense.

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1388–1389 ↗

(On Diff #162637)

I was looking for some way to unify this across architectures, but I don't see one. It looks like the MachO assembler implicitly creates stubs for you, similar to how you can use foo@GOT(%rip) and that will make a GOT stub for you on ELF.

test/CodeGen/X86/win32-ssp.ll

12 ↗

(On Diff #162637)

Does mingw provide __stack_chk_guard? Should we use .refptr to access it? I think we should change TargetLoweringBase::insertSSPDeclarations to mark this global dso_local first, so that we don't introduce these extra stubs, if they are not needed.

[mstorsjo]

In D51288#1215140, @rnk wrote:

I think you need to change clang lib/CodeGen/CodeGenModule.cpp shouldAssumeDSOLocal to stop marking these things as dso_local, and then shouldAssumeDSOLocal will return false, and you can apply your MO_COFFSTUB flag in classifyGlobalReference. Hopefully then everything will make a little more sense.

Right, I'll give that a try. That sounds like it would make a little more sense.

test/CodeGen/X86/win32-ssp.ll

12 ↗

(On Diff #162637)

Yes, mingw has got __stack_chk_guard (as part of libssp.a or libssp.dll.a), and it can be linked either statically or dynamically (which we don't know until we see which kind of library the linker finds). So yes, it's intentional that we're using .refptr here.

[mstorsjo]

In D51288#1215685, @mstorsjo wrote:

In D51288#1215140, @rnk wrote:

I think you need to change clang lib/CodeGen/CodeGenModule.cpp shouldAssumeDSOLocal to stop marking these things as dso_local, and then shouldAssumeDSOLocal will return false, and you can apply your MO_COFFSTUB flag in classifyGlobalReference. Hopefully then everything will make a little more sense.

Right, I'll give that a try. That sounds like it would make a little more sense.

Ok, I started off doing that, but once I stop setting DSOLocal on all variables, how would you suggest I'd proceed next? In TargetMachine::shouldAssumeDSOLocal we've got pretty much the same code as in Clang, more or less - even if we don't have the DSOLocal flag set, we run into this block:

bool TargetMachine::shouldAssumeDSOLocal(const Module &M,
                                         const GlobalValue *GV) const {
  if (GV && GV->isDSOLocal())
    return true;

  if (GV && GV->hasDLLImportStorageClass())
    return false;
  
  // Every other GV is local on COFF.
  if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
    return true;

So even if we remove the DSOLocal flag, we end up doing pretty much the same.

It might make sense in the long run to add the same "if (mingw) don'tAssumeEverythingIsDSOLocal();" there - however TargetMachine::shouldAssumeDSOLocal is used in varying ways in X86/ARM/AArch64, so if we change that one, we'd need all three of them to be ready at the same time.

And if I don't change TargetMachine::shouldAssumeDSOLocal quite yet, I don't really see much difference from what this patch does right now. I guess I could use !GV->isDSOLocal() for part of the condition though...

[rnk]

In D51288#1215735, @mstorsjo wrote:

Ok, I started off doing that, but once I stop setting DSOLocal on all variables, how would you suggest I'd proceed next? In TargetMachine::shouldAssumeDSOLocal we've got pretty much the same code as in Clang, more or less - even if we don't have the DSOLocal flag set, we run into this block:

bool TargetMachine::shouldAssumeDSOLocal(const Module &M,
                                         const GlobalValue *GV) const {
  if (GV && GV->isDSOLocal())
    return true;

  if (GV && GV->hasDLLImportStorageClass())
    return false;
  
  // Every other GV is local on COFF.
  if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
    return true;

So even if we remove the DSOLocal flag, we end up doing pretty much the same.

It might make sense in the long run to add the same "if (mingw) don'tAssumeEverythingIsDSOLocal();" there - however TargetMachine::shouldAssumeDSOLocal is used in varying ways in X86/ARM/AArch64, so if we change that one, we'd need all three of them to be ready at the same time.

And if I don't change TargetMachine::shouldAssumeDSOLocal quite yet, I don't really see much difference from what this patch does right now. I guess I could use !GV->isDSOLocal() for part of the condition though...

Well, I think that COFF-specific check in shouldAssumeDSOLocal is intended to go away at some point, once frontends have migrated over to setting dso_local appropriately. Rafael would be able to tell us what he was thinking here, but obviously he's no longer involved with LLVM. I think it would be reasonable to restrict the "if COFF then local" check only apply to non-gnu environments.

Mainly, I don't want the dso_local marker to become a lie, and I think it's nice to be able to mark specific symbols as being local so that we can avoid the .refptr stubs. A little more duplication between clang and llvm is a reasonable cost for that.

@compnerd @smeenai, do you want these .refptr stubs for x86_64-windows-itanium? It seems like they fix a number of COFF/ELF portability issues.

[mstorsjo]

In D51288#1216484, @rnk wrote:

In D51288#1215735, @mstorsjo wrote:

Ok, I started off doing that, but once I stop setting DSOLocal on all variables, how would you suggest I'd proceed next? In TargetMachine::shouldAssumeDSOLocal we've got pretty much the same code as in Clang, more or less - even if we don't have the DSOLocal flag set, we run into this block:

bool TargetMachine::shouldAssumeDSOLocal(const Module &M,
                                         const GlobalValue *GV) const {
  if (GV && GV->isDSOLocal())
    return true;

  if (GV && GV->hasDLLImportStorageClass())
    return false;
  
  // Every other GV is local on COFF.
  if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
    return true;

So even if we remove the DSOLocal flag, we end up doing pretty much the same.

It might make sense in the long run to add the same "if (mingw) don'tAssumeEverythingIsDSOLocal();" there - however TargetMachine::shouldAssumeDSOLocal is used in varying ways in X86/ARM/AArch64, so if we change that one, we'd need all three of them to be ready at the same time.

And if I don't change TargetMachine::shouldAssumeDSOLocal quite yet, I don't really see much difference from what this patch does right now. I guess I could use !GV->isDSOLocal() for part of the condition though...

Well, I think that COFF-specific check in shouldAssumeDSOLocal is intended to go away at some point, once frontends have migrated over to setting dso_local appropriately. Rafael would be able to tell us what he was thinking here, but obviously he's no longer involved with LLVM. I think it would be reasonable to restrict the "if COFF then local" check only apply to non-gnu environments.

Yes, if I understood correctly from the commit history, the whole method was supposed to go away, more or less.

Mainly, I don't want the dso_local marker to become a lie, and I think it's nice to be able to mark specific symbols as being local so that we can avoid the .refptr stubs. A little more duplication between clang and llvm is a reasonable cost for that.

Yup, that makes sense. I'll see what I can do to allow omitting .refptr for things marked dso_local, without refactoring everything all at once.

[mstorsjo]

Adjusted the code to only use .refptr for variables without dso_local.

[rnk]

Thanks, I think this is ready. I guess it doesn't strictly depend on the clang change, so you can go ahead and commit.

[mstorsjo]

lib/Target/X86/X86Subtarget.cpp

146 ↗

(On Diff #162951)

I guess this condition also should be changed similarly, replacing GV->hasExternalLinkage() && GV->isDeclaration() with GV->isDeclarationForLinker()? It doesn't seem to change any of the existing testcases here in LLVM though.

[rnk]

lib/Target/X86/X86Subtarget.cpp

146 ↗

(On Diff #162951)

I wouldn't expect it to, because by the time we get to codegen we've already discarded all available_externally definitions and turned them into declarations.

I just noticed this is x86-specific logic. Do we need COFF stubs more often on ARM, or can we change shouldAssumeDSOLocal to have this logic for all mingw targets?

[mstorsjo]

lib/Target/X86/X86Subtarget.cpp

146 ↗

(On Diff #162951)

Ok - so even if it doesn't change anything, I guess it's good to have the expression match the one used in clang.

Yes, this is x86 specific - I've got later patches for arm and aarch64 in line afterwards. If we were to change shouldAssumeDSOLocal, we'd need to add all of the coffstub logic to arm and aarch64 all at once, and I'd rather do it gradually. Once they all support it, I could try to move the logic into the common shouldAssumeDSOLocal, as a NFC refactoring.

The stubs are essential on arm/aarch64, since the pseudo relocs don't support the arm instruction encodings, only plain pointers/offsets like in x86 relocs. For x86_64 the stubs fix cases when an autoimported variable gets loaded more than 4GB away from %rip at runtime. For x86_32, they avoid having to make the text section writable while fixing the relocs.

[rnk]

lib/Target/X86/X86Subtarget.cpp

146 ↗

(On Diff #162951)

Gradually makes sense.

llvm/trunk/include/llvm/CodeGen/MachineModuleInfoImpls.h

StubValueTy &getGVStubEntry(MCSymbol *Sym) {
     return GVStubs[Sym];
   }
 
   /// Accessor methods to return the set of stubs in sorted order.
 
   SymbolListTy GetGVStubList() { return getSortedStubs(GVStubs); }
 };
 
+/// MachineModuleInfoCOFF - This is a MachineModuleInfoImpl implementation
+/// for COFF targets.
+class MachineModuleInfoCOFF : public MachineModuleInfoImpl {
+  /// GVStubs - These stubs are used to materialize global addresses in PIC
+  /// mode.
+  DenseMap<MCSymbol *, StubValueTy> GVStubs;
+
+  virtual void anchor(); // Out of line virtual method.
+
+public:
+  MachineModuleInfoCOFF(const MachineModuleInfo &) {}
+
+  StubValueTy &getGVStubEntry(MCSymbol *Sym) {
+    assert(Sym && "Key cannot be null");
+    return GVStubs[Sym];
+  }
+
+  /// Accessor methods to return the set of stubs in sorted order.
+
+  SymbolListTy GetGVStubList() { return getSortedStubs(GVStubs); }
+};
+
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_MACHINEMODULEINFOIMPLS_H

llvm/trunk/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
+#include "llvm/BinaryFormat/COFF.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/CodeGen/GCMetadata.h"
 #include "llvm/CodeGen/GCMetadataPrinter.h"
 #include "llvm/CodeGen/GCStrategy.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineConstantPool.h"
 #include "llvm/CodeGen/MachineDominators.h"
if (!Stubs.empty()) {
       for (const auto &Stub : Stubs) {
         OutStreamer->EmitLabel(Stub.first);
         OutStreamer->EmitSymbolValue(Stub.second.getPointer(),
                                      DL.getPointerSize());
       }
     }
   }
 
+  if (TM.getTargetTriple().isOSBinFormatCOFF()) {
+    MachineModuleInfoCOFF &MMICOFF =
+        MMI->getObjFileInfo<MachineModuleInfoCOFF>();
+
+    // Output stubs for external and common global variables.
+    MachineModuleInfoCOFF::SymbolListTy Stubs = MMICOFF.GetGVStubList();
+    if (!Stubs.empty()) {
+      const DataLayout &DL = M.getDataLayout();
+
+      for (const auto &Stub : Stubs) {
+        SmallString<256> SectionName = StringRef(".rdata$");
+        SectionName += Stub.first->getName();
+        OutStreamer->SwitchSection(OutContext.getCOFFSection(
+            SectionName,
+            COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | COFF::IMAGE_SCN_MEM_READ |
+                COFF::IMAGE_SCN_LNK_COMDAT,
+            SectionKind::getReadOnly(), Stub.first->getName(),
+            COFF::IMAGE_COMDAT_SELECT_ANY));
+        EmitAlignment(Log2_32(DL.getPointerSize()));
+        OutStreamer->EmitSymbolAttribute(Stub.first, MCSA_Global);
+        OutStreamer->EmitLabel(Stub.first);
+        OutStreamer->EmitSymbolValue(Stub.second.getPointer(),
+                                     DL.getPointerSize());
+      }
+    }
+  }
+
   // Finalize debug and EH information.
   for (const HandlerInfo &HI : Handlers) {
     NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName,
                        HI.TimerGroupDescription, TimePassesIsEnabled);
     HI.Handler->endModule();
     delete HI.Handler;
   }
   Handlers.clear();

llvm/trunk/lib/CodeGen/MachineModuleInfoImpls.cpp

 
 //===----------------------------------------------------------------------===//
 // MachineModuleInfoMachO
 //===----------------------------------------------------------------------===//
 
 // Out of line virtual method.
 void MachineModuleInfoMachO::anchor() {}
 void MachineModuleInfoELF::anchor() {}
+void MachineModuleInfoCOFF::anchor() {}
 
 using PairTy = std::pair<MCSymbol *, MachineModuleInfoImpl::StubValueTy>;
 static int SortSymbolPair(const PairTy *LHS, const PairTy *RHS) {
   return LHS->first->getName().compare(RHS->first->getName());
 }
 
 MachineModuleInfoImpl::SymbolListTy MachineModuleInfoImpl::getSortedStubs(
     DenseMap<MCSymbol *, MachineModuleInfoImpl::StubValueTy> &Map) {
   MachineModuleInfoImpl::SymbolListTy List(Map.begin(), Map.end());
 
   array_pod_sort(List.begin(), List.end(), SortSymbolPair);
 
   Map.clear();
   return List;
 }

llvm/trunk/lib/Target/X86/MCTargetDesc/X86BaseInfo.h

enum TOF {
     ///
     /// This is the TLS offset for the COFF/Windows TLS mechanism.
     MO_SECREL,
 
     /// MO_ABS8 - On a symbol operand this indicates that the symbol is known
     /// to be an absolute symbol in range [0,128), so we can use the @ABS8
     /// symbol modifier.
     MO_ABS8,
+
+    /// MO_COFFSTUB - On a symbol operand "FOO", this indicates that the
+    /// reference is actually to the ".refptr.FOO" symbol.  This is used for
+    /// stub symbols on windows.
+    MO_COFFSTUB,
   };
 
   enum : uint64_t {
     //===------------------------------------------------------------------===//
     // Instruction encodings.  These are the standard/most common forms for X86
     // instructions.
     //
 

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

if (MO.getTargetFlags() == X86II::MO_DARWIN_NONLAZY ||
       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());
+    else if (MO.getTargetFlags() == X86II::MO_COFFSTUB)
+      GVSym =
+          P.OutContext.getOrCreateSymbol(Twine(".refptr.") + 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::
static void printSymbolOperand(X86AsmPrinter &P, const MachineOperand &MO,
 
   switch (MO.getTargetFlags()) {
   default:
     llvm_unreachable("Unknown target flag on GV operand");
   case X86II::MO_NO_FLAG:    // No flag.
     break;
   case X86II::MO_DARWIN_NONLAZY:
   case X86II::MO_DLLIMPORT:
+  case X86II::MO_COFFSTUB:
     // These affect the name of the symbol, not any suffix.
     break;
   case X86II::MO_GOT_ABSOLUTE_ADDRESS:
     O << " + [.-";
     P.MF->getPICBaseSymbol()->print(O, P.MAI);
     O << ']';
     break;
   case X86II::MO_PIC_BASE_OFFSET:

llvm/trunk/lib/Target/X86/X86InstrInfo.h

 /// a reference to a stub for a global, not the global itself.
 inline static bool isGlobalStubReference(unsigned char TargetFlag) {
   switch (TargetFlag) {
   case X86II::MO_DLLIMPORT:               // dllimport stub.
   case X86II::MO_GOTPCREL:                // rip-relative GOT reference.
   case X86II::MO_GOT:                     // normal GOT reference.
   case X86II::MO_DARWIN_NONLAZY_PIC_BASE: // Normal $non_lazy_ptr ref.
   case X86II::MO_DARWIN_NONLAZY:          // Normal $non_lazy_ptr ref.
+  case X86II::MO_COFFSTUB:                // COFF .refptr stub.
     return true;
   default:
     return false;
   }
 }
 
 /// isGlobalRelativeToPICBase - Return true if the specified global value
 /// reference is relative to a 32-bit PIC base (X86ISD::GlobalBaseReg).  If this

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

static const std::pair<unsigned, const char *> TargetFlags[] = {
       {MO_DTPOFF, "x86-dtpoff"},
       {MO_NTPOFF, "x86-ntpoff"},
       {MO_GOTNTPOFF, "x86-gotntpoff"},
       {MO_DLLIMPORT, "x86-dllimport"},
       {MO_DARWIN_NONLAZY, "x86-darwin-nonlazy"},
       {MO_DARWIN_NONLAZY_PIC_BASE, "x86-darwin-nonlazy-pic-base"},
       {MO_TLVP, "x86-tlvp"},
       {MO_TLVP_PIC_BASE, "x86-tlvp-pic-base"},
-      {MO_SECREL, "x86-secrel"}};
+      {MO_SECREL, "x86-secrel"},
+      {MO_COFFSTUB, "x86-coffstub"}};
   return makeArrayRef(TargetFlags);
 }
 
 namespace {
   /// Create Global Base Reg pass. This initializes the PIC
   /// global base register for x86-32.
   struct CGBR : public MachineFunctionPass {
     static char ID;

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

MCSymbol *X86MCInstLower::GetSymbolFromOperand(const MachineOperand &MO) const {
   SmallString<128> Name;
   StringRef Suffix;
 
   switch (MO.getTargetFlags()) {
   case X86II::MO_DLLIMPORT:
     // Handle dllimport linkage.
     Name += "__imp_";
     break;
+  case X86II::MO_COFFSTUB:
+    Name += ".refptr.";
+    break;
   case X86II::MO_DARWIN_NONLAZY:
   case X86II::MO_DARWIN_NONLAZY_PIC_BASE:
     Suffix = "$non_lazy_ptr";
     break;
   }
 
   if (!Suffix.empty())
     Name += DL.getPrivateGlobalPrefix();
MCSymbol *X86MCInstLower::GetSymbolFromOperand(const MachineOperand &MO) const {
   if (!Sym)
     Sym = Ctx.getOrCreateSymbol(Name);
 
   // If the target flags on the operand changes the name of the symbol, do that
   // before we return the symbol.
   switch (MO.getTargetFlags()) {
   default:
     break;
+  case X86II::MO_COFFSTUB: {
+    MachineModuleInfoCOFF &MMICOFF =
+        MF.getMMI().getObjFileInfo<MachineModuleInfoCOFF>();
+    MachineModuleInfoImpl::StubValueTy &StubSym = MMICOFF.getGVStubEntry(Sym);
+    if (!StubSym.getPointer()) {
+      assert(MO.isGlobal() && "Extern symbol not handled yet");
+      StubSym = MachineModuleInfoImpl::StubValueTy(
+          AsmPrinter.getSymbol(MO.getGlobal()),
+          !MO.getGlobal()->hasInternalLinkage());
+    }
+    break;
+  }
   case X86II::MO_DARWIN_NONLAZY:
   case X86II::MO_DARWIN_NONLAZY_PIC_BASE: {
     MachineModuleInfoImpl::StubValueTy &StubSym =
         getMachOMMI().getGVStubEntry(Sym);
     if (!StubSym.getPointer()) {
       assert(MO.isGlobal() && "Extern symbol not handled yet");
       StubSym = MachineModuleInfoImpl::StubValueTy(
           AsmPrinter.getSymbol(MO.getGlobal()),
MCOperand X86MCInstLower::LowerSymbolOperand(const MachineOperand &MO,
 
   switch (MO.getTargetFlags()) {
   default:
     llvm_unreachable("Unknown target flag on GV operand");
   case X86II::MO_NO_FLAG: // No flag.
   // These affect the name of the symbol, not any suffix.
   case X86II::MO_DARWIN_NONLAZY:
   case X86II::MO_DLLIMPORT:
+  case X86II::MO_COFFSTUB:
     break;
 
   case X86II::MO_TLVP:
     RefKind = MCSymbolRefExpr::VK_TLVP;
     break;
   case X86II::MO_TLVP_PIC_BASE:
     Expr = MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_TLVP, Ctx);
     // Subtract the pic base.

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

if (Optional<ConstantRange> CR = GV->getAbsoluteSymbolRange()) {
       // accept the range [0,128).
       if (CR->getUnsignedMax().ult(128))
         return X86II::MO_ABS8;
       else
         return X86II::MO_NO_FLAG;
     }
   }
 
+  // For MinGW, if a data reference isn't marked as DSO local or DLLImport,
+  // and it's a pure declaration without a definition, it might potentially
+  // be automatically imported from another DLL, thus route accesses via a stub.
+  if (isTargetWindowsGNU() && GV && !GV->isDSOLocal() &&
+      !GV->hasDLLImportStorageClass() && GV->isDeclarationForLinker() &&
+      isa<GlobalVariable>(GV))
+    return X86II::MO_COFFSTUB;
+
   if (TM.shouldAssumeDSOLocal(M, GV))
     return classifyLocalReference(GV);
 
   if (isTargetCOFF())
     return X86II::MO_DLLIMPORT;
 
   if (is64Bit()) {
     // ELF supports a large, truly PIC code model with non-PC relative GOT

llvm/trunk/test/CodeGen/X86/br-fold.ll

 ; RUN: llc -mtriple=x86_64-apple-darwin < %s | FileCheck  -check-prefix=X64_DARWIN %s
 ; RUN: llc -mtriple=x86_64-pc-linux < %s | FileCheck  -check-prefix=X64_LINUX %s
 ; RUN: llc -mtriple=x86_64-pc-windows < %s | FileCheck  -check-prefix=X64_WINDOWS %s
 ; RUN: llc -mtriple=x86_64-pc-windows-gnu < %s | FileCheck  -check-prefix=X64_WINDOWS_GNU %s
 ; RUN: llc -mtriple=x86_64-scei-ps4 < %s | FileCheck -check-prefix=PS4 %s
 
 ; X64_DARWIN: orq
 ; X64-DARWIN-NEXT: ud2
 
 ; X64_LINUX: orq %rax, %rcx
 ; X64_LINUX-NEXT: jne
 ; X64_LINUX-NEXT: %bb8.i329
 
 ; X64_WINDOWS: orq %rax, %rcx
 ; X64_WINDOWS-NEXT: ud2
 
-; X64_WINDOWS_GNU: orq %rax, %rcx
+; X64_WINDOWS_GNU: movq .refptr._ZN11xercesc_2_513SchemaSymbols21fgURI_SCHEMAFORSCHEMAE(%rip), %rax
+; X64_WINDOWS_GNU: orq .refptr._ZN11xercesc_2_56XMLUni16fgNotationStringE(%rip), %rax
 ; X64_WINDOWS_GNU-NEXT: ud2
 
 ; PS4: orq %rax, %rcx
 ; PS4-NEXT: ud2
 
 @_ZN11xercesc_2_513SchemaSymbols21fgURI_SCHEMAFORSCHEMAE = external constant [33 x i16], align 32 ; <[33 x i16]*> [#uses=1]
 @_ZN11xercesc_2_56XMLUni16fgNotationStringE = external constant [9 x i16], align 16 ; <[9 x i16]*> [#uses=1]
 

llvm/trunk/test/CodeGen/X86/mingw-refptr.ll

+; RUN: llc < %s -mtriple=x86_64-w64-mingw32 | FileCheck %s -check-prefix=CHECK-X64
+; RUN: llc < %s -mtriple=i686-w64-mingw32 | FileCheck %s -check-prefix=CHECK-X86
+
+@var = external local_unnamed_addr global i32, align 4
+@dsolocalvar = external dso_local local_unnamed_addr global i32, align 4
+@localvar = dso_local local_unnamed_addr global i32 0, align 4
+@localcommon = common dso_local local_unnamed_addr global i32 0, align 4
+@extvar = external dllimport local_unnamed_addr global i32, align 4
+
+define dso_local i32 @getVar() {
+; CHECK-X64-LABEL: getVar:
+; CHECK-X64:    movq .refptr.var(%rip), %rax
+; CHECK-X64:    movl (%rax), %eax
+; CHECK-X64:    retq
+; CHECK-X86-LABEL: _getVar:
+; CHECK-X86:    movl .refptr._var, %eax
+; CHECK-X86:    movl (%eax), %eax
+; CHECK-X86:    retl
+entry:
+  %0 = load i32, i32* @var, align 4
+  ret i32 %0
+}
+
+define dso_local i32 @getDsoLocalVar() {
+; CHECK-X64-LABEL: getDsoLocalVar:
+; CHECK-X64:    movl dsolocalvar(%rip), %eax
+; CHECK-X64:    retq
+; CHECK-X86-LABEL: _getDsoLocalVar:
+; CHECK-X86:    movl _dsolocalvar, %eax
+; CHECK-X86:    retl
+entry:
+  %0 = load i32, i32* @dsolocalvar, align 4
+  ret i32 %0
+}
+
+define dso_local i32 @getLocalVar() {
+; CHECK-X64-LABEL: getLocalVar:
+; CHECK-X64:    movl localvar(%rip), %eax
+; CHECK-X64:    retq
+; CHECK-X86-LABEL: _getLocalVar:
+; CHECK-X86:    movl _localvar, %eax
+; CHECK-X86:    retl
+entry:
+  %0 = load i32, i32* @localvar, align 4
+  ret i32 %0
+}
+
+define dso_local i32 @getLocalCommon() {
+; CHECK-X64-LABEL: getLocalCommon:
+; CHECK-X64:    movl localcommon(%rip), %eax
+; CHECK-X64:    retq
+; CHECK-X86-LABEL: _getLocalCommon:
+; CHECK-X86:    movl _localcommon, %eax
+; CHECK-X86:    retl
+entry:
+  %0 = load i32, i32* @localcommon, align 4
+  ret i32 %0
+}
+
+define dso_local i32 @getExtVar() {
+; CHECK-X64-LABEL: getExtVar:
+; CHECK-X64:    movq __imp_extvar(%rip), %rax
+; CHECK-X64:    movl (%rax), %eax
+; CHECK-X64:    retq
+; CHECK-X86-LABEL: _getExtVar:
+; CHECK-X86:    movl __imp__extvar, %eax
+; CHECK-X86:    movl (%eax), %eax
+; CHECK-X86:    retl
+entry:
+  %0 = load i32, i32* @extvar, align 4
+  ret i32 %0
+}
+
+define dso_local void @callFunc() {
+; CHECK-X64-LABEL: callFunc:
+; CHECK-X64:    jmp otherFunc
+; CHECK-X86-LABEL: _callFunc:
+; CHECK-X86:    jmp _otherFunc
+entry:
+  tail call void @otherFunc()
+  ret void
+}
+
+declare dso_local void @otherFunc()
+
+; CHECK-X64:        .section        .rdata$.refptr.var,"dr",discard,.refptr.var
+; CHECK-X64:        .globl  .refptr.var
+; CHECK-X64: .refptr.var:
+; CHECK-X64:        .quad   var
+
+; CHECK-X86:        .section        .rdata$.refptr._var,"dr",discard,.refptr._var
+; CHECK-X86:        .globl  .refptr._var
+; CHECK-X86: .refptr._var:
+; CHECK-X86:        .long   _var

llvm/trunk/test/CodeGen/X86/stack-protector.ll

 ; OPENBSD-AMD64: movq __guard_local(%rip)
 ; OPENBSD-AMD64: callq __stack_smash_handler
 
 ; MSVC-I386-LABEL: test1b:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
 
 ; MINGW-X64-LABEL: test1b:
-; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: mov{{l|q}} .refptr.__stack_chk_guard
 ; MINGW-X64: callq __stack_chk_fail
 
   %a.addr = alloca i8*, align 8
   %buf = alloca [16 x i8], align 16
   store i8* %a, i8** %a.addr, align 8
   %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)

 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test1c:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
 
 ; MINGW-X64-LABEL: test1c:
-; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: mov{{l|q}} .refptr.__stack_chk_guard
 ; MINGW-X64: callq __stack_chk_fail
 
   %a.addr = alloca i8*, align 8
   %buf = alloca [16 x i8], align 16
   store i8* %a, i8** %a.addr, align 8
   %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)

 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test1d:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
 
 ; MINGW-X64-LABEL: test1d:
-; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: mov{{l|q}} .refptr.__stack_chk_guard
 ; MINGW-X64: callq __stack_chk_fail
 
   %a.addr = alloca i8*, align 8
   %buf = alloca [16 x i8], align 16
   store i8* %a, i8** %a.addr, align 8
   %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)

 ; LINUX-KERNEL-X64: mov{{l|q}} %gs:
 ; LINUX-KERNEL-X64: callq __stack_chk_fail
 
 ; DARWIN-X64-LABEL: test2b:
 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MINGW-X64-LABEL: test2b:
-; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: mov{{l|q}} .refptr.__stack_chk_guard
 ; MINGW-X64: callq __stack_chk_fail
 
   %a.addr = alloca i8*, align 8
   %b = alloca %struct.foo, align 1
   store i8* %a, i8** %a.addr, align 8
   %buf = getelementptr inbounds %struct.foo, %struct.foo* %b, i32 0, i32 0
   %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8

 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test2c:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
 
 ; MINGW-X64-LABEL: test2c:
-; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: mov{{l|q}} .refptr.__stack_chk_guard
 ; MINGW-X64: callq __stack_chk_fail
 
   %a.addr = alloca i8*, align 8
   %b = alloca %struct.foo, align 1
   store i8* %a, i8** %a.addr, align 8
   %buf = getelementptr inbounds %struct.foo, %struct.foo* %b, i32 0, i32 0
   %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8

 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test2d:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
 
 ; MINGW-X64-LABEL: test2d:
-; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: mov{{l|q}} .refptr.__stack_chk_guard
 ; MINGW-X64: callq __stack_chk_fail
 
   %a.addr = alloca i8*, align 8
   %b = alloca %struct.foo, align 1
   store i8* %a, i8** %a.addr, align 8
   %buf = getelementptr inbounds %struct.foo, %struct.foo* %b, i32 0, i32 0
   %arraydecay = getelementptr inbounds [16 x i8], [16 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8

 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test3c:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
 
 ; MINGW-X64-LABEL: test3c:
-; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: mov{{l|q}} .refptr.__stack_chk_guard
 ; MINGW-X64: callq __stack_chk_fail
 
   %a.addr = alloca i8*, align 8
   %buf = alloca [4 x i8], align 1
   store i8* %a, i8** %a.addr, align 8
   %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)

 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test3d:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
 
 ; MINGW-X64-LABEL: test3d:
-; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: mov{{l|q}} .refptr.__stack_chk_guard
 ; MINGW-X64: callq __stack_chk_fail
 
   %a.addr = alloca i8*, align 8
   %buf = alloca [4 x i8], align 1
   store i8* %a, i8** %a.addr, align 8
   %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i8* @strcpy(i8* %arraydecay, i8* %0)

 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test4c:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
 
 ; MINGW-X64-LABEL: test4c:
-; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: mov{{l|q}} .refptr.__stack_chk_guard
 ; MINGW-X64: callq __stack_chk_fail
 
   %a.addr = alloca i8*, align 8
   %b = alloca %struct.foo.0, align 1
   store i8* %a, i8** %a.addr, align 8
   %buf = getelementptr inbounds %struct.foo.0, %struct.foo.0* %b, i32 0, i32 0
   %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8

 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test4d:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
 
 ; MINGW-X64-LABEL: test4d:
-; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: mov{{l|q}} .refptr.__stack_chk_guard
 ; MINGW-X64: callq __stack_chk_fail
 
   %a.addr = alloca i8*, align 8
   %b = alloca %struct.foo.0, align 1
   store i8* %a, i8** %a.addr, align 8
   %buf = getelementptr inbounds %struct.foo.0, %struct.foo.0* %b, i32 0, i32 0
   %arraydecay = getelementptr inbounds [4 x i8], [4 x i8]* %buf, i32 0, i32 0
   %0 = load i8*, i8** %a.addr, align 8

 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test5d:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
 
 ; MINGW-X64-LABEL: test5d:
-; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: mov{{l|q}} .refptr.__stack_chk_guard
 ; MINGW-X64: callq __stack_chk_fail
 
   %a.addr = alloca i8*, align 8
   store i8* %a, i8** %a.addr, align 8
   %0 = load i8*, i8** %a.addr, align 8
   %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %0)
   ret void
 }

 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test6c:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
 
 ; MINGW-X64-LABEL: test6c:
-; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: mov{{l|q}} .refptr.__stack_chk_guard
 ; MINGW-X64: callq __stack_chk_fail
 
   %retval = alloca i32, align 4
   %a = alloca i32, align 4
   %j = alloca i32*, align 8
   store i32 0, i32* %retval
   %0 = load i32, i32* %a, align 4
   %add = add nsw i32 %0, 1

 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test6d:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
 
 ; MINGW-X64-LABEL: test6d:
-; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: mov{{l|q}} .refptr.__stack_chk_guard
 ; MINGW-X64: callq __stack_chk_fail
 
   %retval = alloca i32, align 4
   %a = alloca i32, align 4
   %j = alloca i32*, align 8
   store i32 0, i32* %retval
   %0 = load i32, i32* %a, align 4
   %add = add nsw i32 %0, 1

 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test7c:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
 
 ; MINGW-X64-LABEL: test7c:
-; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: mov{{l|q}} .refptr.__stack_chk_guard
 ; MINGW-X64: .seh_endproc
 
   %a = alloca i32, align 4
   %0 = ptrtoint i32* %a to i64
   %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i64 %0)
   ret void
 }
 

 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test7d:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
 
 ; MINGW-X64-LABEL: test7d:
-; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: mov{{l|q}} .refptr.__stack_chk_guard
 ; MINGW-X64: callq __stack_chk_fail
 
   %a = alloca i32, align 4
   %0 = ptrtoint i32* %a to i64
   %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i64 %0)
   ret void
 }
 

 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test8c:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
 
 ; MINGW-X64-LABEL: test8c:
-; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: mov{{l|q}} .refptr.__stack_chk_guard
 ; MINGW-X64: callq __stack_chk_fail
 
   %b = alloca i32, align 4
   call void @funcall(i32* %b)
   ret void
 }
 
 ; test8d:  Passing addr-of to function call

 ; DARWIN-X64: mov{{l|q}} ___stack_chk_guard
 ; DARWIN-X64: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test8d:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
 
 ; MINGW-X64-LABEL: test8d:
-; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: mov{{l|q}} .refptr.__stack_chk_guard
 ; MINGW-X64: callq __stack_chk_fail
 
   %b = alloca i32, align 4
   call void @funcall(i32* %b)
   ret void
 }
 
 ; test9a:  Addr-of in select instruction

 ; DARWIN-X64: callq ___stack_chk_fail
 ; DARWIN-X64-NOT: callq ___stack_chk_fail
 
 ; MSVC-I386-LABEL: test19d:
 ; MSVC-I386: movl ___security_cookie,
 ; MSVC-I386: calll @__security_check_cookie@4
 
 ; MINGW-X64-LABEL: test19d:
-; MINGW-X64: mov{{l|q}} __stack_chk_guard
+; MINGW-X64: mov{{l|q}} .refptr.__stack_chk_guard
 ; MINGW-X64: callq __stack_chk_fail
 
   %c = alloca %struct.pair, align 4
   %exn.slot = alloca i8*
   %ehselector.slot = alloca i32
   %a = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 0
   store i32 0, i32* %a, align 4
   %a1 = getelementptr inbounds %struct.pair, %struct.pair* %c, i32 0, i32 0

llvm/trunk/test/CodeGen/X86/win32-ssp.ll

 ; RUN: llc -mtriple=x86_64-w64-mingw32        < %s -o - | FileCheck --check-prefix=MINGW %s
 ; RUN: llc -mtriple=x86_64-pc-windows-itanium < %s -o - | FileCheck --check-prefix=MSVC  %s
 ; RUN: llc -mtriple=x86_64-pc-windows-msvc    < %s -o - | FileCheck --check-prefix=MSVC  %s
 
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
 declare dso_local void @other(i8*)
 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
 
 define dso_local void @func() sspstrong {
 entry:
 ; MINGW-LABEL: func:
-; MINGW: mov{{l|q}}  __stack_chk_guard
+; MINGW: mov{{l|q}}  .refptr.__stack_chk_guard(%rip), [[REG:%[a-z]+]]
+; MINGW: mov{{l|q}}  ([[REG]])
 ; MINGW: callq other
-; MINGW: mov{{l|q}}  __stack_chk_guard
+; MINGW: mov{{l|q}}  ([[REG]])
 ; MINGW: callq __stack_chk_fail
 ; MINGW: .seh_endproc
 
 ; MSVC-LABEL: func:
 ; MSVC: mov{{l|q}} __security_cookie
 ; MSVC: callq other
 ; MSVC: callq __security_check_cookie
 ; MSVC: .seh_endproc
 
   %c = alloca i8, align 1
   call void @llvm.lifetime.start.p0i8(i64 1, i8* nonnull %c)
   call void @other(i8* nonnull %c)
   call void @llvm.lifetime.end.p0i8(i64 1, i8* nonnull %c)
   ret void
 }