[CGP][ARM] Dont align memcpy args when optimization for size

[dmgreen]

Summary

This was added back in D7908, to align memcpy args. It should be limited when optimizing for size to prevent extra unnecessary padding being added. It seems to only currently be used under arm.

[SjoerdMeijer]

llvm/test/CodeGen/ARM/memcpy-no-inline.ll

59–85

I understand the logic of this patch, but I am struggling with the tests.
In this new test below, it's unclear to me why we shouldn't be generating the libcall.

To make the differences clear I am wondering if these tests should test more or if they should be llc .. | llvm-objdump -d .. tests so that we can actually see codesize?

[dmgreen]

I've updated the test with all the output - and just shown the diffs here. With that test, if the array is no longer aligned then a series of load/stores will be needed, an LDM will have too-high alignment requirements.

[efriedma]

llvm/lib/CodeGen/CodeGenPrepare.cpp

2130

Not sure I understand the placement of this check. Increasing the alignment of an alloca or a MemIntrinsic doesn't directly increase codesize. And increasing the alignment of a global variable only increases codeisze if we're forced to insert extra padding.

llvm/lib/CodeGen/CodeGenPrepare.cpp

if (CI->isInlineAsm()) {
     if (optimizeInlineAsmInst(CI))
       return true;
   }
 
   // Align the pointer arguments to this call if the target thinks it's a good
   // idea
   unsigned MinSize;
   Align PrefAlign;
-  if (TLI->shouldAlignPointerArgs(CI, MinSize, PrefAlign)) {
+  if (!OptSize && TLI->shouldAlignPointerArgs(CI, MinSize, PrefAlign)) {
     for (auto &Arg : CI->args()) {
       // We want to align both objects whose address is used directly and
       // objects whose address is used in casts and GEPs, though it only makes
       // sense for GEPs if the offset is a multiple of the desired alignment and
       // if size - offset meets the size threshold.
       if (!Arg->getType()->isPointerTy())
         continue;
       APInt Offset(DL->getIndexSizeInBits(

llvm/test/CodeGen/ARM/memcpy-no-inline.ll

 define void @foo() #0 {
 ; CHECK-LABEL: foo:
 ; CHECK:       @ %bb.0: @ %entry
 ; CHECK-NEXT:    .save {r7, lr}
 ; CHECK-NEXT:    push {r7, lr}
 ; CHECK-NEXT:    .pad #32
 ; CHECK-NEXT:    sub sp, #32
 ; CHECK-NEXT:    ldr r1, .LCPI0_0
-; CHECK-NEXT:    mov r0, sp
+; CHECK-NEXT:    add.w r0, sp, #1
 ; CHECK-NEXT:    movs r2, #31
 ; CHECK-NEXT:    bl __aeabi_memcpy
 ; CHECK-NEXT:    add sp, #32
 ; CHECK-NEXT:    pop {r7, pc}
 ; CHECK-NEXT:    .p2align 2
 ; CHECK-NEXT:  @ %bb.1:
 ; CHECK-NEXT:  .LCPI0_0:
 ; CHECK-NEXT:    .long .L.str
 entry:
   %mystring = alloca [31 x i8], align 1
   %0 = getelementptr inbounds [31 x i8], [31 x i8]* %mystring, i32 0, i32 0
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 %0, i8* align 1 getelementptr inbounds ([31 x i8], [31 x i8]* @.str, i32 0, i32 0), i32 31, i1 false)
   ret void
 }
 
 define void @bar() #0 {
 ; CHECK-LABEL: bar:
 ; CHECK:       @ %bb.0: @ %entry
-; CHECK-NEXT:    .save {r4, r5, r6, lr}
-; CHECK-NEXT:    push {r4, r5, r6, lr}
+; CHECK-NEXT:    .save {r7, lr}
+; CHECK-NEXT:    push {r7, lr}
 ; CHECK-NEXT:    .pad #32
 ; CHECK-NEXT:    sub sp, #32
-; CHECK-NEXT:    ldr r0, .LCPI1_0
-; CHECK-NEXT:    mov r1, sp
-; CHECK-NEXT:    ldm r0!, {r2, r3, r4, r5, r6}
-; CHECK-NEXT:    stm r1!, {r2, r3, r4, r5, r6}
-; CHECK-NEXT:    ldrb r0, [r0]
-; CHECK-NEXT:    strb r0, [r1]
+; CHECK-NEXT:    ldr r1, .LCPI1_0
+; CHECK-NEXT:    add.w r0, sp, #1
+; CHECK-NEXT:    movs r2, #21
+; CHECK-NEXT:    bl __aeabi_memcpy
 ; CHECK-NEXT:    add sp, #32
-; CHECK-NEXT:    pop {r4, r5, r6, pc}
+; CHECK-NEXT:    pop {r7, pc}
 ; CHECK-NEXT:    .p2align 2
 ; CHECK-NEXT:  @ %bb.1:
 ; CHECK-NEXT:  .LCPI1_0:
 ; CHECK-NEXT:    .long .L.str.1
 entry:
   %mystring = alloca [31 x i8], align 1
   %0 = getelementptr inbounds [31 x i8], [31 x i8]* %mystring, i32 0, i32 0
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 %0, i8* align 1 getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i32 0, i32 0), i32 21, i1 false)
   ret void
 }
 
 define void @bar2() #0 {
 ; CHECK-LABEL: bar2:
 ; CHECK:       @ %bb.0: @ %entry
 ; CHECK-NEXT:    .save {r4, r5, r6, lr}
 ; CHECK-NEXT:    push {r4, r5, r6, lr}
 ; CHECK-NEXT:    .pad #32
 ; CHECK-NEXT:    sub sp, #32
 ; CHECK-NEXT:    ldr r0, .LCPI2_0
 ; CHECK-NEXT:    mov r1, sp
 ; CHECK-NEXT:    ldm r0!, {r2, r3, r4, r5, r6}
 ; CHECK-NEXT:    stm r1!, {r2, r3, r4, r5, r6}
 ; CHECK-NEXT:    ldrb r0, [r0]
 ; CHECK-NEXT:    strb r0, [r1]
 ; CHECK-NEXT:    add sp, #32
 ; CHECK-NEXT:    pop {r4, r5, r6, pc}
 ; CHECK-NEXT:    .p2align 2
 ; CHECK-NEXT:  @ %bb.1:
 ; CHECK-NEXT:  .LCPI2_0:
 ; CHECK-NEXT:    .long .L.str.2
 entry:
   %mystring = alloca [32 x i8], align 4
   %0 = getelementptr inbounds [32 x i8], [32 x i8]* %mystring, i32 0, i32 0
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %0, i8* align 4 getelementptr inbounds ([21 x i8], [21 x i8]* @.str.2, i32 0, i32 0), i32 21, i1 false)
   ret void
 }
 
 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i1) #1
 
 attributes #0 = { minsize noinline nounwind optsize }

llvm/test/CodeGen/ARM/memfunc.ll

entry:
   ; CHECK-GNUEABI: bl memset
   %arr2 = alloca [13 x i8], align 1
   %2 = getelementptr inbounds [13 x i8], [13 x i8]* %arr2, i32 0, i32 16
   call void @llvm.memset.p0i8.i32(i8* %2, i8 1, i32 %n, i1 false)
 
   ret void
 }
 
+; Check that alloca arguments are not aligned when the function is minsize
+define void @fminsize(i8* %dest, i32 %n) "frame-pointer"="all" minsize {
+entry:
+  ; CHECK-LABEL: fminsize
+
+  ; CHECK: {{add(.w)? r., sp, #27|sub(.w)? r., r(7|11), #17}}
+  ; CHECK-IOS: bl _memmove
+  ; CHECK-DARWIN: bl _memmove
+  ; CHECK-EABI: bl __aeabi_memmove
+  ; CHECK-GNUEABI: bl memmove
+  %arr0 = alloca [9 x i8], align 1
+  %0 = bitcast [9 x i8]* %arr0 to i8*
+  call void @llvm.memmove.p0i8.p0i8.i32(i8* %dest, i8* %0, i32 %n, i1 false)
+
+  ; CHECK: {{add(.w)? r., sp, #(10|14)|sub(.w)? r., r(7|11), #26}}
+  ; CHECK-IOS: bl _memcpy
+  ; CHECK-DARWIN: bl _memcpy
+  ; CHECK-EABI: bl __aeabi_memcpy
+  ; CHECK-GNUEABI: bl memcpy
+  %arr1 = alloca [9 x i8], align 1
+  %1 = bitcast [9 x i8]* %arr1 to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %1, i32 %n, i1 false)
+
+  ; CHECK: {{add(.w)? r., sp, #(1|5)|sub(.w)? r., r(7|11), #35}}
+  ; CHECK-IOS: mov r1, #1
+  ; CHECK-IOS: bl _memset
+  ; CHECK-DARWIN: movs r1, #1
+  ; CHECK-DARWIN: bl _memset
+  ; CHECK-EABI: mov r2, #1
+  ; CHECK-EABI: bl __aeabi_memset
+  ; CHECK-GNUEABI: mov r1, #1
+  ; CHECK-GNUEABI: bl memset
+  %arr2 = alloca [9 x i8], align 1
+  %2 = bitcast [9 x i8]* %arr2 to i8*
+  call void @llvm.memset.p0i8.i32(i8* %2, i8 1, i32 %n, i1 false)
+
+  ret void
+}
+
 ; Check that global variables are aligned if they are large enough, but only if
 ; they are defined in this object and don't have an explicit section.
 @arr1 = global [7 x i8] c"\01\02\03\04\05\06\07", align 1
 @arr2 = global [8 x i8] c"\01\02\03\04\05\06\07\08", align 1
 @arr3 = global [7 x i8] c"\01\02\03\04\05\06\07", section "foo,bar", align 1
 @arr4 = global [8 x i8] c"\01\02\03\04\05\06\07\08", section "foo,bar", align 1
 @arr5 = weak global [7 x i8] c"\01\02\03\04\05\06\07", align 1
 @arr6 = weak_odr global [7 x i8] c"\01\02\03\04\05\06\07", align 1