Define a subtarget feature to force stack realignment

[ahatanak]

Summary

This patch defines a subtarget feature to force stack realignment and removes cl::opt option force-stack-align. This change is needed to enable forcing stack realignment when doing LTO. The subtarget features each target defines should be removed in the future once we have a way to define target-independent "generic" subtarget features.

[ahatanak]

I think we can make changes to X86TTIImpl::areInlineCompatible if we want to be stricter and reject inlining when the caller and callee disagree on "force-align-stack". The current code would allow inlining if the caller had feature "force-align-stack" and the callee did not.

[hfinkel]

I don't think this is the right design for this feature: Forcing essentially all targets to add the same subtarget feature and associated logic is not good.

Instead, please add this to include/llvm/Target/TargetOptions.h, and add default handling in lib/Target/TargetMachine.cpp (command-line options, function attributes, etc.).

[echristo]

Hi Hal,

We specifically didn't do that for soft-float. I don't know if we want to look at this as "a step too far", but that's where we've been. I'm fine with revisiting that decision - I didn't have a strong opinion either way.

-eric

[ahatanak]

Use function attribute "force-align-stack" instead of defining a subtarget feature for each target and move cl::opt option ForceAlignStack to CommandFlags.h so that tools like llc can write the function attribute to the IR. It really should be an enum attribute because it's target independent, but I used a string attribute here to make it consistent with "no-realign-stack".

[ahatanak]

The updated patch makes the following changes:

• Use function attribute "stackrealign" to decide whether stack realignment should happen.
• Rename "force-align-stack" to "stackrealign" to be consistent with the function attribute.

I also think function attribute "no-realign-stack" should be a cl::opt option since it is used for debugging purposes. I plan to make the changes in a follow-up patch.

llvm/trunk/include/llvm/CodeGen/CommandFlags.h

DisableTailCalls("disable-tail-calls",
                  cl::desc("Never emit tail calls"),
                  cl::init(false));
 
 cl::opt<unsigned>
 OverrideStackAlignment("stack-alignment",
                        cl::desc("Override default stack alignment"),
                        cl::init(0));
 
+cl::opt<bool>
+StackRealign("stackrealign",
+             cl::desc("Force align the stack to the minimum alignment"),
+             cl::init(false));
+
 cl::opt<std::string>
 TrapFuncName("trap-func", cl::Hidden,
         cl::desc("Emit a call to trap function rather than a trap instruction"),
         cl::init(""));
 
 cl::opt<bool>
 EnablePIE("enable-pie",
           cl::desc("Assume the creation of a position independent executable."),
if (DisableFPElim.getNumOccurrences() > 0)
                                        "no-frame-pointer-elim",
                                        DisableFPElim ? "true" : "false");
 
     if (DisableTailCalls.getNumOccurrences() > 0)
       NewAttrs = NewAttrs.addAttribute(Ctx, AttributeSet::FunctionIndex,
                                        "disable-tail-calls",
                                        toStringRef(DisableTailCalls));
 
+    if (StackRealign)
+      NewAttrs = NewAttrs.addAttribute(Ctx, AttributeSet::FunctionIndex,
+                                       "stackrealign");
+
     if (TrapFuncName.getNumOccurrences() > 0)
       for (auto &B : F)
         for (auto &I : B)
           if (auto *Call = dyn_cast<CallInst>(&I))
             if (const auto *F = Call->getCalledFunction())
               if (F->getIntrinsicID() == Intrinsic::debugtrap ||
                   F->getIntrinsicID() == Intrinsic::trap)
                 Call->addAttribute(llvm::AttributeSet::FunctionIndex,

llvm/trunk/include/llvm/Target/TargetRegisterInfo.h

 class BitVector;
 class MachineFunction;
 class RegScavenger;
 template<class T> class SmallVectorImpl;
 class VirtRegMap;
 class raw_ostream;
 class LiveRegMatrix;
 
-extern cl::opt<bool> ForceStackAlign;
-
 class TargetRegisterClass {
 public:
   typedef const MCPhysReg* iterator;
   typedef const MCPhysReg* const_iterator;
   typedef const MVT::SimpleValueType* vt_iterator;
   typedef const TargetRegisterClass* const * sc_iterator;
 
   // Instance variables filled by tablegen, do not use!

llvm/trunk/lib/CodeGen/TargetRegisterInfo.cpp

 #include "llvm/IR/Function.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetFrameLowering.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 
 #define DEBUG_TYPE "target-reg-info"
 
-namespace llvm {
-cl::opt<bool>
-    ForceStackAlign("force-align-stack",
-                    cl::desc("Force align the stack to the minimum alignment"
-                             " needed for the function."),
-                    cl::init(false), cl::Hidden);
-} // end namespace llvm
-
 using namespace llvm;
 
 TargetRegisterInfo::TargetRegisterInfo(const TargetRegisterInfoDesc *ID,
                              regclass_iterator RCB, regclass_iterator RCE,
                              const char *const *SRINames,
                              const unsigned *SRILaneMasks,
                              unsigned SRICoveringLanes)
   : InfoDesc(ID), SubRegIndexNames(SRINames),

 bool TargetRegisterInfo::needsStackRealignment(
     const MachineFunction &MF) const {
   const MachineFrameInfo *MFI = MF.getFrameInfo();
   const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
   const Function *F = MF.getFunction();
   unsigned StackAlign = TFI->getStackAlignment();
   bool requiresRealignment = ((MFI->getMaxAlignment() > StackAlign) ||
                               F->hasFnAttribute(Attribute::StackAlignment));
-  if (ForceStackAlign || requiresRealignment) {
+  if (MF.getFunction()->hasFnAttribute("stackrealign") || requiresRealignment) {
     if (canRealignStack(MF))
       return true;
     DEBUG(dbgs() << "Can't realign function's stack: " << F->getName() << "\n");
   }
   return false;
 }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 void
 TargetRegisterInfo::dumpReg(unsigned Reg, unsigned SubRegIndex,
                             const TargetRegisterInfo *TRI) {
   dbgs() << PrintReg(Reg, TRI, SubRegIndex) << "\n";
 }
 #endif

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

 // If we're forcing a stack realignment we can't rely on just the frame
 // info, we need to know the ABI stack alignment as well in case we
 // have a call out.  Otherwise just make sure we have some alignment - we'll
 // go with the minimum SlotSize.
 uint64_t X86FrameLowering::calculateMaxStackAlign(const MachineFunction &MF) const {
   const MachineFrameInfo *MFI = MF.getFrameInfo();
   uint64_t MaxAlign = MFI->getMaxAlignment(); // Desired stack alignment.
   unsigned StackAlign = getStackAlignment();
-  if (ForceStackAlign) {
+  if (MF.getFunction()->hasFnAttribute("stackrealign")) {
     if (MFI->hasCalls())
       MaxAlign = (StackAlign > MaxAlign) ? StackAlign : MaxAlign;
     else if (MaxAlign < SlotSize)
       MaxAlign = SlotSize;
   }
   return MaxAlign;
 }
 

llvm/trunk/test/CodeGen/Generic/ForceStackAlign.ll

 ; Check that stack alignment can be forced. Individual targets should test their
 ; specific implementation details.
 
-; RUN: llc < %s -force-align-stack -stack-alignment=32 | FileCheck %s
+; RUN: llc < %s -stackrealign -stack-alignment=32 | FileCheck %s
 ; CHECK-LABEL: @f
 ; CHECK-LABEL: @g
 
 define i32 @f(i8* %p) nounwind {
 entry:
   %0 = load i8, i8* %p
   %conv = sext i8 %0 to i32
   ret i32 %conv

llvm/trunk/test/CodeGen/X86/dynamic-allocas-VLAs.ll

 ; RUN: llc < %s -mcpu=generic -march=x86-64 -mattr=+avx -mtriple=i686-apple-darwin10 | FileCheck %s
-; RUN: llc < %s -mcpu=generic -force-align-stack -stack-alignment=32 -march=x86-64 -mattr=+avx -mtriple=i686-apple-darwin10 | FileCheck %s -check-prefix=FORCE-ALIGN
+; RUN: llc < %s -mcpu=generic -stackrealign -stack-alignment=32 -march=x86-64 -mattr=+avx -mtriple=i686-apple-darwin10 | FileCheck %s -check-prefix=FORCE-ALIGN
 ; rdar://11496434
 
 ; no VLAs or dynamic alignment
 define i32 @t1() nounwind uwtable ssp {
 entry:
   %a = alloca i32, align 4
   call void @t1_helper(i32* %a) nounwind
   %0 = load i32, i32* %a, align 4

llvm/trunk/test/CodeGen/X86/force-align-stack-alloca.ll

 ; This test is attempting to detect when we request forced re-alignment of the
 ; stack to an alignment greater than would be available due to the ABI. We
 ; arbitrarily force alignment up to 32-bytes for i386 hoping that this will
 ; exceed any ABI provisions.
 ;
-; RUN: llc < %s -mcpu=generic -force-align-stack -stack-alignment=32 | FileCheck %s
+; RUN: llc < %s -mcpu=generic -stackrealign -stack-alignment=32 | FileCheck %s
 
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32-S128"
 target triple = "i386-unknown-linux-gnu"
 
 define i32 @f(i8* %p) nounwind {
 entry:
   %0 = load i8, i8* %p
   %conv = sext i8 %0 to i32

llvm/trunk/test/CodeGen/X86/force-align-stack.ll

-; RUN: llc < %s -relocation-model=static -force-align-stack | FileCheck %s
+; RUN: llc < %s -relocation-model=static -stackrealign | FileCheck %s
 ; Tests to make sure that we always align the stack out to the minimum needed - 
 ; in this case 16-bytes.
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32"
 target triple = "i386-apple-darwin10.3"
 
 define void @a() nounwind ssp {
 entry:
 ; CHECK: _a:

llvm/trunk/test/CodeGen/X86/inline-asm-sp-clobber-memcpy.ll

-; RUN: llc < %s -force-align-stack -mtriple i386-apple-darwin -mcpu=i486 | FileCheck %s
+; RUN: llc < %s -stackrealign -mtriple i386-apple-darwin -mcpu=i486 | FileCheck %s
 
 %struct.foo = type { [88 x i8] }
 
 declare void @bar(i8* nocapture, %struct.foo* align 4 byval) nounwind
 
 ; PR19012
 ; Don't clobber %esi if we have inline asm that clobbers %esp.
 define void @test1(%struct.foo* nocapture %x, i32 %y, i8* %z) nounwind {
   call void @bar(i8* %z, %struct.foo* align 4 byval %x)
   call void asm sideeffect inteldialect "xor esp, esp", "=*m,~{flags},~{esp},~{esp},~{dirflag},~{fpsr},~{flags}"(i8* %z)
   ret void
 
 ; CHECK-LABEL: test1:
 ; CHECK: movl %esp, %esi
 ; CHECK-NOT: rep;movsl
 }

llvm/trunk/test/CodeGen/X86/movtopush.ll

 ; RUN: llc < %s -mtriple=i686-windows | FileCheck %s -check-prefix=NORMAL
 ; RUN: llc < %s -mtriple=x86_64-windows | FileCheck %s -check-prefix=X64
-; RUN: llc < %s -mtriple=i686-windows -force-align-stack -stack-alignment=32 | FileCheck %s -check-prefix=ALIGNED 
+; RUN: llc < %s -mtriple=i686-windows -stackrealign -stack-alignment=32 | FileCheck %s -check-prefix=ALIGNED
 
 %class.Class = type { i32 }
 %struct.s = type { i64 }
 
 declare void @good(i32 %a, i32 %b, i32 %c, i32 %d)
 declare void @inreg(i32 %a, i32 inreg %b, i32 %c, i32 %d)
 declare x86_thiscallcc void @thiscall(%class.Class* %class, i32 %a, i32 %b, i32 %c, i32 %d)
 declare void @oneparam(i32 %a)

llvm/trunk/test/CodeGen/X86/pr11468.ll

-; RUN: llc < %s -force-align-stack -stack-alignment=32 -march=x86-64 -mattr=+avx -mtriple=i686-apple-darwin10 | FileCheck %s
+; RUN: llc < %s -stackrealign -stack-alignment=32 -march=x86-64 -mattr=+avx -mtriple=i686-apple-darwin10 | FileCheck %s
 ; PR11468
 
 define void @f(i64 %sz) uwtable {
 entry:
   %a = alloca i32, align 32
   store volatile i32 0, i32* %a, align 32
   ; force to push r14 on stack
   call void asm sideeffect "nop", "~{r14},~{dirflag},~{fpsr},~{flags}"() nounwind, !srcloc !0

llvm/trunk/test/CodeGen/X86/stack-align-memcpy.ll

-; RUN: llc < %s -force-align-stack -mtriple i386-apple-darwin -mcpu=i486 | FileCheck %s
+; RUN: llc < %s -stackrealign -mtriple i386-apple-darwin -mcpu=i486 | FileCheck %s
 
 %struct.foo = type { [88 x i8] }
 
 declare void @bar(i8* nocapture, %struct.foo* align 4 byval) nounwind
 declare void @baz(i8*) nounwind
 
 ; PR15249
 ; We can't use rep;movsl here because it clobbers the base pointer in %esi.

llvm/trunk/test/CodeGen/X86/unaligned-spill-folding.ll

 ; RUN: llc -mtriple=i386-unknown-freebsd -mcpu=core2 -stack-alignment=4 -relocation-model=pic < %s | FileCheck %s -check-prefix=UNALIGNED
 ; RUN: llc -mtriple=i386-unknown-freebsd -mcpu=core2 -stack-alignment=16 -relocation-model=pic < %s | FileCheck %s -check-prefix=ALIGNED
-; RUN: llc -mtriple=i386-unknown-freebsd -mcpu=core2 -stack-alignment=4 -force-align-stack -relocation-model=pic < %s | FileCheck %s -check-prefix=FORCEALIGNED
+; RUN: llc -mtriple=i386-unknown-freebsd -mcpu=core2 -stack-alignment=4 -stackrealign -relocation-model=pic < %s | FileCheck %s -check-prefix=FORCEALIGNED
 
 @arr = internal unnamed_addr global [32 x i32] zeroinitializer, align 16
 
 ; PR12250
 define i32 @test1() {
 vector.ph:
   br label %vector.body
 

llvm/trunk/test/CodeGen/X86/x86-64-baseptr.ll

-; RUN: llc -mtriple=x86_64-pc-linux -force-align-stack -stack-alignment=32 < %s | FileCheck %s
-; RUN: llc -mtriple=x86_64-pc-linux-gnux32 -force-align-stack -stack-alignment=32 < %s | FileCheck -check-prefix=X32ABI %s
+; RUN: llc -mtriple=x86_64-pc-linux -stackrealign -stack-alignment=32 < %s | FileCheck %s
+; RUN: llc -mtriple=x86_64-pc-linux-gnux32 -stackrealign -stack-alignment=32 < %s | FileCheck -check-prefix=X32ABI %s
 ; This should run with NaCl as well ( -mtriple=x86_64-pc-nacl ) but currently doesn't due to PR22655
 
 ; Make sure the correct register gets set up as the base pointer
 ; This should be rbx for x64 and 64-bit NaCl and ebx for x32
 ; CHECK-LABEL: base
 ; CHECK: subq $32, %rsp
 ; CHECK: movq %rsp, %rbx
 ; X32ABI-LABEL: base