[X86] Use single add/sub for large stack offsets

[rob.lougher]

Summary

The following code generates an object file which is over 30 MB in size:

void bar(char *a);
void foo (void) {
    char b[5000000000000000];
    bar(b);
}

The reason is that the code to push the space on the stack consists of over 2 million subtract
instructions of the form:

subq    $2147483647, %rsp       # imm = 0x7FFFFFFF

Instead of doing multiple immediate mode subtracts, the compiler should place the final amount to
be subtracted into a register and do a single subtraction.

[asl]

lib/Target/X86/X86FrameLowering.cpp

202

This clobbers rax/eax w/o checking whether it's a livein or not. This may be a problem for functions with inreg attributes. I believe the code should always use findDeadCallerSavedReg().

[rob.lougher]

lib/Target/X86/X86FrameLowering.cpp

202

I copied that from the code that generates a push/pop (lines 223-225), so the existing code always uses rax/eax in the prologue for a push. If this is a problem for inreg attributes, this code will also need to be fixed.

[asl]

lib/Target/X86/X86FrameLowering.cpp

202

It's not a problem for push below, because we just need to put something on stack (we can use any register for this). For pop'ing stuff we need to find free register, since we're going to clobber it.

Situation here is completely different, because the code in the patch materializes a constant in the register thus clobbering it always.

[rob.lougher]

lib/Target/X86/X86FrameLowering.cpp

202

OK, point taken - in the push case it's pushing whatever value is in rax/eax (as it's just making space, the value doesn't matter). I tried changing the code to always use findDeadCallerSavedReg(), but it returns zero when used in the prologue, so we fall back to using multiple instructions (as before). I need to do some more investigation.

[rob.lougher]

I have uploaded a new diff which hopefully addresses the inreg attribute issue. I have also updated the tests to include a test for it.

[asl]

LGTM after the fix of the test.

test/CodeGen/X86/huge-stack-offset.ll

16

Typo? Should be CHECK-32-LABEL as I can see.

[rob.lougher]

Thanks for the review! Typo fixed, and committed in r227458.

lib/Target/X86/X86FrameLowering.cpp

if (IsLP64) {
     return X86::ADD64ri32;
   } else {
     if (isInt<8>(Imm))
       return X86::ADD32ri8;
     return X86::ADD32ri;
   }
 }
 
+static unsigned getSUBrrOpcode(unsigned isLP64) {
+  return isLP64 ? X86::SUB64rr : X86::SUB32rr;
+}
+
+static unsigned getADDrrOpcode(unsigned isLP64) {
+  return isLP64 ? X86::ADD64rr : X86::ADD32rr;
+}
+
 static unsigned getANDriOpcode(bool IsLP64, int64_t Imm) {
   if (IsLP64) {
     if (isInt<8>(Imm))
       return X86::AND64ri8;
     return X86::AND64ri32;
   }
   if (isInt<8>(Imm))
     return X86::AND32ri8;
else
     Opc = isSub
       ? getSUBriOpcode(Is64BitStackPtr, Offset)
       : getADDriOpcode(Is64BitStackPtr, Offset);
 
   uint64_t Chunk = (1LL << 31) - 1;
   DebugLoc DL = MBB.findDebugLoc(MBBI);
 
   while (Offset) {
+    if (Offset > Chunk) {
+      // Rather than emit a long series of instructions for large offsets,
+      // load the offset into a register and do one sub/add
+      unsigned Reg = isSub
+        ? (unsigned)(Is64BitTarget ? X86::RAX : X86::EAX)
+        : findDeadCallerSavedReg(MBB, MBBI, TRI, Is64BitTarget);
+      if (Reg) {
+        Opc = Is64BitTarget ? X86::MOV64ri : X86::MOV32ri;
+        BuildMI(MBB, MBBI, DL, TII.get(Opc), Reg)
+          .addImm(Offset);
+        Opc = isSub
+          ? getSUBrrOpcode(Is64BitTarget)
+          : getADDrrOpcode(Is64BitTarget);
+        MachineInstr *MI = BuildMI(MBB, MBBI, DL, TII.get(Opc), StackPtr)
+          .addReg(StackPtr)
+          .addReg(Reg);
+        MI->getOperand(3).setIsDead(); // The EFLAGS implicit def is dead.
+        Offset = 0;
+        continue;
+      }
+    }
+
     uint64_t ThisVal = (Offset > Chunk) ? Chunk : Offset;
     if (ThisVal == (Is64BitTarget ? 8 : 4)) {
       // Use push / pop instead.
       unsigned Reg = isSub
         ? (unsigned)(Is64BitTarget ? X86::RAX : X86::EAX)
         : findDeadCallerSavedReg(MBB, MBBI, TRI, Is64BitTarget);
       if (Reg) {
         Opc = isSub

test/CodeGen/X86/huge-stack-offset.ll

+; RUN: llc < %s -march=x86-64 | FileCheck %s
+
+; Test that a large stack offset uses a single add/sub instruction to
+; adjust the stack pointer.
+
+define void @foo() nounwind {
+; CHECK-LABEL: foo:
+; CHECK:      movabsq $5000000000000008, %rax
+; CHECK-NEXT: subq    %rax, %rsp
+; CHECK-NOT:  subq    $2147483647, %rsp
+; CHECK:      movabsq $5000000000000008, [[RAX:%r..]]
+; CHECK-NEXT: addq    [[RAX]], %rsp
+  %1 = alloca [5000000000000000 x i8], align 16
+  %2 = getelementptr inbounds [5000000000000000 x i8]* %1, i32 0, i32 0
+  call void @bar(i8* %2)
+  ret void
+}
+
+; Verify that we do not clobber the return value.
+
+define i32 @foo2() nounwind {
+; CHECK-LABEL: foo2:
+; CHECK:      movabsq $5000000000000008, %rax
+; CHECK-NEXT: subq    %rax, %rsp
+; CHECK-NOT:  subq    $2147483647, %rsp
+; CHECK:      movl  $10, %eax
+; CHECK-NOT:  movabsq $5000000000000008, %rax
+  %1 = alloca [5000000000000000 x i8], align 16
+  %2 = getelementptr inbounds [5000000000000000 x i8]* %1, i32 0, i32 0
+  call void @bar(i8* %2)
+  ret i32 10
+}
+
+declare void @bar(i8*)