Change memcpy/memove/memset to have dest and source alignment attributes.

[dneilson]

Summary

Upstream LLVM is changing the the prototypes of the @llvm.memcpy/memmove/memset intrinsics. This change updates the polly ScopHelper and the polly tests for this change.

The @llvm.memcpy/memmove/memset intrinsics currently have an explicit argument which is required to be a constant integer. It represents the alignment of the dest (and source), and so must be the minimum of the actual alignment of the two.

This change allows source and dest to each have their own alignments by using the alignment attribute on their arguments. The alignment argument is removed.

For example, code which used to read:

call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dest, i8* %src, i32 100, i32 4, i1 false)

will now read

call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %dest, i8* align 4 %src, i32 100, i1 false)

[grosser]

LGTM. Thank you!

[dneilson]

Landed as: https://reviews.llvm.org/rL323618

include/polly/Support/ScopHelper.h

llvm::Value *getPointerOperand() const {
     llvm_unreachable("Operation not supported on nullptr");
   }
 
   unsigned getAlignment() const {
     if (isLoad())
       return asLoad()->getAlignment();
     if (isStore())
       return asStore()->getAlignment();
+    if (isMemTransferInst())
+      return std::min(asMemTransferInst()->getDestAlignment(),
+                      asMemTransferInst()->getSourceAlignment());
     if (isMemIntrinsic())
-      return asMemIntrinsic()->getAlignment();
+      return asMemIntrinsic()->getDestAlignment();
     if (isCallInst())
       return 0;
     llvm_unreachable("Operation not supported on nullptr");
   }
   bool isVolatile() const {
     if (isLoad())
       return asLoad()->isVolatile();
     if (isStore())

test/ScopInfo/memcpy.ll

 ;
 ; IR: polly.loop_preheader:
 ; IR:   %[[r1:[a-zA-Z0-9]*]] = getelementptr i32, i32* %A, i64 -4
 ; IR:   %[[r2:[a-zA-Z0-9]*]] = bitcast i32* %scevgep to i8*
 ; IR:   %[[r3:[a-zA-Z0-9]*]] = getelementptr i64, i64* %B, i64 8
 ; IR:   %[[r4:[a-zA-Z0-9]*]] = bitcast i64* %scevgep8 to i8*
 ;
 ; IR: polly.stmt.for.body3:
-; IR:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %[[r2]], i8* %[[r4]], i64 37, i32 4, i1 false)
+; IR:   call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %[[r2]], i8* align 4 %[[r4]], i64 37, i1 false)
 ;
 ;
 ;    #include <string.h>
 ;
 ;    void jd(int *restrict A, long *restrict B) {
 ;      for (int i = 0; i < 1024; i++)
 ;        for (int j = 0; j < 1024; j++)
 ;          memcpy(A - 4, B + 8, 37);

test/ScopInfo/memmove.ll

 ;
 ; IR: polly.loop_preheader:
 ; IR:   %[[r1:[a-zA-Z0-9]*]] = getelementptr i32, i32* %A, i64 -4
 ; IR:   %[[r2:[a-zA-Z0-9]*]] = bitcast i32* %scevgep to i8*
 ; IR:   %[[r3:[a-zA-Z0-9]*]] = getelementptr i64, i64* %B, i64 8
 ; IR:   %[[r4:[a-zA-Z0-9]*]] = bitcast i64* %scevgep8 to i8*
 ;
 ; IR: polly.stmt.for.body3:
-; IR:   call void @llvm.memmove.p0i8.p0i8.i64(i8* %[[r2]], i8* %[[r4]], i64 32, i32 4, i1 false)
+; IR:   call void @llvm.memmove.p0i8.p0i8.i64(i8* align 4 %[[r2]], i8* align 4 %[[r4]], i64 32, i1 false)
 ;
 ;    #include <string.h>
 ;
 ;    void jd(int *restrict A, long *restrict B) {
 ;      for (int i = 0; i < 1024; i++)
 ;        for (int j = 0; j < 1024; j++)
 ;          memmove(A - 4, B + 8, 32);
 ;    }

test/ScopInfo/memset.ll

 ; CHECK-NEXT:            Schedule :=
 ; CHECK-NEXT:                { Stmt_for_body3[i0, i1] -> [i0, i1] };
 ; CHECK-NEXT:            MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:                { Stmt_for_body3[i0, i1] -> MemRef_A[o0] : 0 <= o0 <= 186 };
 ;
 ; IR:   %[[r1:[a-zA-Z0-9]*]] = bitcast i32* %A to i8*
 ;
 ; IR: polly.stmt.for.body3:
-; IR:   call void @llvm.memset.p0i8.i64(i8* %[[r1]], i8 36, i64 187, i32 4, i1 false)
+; IR:   call void @llvm.memset.p0i8.i64(i8* align 4 %[[r1]], i8 36, i64 187, i1 false)
 ;
 ;    #include <string.h>
 ;
 ;    void jd(int *A) {
 ;      for (int i = 0; i < 1024; i++)
 ;        for (int j = 0; j < 1024; j++)
 ;          memset(A, '$', 187);
 ;    }