ARM: enable long calls for WoA

[abdulras]

Summary

Enable long calls on WoA. While this may not be the most efficient approach,
the MSVC compiler also generates long calls for most scenarios. Ideally, all
local symbols would be relaxed during CG to normal calls. However, in the
scenario of external symbols, you do not know the required range for the jump,
and thus require long calls.

[grosbach]

Perhaps a new predicate function like ARMTargetLowering::useLongCalls() that contains the compound check rather than putting it inline here?

[abdulras]

Introduce usesLongCalls and use that in place of Windows specifically in the ISelLowering.

[abdulras]

As Jim mentioned at the beginning, that there is some overhead to this, and enabling this unconditionally seems a bit heavy handed. By improving the driver to be a bit more similar to gcc (adding support for -mlong-calls/-mno-long-calls), we can enable this as and when it is needed as the linker should indicate that the jump target is out of range.

[t.p.northover]

Hi Saleem,

This looks reasonable to me.

Cheers.

Tim.

lib/Target/ARM/ARMISelLowering.cpp

   // If the callee is a GlobalAddress/ExternalSymbol node (quite common, every
   // direct call is) turn it into a TargetGlobalAddress/TargetExternalSymbol
   // node so that legalize doesn't hack it.
   bool isDirect = false;
   bool isARMFunc = false;
   bool isLocalARMFunc = false;
   ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
 
-  if (EnableARMLongCalls) {
-    assert (getTargetMachine().getRelocationModel() == Reloc::Static
+  if (EnableARMLongCalls || Subtarget->usesLongCalls()) {
+    assert ((getTargetMachine().getRelocationModel() == Reloc::Static ||
+             Subtarget->isTargetWindows())
             && "long-calls with non-static relocation model!");
     // Handle a global address or an external symbol. If it's not one of
     // those, the target's already in a register, so we don't need to do
     // anything extra.
     if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
       const GlobalValue *GV = G->getGlobal();
       // Create a constant pool entry for the callee address
       unsigned ARMPCLabelIndex = AFI->createPICLabelUId();

lib/Target/ARM/ARMSubtarget.h

protected:
   /// imms (including global addresses).
   bool UseMovt;
 
   /// SupportsTailCall - True if the OS supports tail call. The dynamic linker
   /// must be able to synthesize call stubs for interworking between ARM and
   /// Thumb.
   bool SupportsTailCall;
 
+  /// UsesLongCalls - True if the OS uses long calls.
+  bool UsesLongCalls;
+
   /// HasFP16 - True if subtarget supports half-precision FP (We support VFP+HF
   /// only so far)
   bool HasFP16;
 
   /// HasD16 - True if subtarget is limited to 16 double precision
   /// FP registers for VFPv3.
   bool HasD16;
 
public:
   bool isRClass() const { return ARMProcClass == RClass; }
   bool isAClass() const { return ARMProcClass == AClass; }
 
   bool isR9Reserved() const { return IsR9Reserved; }
 
   bool useMovt() const { return UseMovt && !isMinSize(); }
   bool supportsTailCall() const { return SupportsTailCall; }
 
+  bool usesLongCalls() const { return UsesLongCalls; }
+
   bool allowsUnalignedMem() const { return AllowsUnalignedMem; }
 
   bool restrictIT() const { return RestrictIT; }
 
   const std::string & getCPUString() const { return CPUString; }
 
   bool isLittle() const { return IsLittle; }
 

lib/Target/ARM/ARMSubtarget.cpp

void ARMSubtarget::initializeEnvironment() {
   SlowFPBrcc = false;
   InThumbMode = false;
   HasThumb2 = false;
   NoARM = false;
   PostRAScheduler = false;
   IsR9Reserved = ReserveR9;
   UseMovt = false;
   SupportsTailCall = false;
+  UsesLongCalls = false;
   HasFP16 = false;
   HasD16 = false;
   HasHardwareDivide = false;
   HasHardwareDivideInARM = false;
   HasT2ExtractPack = false;
   HasDataBarrier = false;
   Pref32BitThumb = false;
   AvoidCPSRPartialUpdate = false;
default:
       break;
     }
   }
 
   // FIXME: this is invalid for WindowsCE
   if (isTargetWindows()) {
     TargetABI = ARM_ABI_AAPCS;
     NoARM = true;
+
+    UsesLongCalls = true;
   }
 
   if (isAAPCS_ABI())
     stackAlignment = 8;
   if (isTargetNaCl())
     stackAlignment = 16;
 
   UseMovt = hasV6T2Ops() && ArmUseMOVT;

test/CodeGen/ARM/Windows/calls.ll

+; RUN: llc -mtriple=thumbv7-windows -mcpu=cortex-a9 -o - %s | FileCheck %s
+
+declare void @external()
+
+define void @internal() nounwind {
+entry:
+  ret void
+}
+
+define void @call_external() nounwind {
+entry:
+  tail call void @external()
+  ret void
+}
+
+define void @call_internal() nounwind {
+entry:
+  tail call void @internal()
+  ret void
+}
+
+; CHECK: call_external:
+; CHECK:  ldr r0, .L[[CPI:[^ ]*]]
+; CHECK:  bx  r0
+; CHECK: .align 2
+; CHECK: .L[[CPI]]
+; CHECK:  .long external
+
+; CHECK: call_internal
+; CHECK:  ldr r0, .L[[CPI:[^ ]*]]
+; FIXME: relax this to a bl function
+; CHECK:  bx  r0
+; CHECK: .align 2
+; CHECK: .L[[CPI]]
+; CHECK:  .long internal
+