[ARM] Fix offset calculation in ARMBaseRegisterInfo::needsFrameBaseReg

[john.brawn]

Summary

The input offset to needsFrameBaseReg is a negative value below the top of the stack frame, but when converting to a positive offset from the bottom of the stack frame this value was negated, causing the final offset to be too large by twice the input offset's magnitude. Fix that by not negating the offset.

[jmolloy]

Hi John,

This LGTM.

James

[john.brawn]

In D8316#141952, @jmolloy wrote:

Hi John,

This LGTM.

James

Thanks. Could you commit this for me please?

lib/Target/ARM/ARMBaseRegisterInfo.cpp

needsFrameBaseReg(MachineInstr *MI, int64_t Offset) const {
   int64_t FPOffset = Offset - 8;
   // ARM and Thumb2 functions also need to consider R8-R11 and D8-D15
   if (!AFI->isThumbFunction() || !AFI->isThumb1OnlyFunction())
     FPOffset -= 80;
   // Estimate an offset from the stack pointer.
   // The incoming offset is relating to the SP at the start of the function,
   // but when we access the local it'll be relative to the SP after local
   // allocation, so adjust our SP-relative offset by that allocation size.
-  Offset = -Offset;
   Offset += MFI->getLocalFrameSize();
   // Assume that we'll have at least some spill slots allocated.
   // FIXME: This is a total SWAG number. We should run some statistics
   //        and pick a real one.
   Offset += 128; // 128 bytes of spill slots
 
   // If there's a frame pointer and the addressing mode allows it, try using it.
   // The FP is only available if there is no dynamic realignment. We

test/CodeGen/ARM/ssp-data-layout.ll

 %struct.struct_large_char2 = type { [2 x i8], [8 x i8] }
 %struct.struct_small_char = type { [2 x i8] }
 %struct.struct_large_nonchar = type { [8 x i32] }
 %struct.struct_small_nonchar = type { [2 x i16] }
 
 define void @layout_ssp() ssp {
 entry:
 ; Expected stack layout for ssp is
-;  180 large_char          . Group 1, nested arrays, arrays >= ssp-buffer-size
-;  172 struct_large_char   .
-;  168 scalar1             | Everything else
-;  164 scalar2
-;  160 scalar3
-;  156 addr-of
-;  152 small_nonchar (84+68)
+;  176 large_char          . Group 1, nested arrays, arrays >= ssp-buffer-size
+;  168 struct_large_char   .
+;  164 scalar1             | Everything else
+;  160 scalar2
+;  156 scalar3
+;  152 addr-of
+;  148 small_nonchar
 ;  112 large_nonchar
 ;  110 small_char
 ;  108 struct_small_char
 ;   72 struct_large_nonchar
 ;   68 struct_small_nonchar
 
 ; CHECK: layout_ssp:
-; r[[SP]] is used as an offset into the stack later
-; CHECK: add r[[SP:[0-9]+]], sp, #68
 
 ; CHECK: bl get_scalar1
-; CHECK: str r0, [sp, #168]
+; CHECK: str r0, [sp, #164]
 ; CHECK: bl end_scalar1
 
 ; CHECK: bl get_scalar2
-; CHECK: str r0, [sp, #164]
+; CHECK: str r0, [sp, #160]
 ; CHECK: bl end_scalar2
 
 ; CHECK: bl get_scalar3
-; CHECK: str r0, [sp, #160]
+; CHECK: str r0, [sp, #156]
 ; CHECK: bl end_scalar3
 
 ; CHECK: bl get_addrof
-; CHECK: str r0, [sp, #156]
+; CHECK: str r0, [sp, #152]
 ; CHECK: bl end_addrof
 
 ; CHECK: get_small_nonchar
-; CHECK: strh r0, [r[[SP]], #84]
+; CHECK: strh r0, [sp, #148]
 ; CHECK: bl end_small_nonchar
 
 ; CHECK: bl get_large_nonchar
 ; CHECK: str r0, [sp, #112]
 ; CHECK: bl end_large_nonchar
 
 ; CHECK: bl get_small_char
 ; CHECK: strb r0, [sp, #110]
 ; CHECK: bl end_small_char
 
 ; CHECK: bl get_large_char
-; CHECK: strb r0, [sp, #180]
+; CHECK: strb r0, [sp, #176]
 ; CHECK: bl end_large_char
 
 ; CHECK: bl get_struct_large_char
-; CHECK: strb r0, [sp, #172]
+; CHECK: strb r0, [sp, #168]
 ; CHECK: bl end_struct_large_char
 
 ; CHECK: bl get_struct_small_char
 ; CHECK: strb r0, [sp, #108]
 ; CHECK: bl end_struct_small_char
 
 ; CHECK: bl get_struct_large_nonchar
 ; CHECK:str r0, [sp, #72]
 ; CHECK: bl end_struct_large_nonchar
 
 ; CHECK: bl get_struct_small_nonchar
-; CHECK: strh r0, [r[[SP]]]
+; CHECK: strh r0, [sp, #68]
 ; CHECK: bl end_struct_small_nonchar
   %x = alloca i32, align 4
   %y = alloca i32, align 4
   %z = alloca i32, align 4
   %ptr = alloca i32, align 4
   %small2 = alloca [2 x i16], align 2
   %large2 = alloca [8 x i32], align 16
   %small = alloca [2 x i8], align 1

 ; 88   struct_small_char      |
 ; 84   struct_small_nonchar   |
 ; 80   addrof                 * Group 3, addr-of local
 ; 76   scalar1                + Group 4, everything else
 ; 72   scalar2                +
 ; 68   scalar3                +
 ;   
 ; CHECK: layout_sspstrong:
-; r[[SP]] is used as an offset into the stack later
-; CHECK: add r[[SP:[0-9]+]], sp, #84
 
 ; CHECK: bl get_scalar1
 ; CHECK: str r0, [sp, #76]
 ; CHECK: bl end_scalar1
 
 ; CHECK: bl get_scalar2
 ; CHECK: str r0, [sp, #72]
 ; CHECK: bl end_scalar2
 
 ; CHECK: bl get_scalar3
 ; CHECK: str r0, [sp, #68]
 ; CHECK: bl end_scalar3
 
 ; CHECK: bl get_addrof
 ; CHECK: str r0, [sp, #80]
 ; CHECK: bl end_addrof
 
 ; CHECK: get_small_nonchar
-; CHECK: strh r0, [r[[SP]], #8]
+; CHECK: strh r0, [sp, #92]
 ; CHECK: bl end_small_nonchar
 
 ; CHECK: bl get_large_nonchar
 ; CHECK: str r0, [sp, #144]
 ; CHECK: bl end_large_nonchar
 
 ; CHECK: bl get_small_char
 ; CHECK: strb r0, [sp, #90]

 ; CHECK: strb r0, [sp, #88]
 ; CHECK: bl end_struct_small_char
 
 ; CHECK: bl get_struct_large_nonchar
 ; CHECK: str r0, [sp, #96]
 ; CHECK: bl end_struct_large_nonchar
 
 ; CHECK: bl get_struct_small_nonchar
-; CHECK: strh r0, [r[[SP]]]
+; CHECK: strh r0, [sp, #84]
 ; CHECK: bl end_struct_small_nonchar
   %x = alloca i32, align 4
   %y = alloca i32, align 4
   %z = alloca i32, align 4
   %ptr = alloca i32, align 4
   %small2 = alloca [2 x i16], align 2
   %large2 = alloca [8 x i32], align 16
   %small = alloca [2 x i8], align 1
; CHECK: bl end_struct_small_nonchar
   ret void
 }
 
 define void @layout_sspreq() sspreq {
 entry:
 ; Expected stack layout for sspreq is the same as sspstrong
 ;   
 ; CHECK: layout_sspreq:
-; r[[SP]] is used as an offset into the stack later
-; CHECK: add r[[SP:[0-9]+]], sp, #84
 
 ; CHECK: bl get_scalar1
 ; CHECK: str r0, [sp, #76]
 ; CHECK: bl end_scalar1
 
 ; CHECK: bl get_scalar2
 ; CHECK: str r0, [sp, #72]
 ; CHECK: bl end_scalar2
 
 ; CHECK: bl get_scalar3
 ; CHECK: str r0, [sp, #68]
 ; CHECK: bl end_scalar3
 
 ; CHECK: bl get_addrof
 ; CHECK: str r0, [sp, #80]
 ; CHECK: bl end_addrof
 
 ; CHECK: get_small_nonchar
-; CHECK: strh r0, [r[[SP]], #8]
+; CHECK: strh r0, [sp, #92]
 ; CHECK: bl end_small_nonchar
 
 ; CHECK: bl get_large_nonchar
 ; CHECK: str r0, [sp, #144]
 ; CHECK: bl end_large_nonchar
 
 ; CHECK: bl get_small_char
 ; CHECK: strb r0, [sp, #90]

 ; CHECK: strb r0, [sp, #88]
 ; CHECK: bl end_struct_small_char
 
 ; CHECK: bl get_struct_large_nonchar
 ; CHECK: str r0, [sp, #96]
 ; CHECK: bl end_struct_large_nonchar
 
 ; CHECK: bl get_struct_small_nonchar
-; CHECK: strh r0, [r[[SP]]]
+; CHECK: strh r0, [sp, #84]
 ; CHECK: bl end_struct_small_nonchar
   %x = alloca i32, align 4
   %y = alloca i32, align 4
   %z = alloca i32, align 4
   %ptr = alloca i32, align 4
   %small2 = alloca [2 x i16], align 2
   %large2 = alloca [8 x i32], align 16
   %small = alloca [2 x i8], align 1

test/CodeGen/Thumb/stack-access.ll

 
 define zeroext i16 @test6() {
   %x = alloca i16, align 2
 ; CHECK: mov r0, sp
 ; CHECK: ldrh r0, [r0]
   %1 = load i16, i16* %x, align 2
   ret i16 %1
 }
+
+; Accessing the bottom of a large array shouldn't require materializing a base
+define void @test7() {
+  %arr = alloca [200 x i32], align 4
+
+  ; CHECK: movs [[REG:r[0-9]+]], #1
+  ; CHECK: str [[REG]], [sp, #4]
+  %arrayidx = getelementptr inbounds [200 x i32], [200 x i32]* %arr, i32 0, i32 1
+  store i32 1, i32* %arrayidx, align 4
+
+  ; CHECK: str [[REG]], [sp, #16]
+  %arrayidx1 = getelementptr inbounds [200 x i32], [200 x i32]* %arr, i32 0, i32 4
+  store i32 1, i32* %arrayidx1, align 4
+
+  ret void
+}
 No newline at end of file