[MinGW] [ARM] Add stubs for potential automatic dllimported variables

[mstorsjo]

Summary

The runtime pseudo relocations can't handle the ARM format embedded addresses in movw/movt pairs. By using stubs, the potentially dllimported addresses can be touched up by the runtime pseudo relocation framework.

The MachineOperand TargetFlags range (8 bits) is just about exhausted; this allocates the last bit to MO_COFFSTUB. (In the X86 target, the TargetFlags are just direct values, while most of it is used as a bitfield on ARM and AArch64.) An alternative, to conserve bits, would be to use MO_GOT (which doesn't have much meaning in a COFF context right now).

[rnk]

lgtm, regardless of what we do with the external linkage bit.

lib/Target/ARM/ARMAsmPrinter.cpp

840 ↗

(On Diff #163157)

Maybe we should just pass true here instead of !GV->hasInternalLinkage(). We should never use .refptr stubs to access internal symbols, right? They will always be DSO local, and should be accessible with other means.

We don't even use Stub.second.getInt() in the generic AsmPrinter.cpp code that emits the stub globals.

[mstorsjo]

lib/Target/ARM/ARMAsmPrinter.cpp

840 ↗

(On Diff #163157)

Sounds good; I'll change it similarly in the existing codepath for X86 as well.

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

if (Subtarget->isTargetMachO()) {
     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);
+    bool IsIndirect =
+        (TargetFlags & (ARMII::MO_DLLIMPORT | ARMII::MO_COFFSTUB));
     if (!IsIndirect)
       return getSymbol(GV);
 
     SmallString<128> Name;
+    if (TargetFlags & ARMII::MO_DLLIMPORT)
       Name = "__imp_";
+    else if (TargetFlags & ARMII::MO_COFFSTUB)
+      Name = ".refptr.";
     getNameWithPrefix(Name, GV);
 
-    return OutContext.getOrCreateSymbol(Name);
+    MCSymbol *MCSym = OutContext.getOrCreateSymbol(Name);
+
+    if (TargetFlags & ARMII::MO_COFFSTUB) {
+      MachineModuleInfoCOFF &MMICOFF =
+          MMI->getObjFileInfo<MachineModuleInfoCOFF>();
+      MachineModuleInfoImpl::StubValueTy &StubSym =
+          MMICOFF.getGVStubEntry(MCSym);
+
+      if (!StubSym.getPointer())
+        StubSym = MachineModuleInfoImpl::StubValueTy(getSymbol(GV), true);
+    }
+
+    return MCSym;
   } else if (Subtarget->isTargetELF()) {
     return getSymbol(GV);
   }
   llvm_unreachable("unexpected target");
 }
 
 void ARMAsmPrinter::
 EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) {

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

ARMBaseInstrInfo::getSerializableDirectMachineOperandTargetFlags() const {
   return makeArrayRef(TargetFlags);
 }
 
 ArrayRef<std::pair<unsigned, const char *>>
 ARMBaseInstrInfo::getSerializableBitmaskMachineOperandTargetFlags() const {
   using namespace ARMII;
 
   static const std::pair<unsigned, const char *> TargetFlags[] = {
+      {MO_COFFSTUB, "arm-coffstub"},
       {MO_GOT, "arm-got"},
       {MO_SBREL, "arm-sbrel"},
       {MO_DLLIMPORT, "arm-dllimport"},
       {MO_SECREL, "arm-secrel"},
       {MO_NONLAZY, "arm-nonlazy"}};
   return makeArrayRef(TargetFlags);
 }

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

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");
   assert(!Subtarget->isROPI() && !Subtarget->isRWPI() &&
          "ROPI/RWPI not currently supported for Windows");
 
   const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
-  const ARMII::TOF TargetFlags =
-    (GV->hasDLLImportStorageClass() ? ARMII::MO_DLLIMPORT : ARMII::MO_NO_FLAG);
+  ARMII::TOF TargetFlags = ARMII::MO_NO_FLAG;
+  if (GV->hasDLLImportStorageClass())
+    TargetFlags = ARMII::MO_DLLIMPORT;
+  else if (Subtarget->getTargetTriple().isWindowsGNUEnvironment() &&
+           !GV->isDSOLocal() && GV->isDeclarationForLinker() &&
+           isa<GlobalVariable>(GV))
+    TargetFlags = ARMII::MO_COFFSTUB;
   EVT PtrVT = getPointerTy(DAG.getDataLayout());
   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));
-  if (GV->hasDLLImportStorageClass())
+  if (TargetFlags & (ARMII::MO_DLLIMPORT | ARMII::MO_COFFSTUB))
     Result = DAG.getLoad(PtrVT, DL, DAG.getEntryNode(), Result,
                          MachinePointerInfo::getGOT(DAG.getMachineFunction()));
   return Result;
 }
 
 SDValue
 ARMTargetLowering::LowerEH_SJLJ_SETJMP(SDValue Op, SelectionDAG &DAG) const {
   SDLoc dl(Op);

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

enum TOF {
     /// MO_HI16 - On a symbol operand, this represents a relocation containing
     /// higher 16 bit of the address. Used only via movt instruction.
     MO_HI16 = 0x2,
 
     /// MO_OPTION_MASK - Most flags are mutually exclusive; this mask selects
     /// just that part of the flag set.
     MO_OPTION_MASK = 0x3,
 
+    /// MO_COFFSTUB - On a symbol operand "FOO", this indicates that the
+    /// reference is actually to the ".refptrp.FOO" symbol.  This is used for
+    /// stub symbols on windows.
+    MO_COFFSTUB = 0x4,
+
     /// MO_GOT - On a symbol operand, this represents a GOT relative relocation.
     MO_GOT = 0x8,
 
     /// MO_SBREL - On a symbol operand, this represents a static base relative
     /// relocation. Used in movw and movt instructions.
     MO_SBREL = 0x10,
 
     /// MO_DLLIMPORT - On a symbol operand, this represents that the reference

llvm/trunk/test/CodeGen/ARM/Windows/mingw-refptr.ll

+; RUN: llc < %s -mtriple=thumbv7-w64-mingw32 | FileCheck %s
+
+@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-LABEL: getVar:
+; CHECK:    movw r0, :lower16:.refptr.var
+; CHECK:    movt r0, :upper16:.refptr.var
+; CHECK:    ldr  r0, [r0]
+; CHECK:    ldr  r0, [r0]
+; CHECK:    bx   lr
+entry:
+  %0 = load i32, i32* @var, align 4
+  ret i32 %0
+}
+
+define dso_local i32 @getDsoLocalVar() {
+; CHECK-LABEL: getDsoLocalVar:
+; CHECK:    movw r0, :lower16:dsolocalvar
+; CHECK:    movt r0, :upper16:dsolocalvar
+; CHECK:    ldr  r0, [r0]
+; CHECK:    bx   lr
+entry:
+  %0 = load i32, i32* @dsolocalvar, align 4
+  ret i32 %0
+}
+
+define dso_local i32 @getLocalVar() {
+; CHECK-LABEL: getLocalVar:
+; CHECK:    movw r0, :lower16:localvar
+; CHECK:    movt r0, :upper16:localvar
+; CHECK:    ldr  r0, [r0]
+; CHECK:    bx   lr
+entry:
+  %0 = load i32, i32* @localvar, align 4
+  ret i32 %0
+}
+
+define dso_local i32 @getLocalCommon() {
+; CHECK-LABEL: getLocalCommon:
+; CHECK:    movw r0, :lower16:localcommon
+; CHECK:    movt r0, :upper16:localcommon
+; CHECK:    ldr  r0, [r0]
+; CHECK:    bx   lr
+entry:
+  %0 = load i32, i32* @localcommon, align 4
+  ret i32 %0
+}
+
+define dso_local i32 @getExtVar() {
+; CHECK-LABEL: getExtVar:
+; CHECK:    movw r0, :lower16:__imp_extvar
+; CHECK:    movt r0, :upper16:__imp_extvar
+; CHECK:    ldr  r0, [r0]
+; CHECK:    ldr  r0, [r0]
+; CHECK:    bx   lr
+entry:
+  %0 = load i32, i32* @extvar, align 4
+  ret i32 %0
+}
+
+define dso_local void @callFunc() {
+; CHECK-LABEL: callFunc:
+; CHECK:    b otherFunc
+entry:
+  tail call void @otherFunc()
+  ret void
+}
+
+declare dso_local void @otherFunc()
+
+; CHECK:        .section        .rdata$.refptr.var,"dr",discard,.refptr.var
+; CHECK:        .globl  .refptr.var
+; CHECK: .refptr.var:
+; CHECK:        .long   var

llvm/trunk/test/CodeGen/ARM/Windows/pic.ll

 }
 
 ; CHECK-WIN-LABEL: return_external
 ; CHECK-WIN: movw r0, :lower16:external
 ; CHECK-WIN: movt r0, :upper16:external
 ; CHECK-WIN: ldrb r0, [r0]
 
 ; CHECK-GNU-LABEL: return_external
-; CHECK-GNU: movw r0, :lower16:external
-; CHECK-GNU: movt r0, :upper16:external
+; CHECK-GNU: movw r0, :lower16:.refptr.external
+; CHECK-GNU: movt r0, :upper16:.refptr.external
+; CHECK-GNU: ldr  r0, [r0]
 ; CHECK-GNU: ldrb r0, [r0]

llvm/trunk/test/CodeGen/ARM/emutls_generic.ll

 ; ARM_32-NEXT:   .long 16
 ; ARM_32-NEXT:   .long 0
 ; ARM_32-NEXT:   .long __emutls_t.internal_y
 ; ARM_32-LABEL:  __emutls_t.internal_y:
 ; ARM_32-NEXT:   .long 9
 ; ARM_32-NEXT:   .long 0
 
 ; WIN-LABEL:  get_external_x:
-; WIN:        movw r0, :lower16:__emutls_v.external_x
-; WIN:        movt r0, :upper16:__emutls_v.external_x
+; WIN:        movw r0, :lower16:.refptr.__emutls_v.external_x
+; WIN:        movt r0, :upper16:.refptr.__emutls_v.external_x
+; WIN:        ldr  r0, [r0]
 ; WIN:        bl __emutls_get_address
 ; WIN-LABEL:  get_external_y:
 ; WIN:        movw r0, :lower16:__emutls_v.external_y
 ; WIN:        movt r0, :upper16:__emutls_v.external_y
 ; WIN:        bl __emutls_get_address
 ; WIN-LABEL:  get_internal_y:
 ; WIN:        movw r0, :lower16:__emutls_v.internal_y
 ; WIN:        movt r0, :upper16:__emutls_v.internal_y