Improve handling of memmove when Lenght > size of the type to move

It is possible that for a single element Src type size doesn't
match memory size to move (for example we copy N elements of one
integer array to an address of a first element of another integer
array).

Signed-off-by: Dmitry Sidorov <[email protected]>

Author: MrSidims

lib/SPIRV/SPIRVLowerMemmove.cpp

@@ -63,34 +63,31 @@ class SPIRVLowerMemmoveBase {
     if (isa<PHINode>(Src))
       report_fatal_error("llvm.memmove of PHI instruction result not supported",
                          false);
-    auto *SrcTy = Src->getType();
-    auto *Length = cast<ConstantInt>(I.getLength());
-    auto *S = Src;
     // The source could be bit-cast or addrspacecast from another type,
     // need the original type for the allocation of the temporary variable
-    while (isa<BitCastInst>(S) || isa<AddrSpaceCastInst>(S))
-      S = cast<CastInst>(S)->getOperand(0);
-    SrcTy = S->getType();
+    auto *SrcTy = Src->stripPointerCasts()->getType();
+    auto *Length = cast<ConstantInt>(I.getLength());
     MaybeAlign Align = I.getSourceAlign();
     auto Volatile = I.isVolatile();
     Value *NumElements = nullptr;
     uint64_t ElementsCount = 1;
     if (SrcTy->isArrayTy()) {
-      NumElements = Builder.getInt32(SrcTy->getArrayNumElements());
       ElementsCount = SrcTy->getArrayNumElements();
+      NumElements = Builder.getInt32(ElementsCount);
     }
-    if (((ElementsCount > 1) && (Mod->getDataLayout().getTypeSizeInBits(
-                                     SrcTy->getPointerElementType()) *
-                                     ElementsCount !=
-                                 Length->getZExtValue() * 8)) ||
-        ((ElementsCount == 1) &&
-         (Mod->getDataLayout().getTypeSizeInBits(
-              SrcTy->getPointerElementType()) < Length->getZExtValue() * 8)))
-      report_fatal_error("Size of the memcpy should match the allocated memory",
-                         false);
-
-    auto *Alloca =
-        Builder.CreateAlloca(SrcTy->getPointerElementType(), NumElements);
+    // Get number of bits to move and allocate memory appropriately:
+    // if lenght is bigger than a pointer base type size, then create an
+    // alloca of an array type with the same base type.
+    const uint64_t LenBits = Length->getZExtValue();
+    const uint64_t LayoutTypeBites =
+        Mod->getDataLayout().getTypeSizeInBits(SrcTy->getPointerElementType()) *
+        ElementsCount;
+    auto *AllocaTy = SrcTy->getPointerElementType();
+    if (LenBits > LayoutTypeBites) {
+      const uint64_t ArraySize = LenBits / LayoutTypeBites;
+      AllocaTy = ArrayType::get(SrcTy->getPointerElementType(), ArraySize);
+    }
+    auto *Alloca = Builder.CreateAlloca(AllocaTy, NumElements);
     if (Align.hasValue()) {
       Alloca->setAlignment(Align.getValue());
     }

test/llvm-intrinsics/memmove.ll

@@ -7,6 +7,9 @@
 
 ; CHECK-SPIRV-NOT: llvm.memmove
 
+; CHECK-SPIRV: TypeInt [[#TYPEINT:]] 32
+; CHECK-SPIRV: Constant [[#TYPEINT]] [[#ARRSIZE:]] 128
+
 ; CHECK-SPIRV: Variable {{[0-9]+}} [[mem:[0-9]+]] 7
 ; CHECK-SPIRV: Bitcast [[i8Ty:[0-9]+]] [[tmp0:[0-9]+]] [[mem]]
 ; CHECK-SPIRV: LifetimeStart [[tmp0]] [[size:[0-9]+]]
@@ -28,6 +31,16 @@
 ; CHECK-SPIRV: Bitcast [[i8Ty]] [[tmp3:[0-9]+]] [[mem]]
 ; CHECK-SPIRV: LifetimeStop [[tmp3]] [[size]]
 
+; CHECK-SPIRV: Variable [[#]] [[#VAR:]]
+; CHECK-SPIRV: Bitcast [[i8Ty:[0-9]+]] [[#TMP0:]] [[#VAR]]
+; CHECK-SPIRV: LifetimeStart [[#TMP0]]
+; CHECK-SPIRV: Bitcast [[i8Ty]] [[#TMP1:]] [[#VAR]]
+; CHECK-SPIRV: CopyMemorySized [[#TMP1]] [[#]] [[#ARRSIZE]]
+; CHECK-SPIRV: Bitcast [[i8Ty]] [[#TMP2:]] [[#VAR]]
+; CHECK-SPIRV: CopyMemorySized [[#]] [[#TMP2]] [[#ARRSIZE]]
+; CHECK-SPIRV: Bitcast [[i8Ty]] [[#TMP3:]] [[#VAR]]
+; CHECK-SPIRV: LifetimeStop [[#TMP3]]
+
 ; CHECK-LLVM-NOT: llvm.memmove
 
 ; CHECK-LLVM-LABEL: @test_struct
@@ -60,6 +73,18 @@
 ; CHECK-LLVM: [[tmp4:%[0-9]+]] = bitcast %struct.SomeStruct* [[local]] to [[type]]
 ; CHECK-LLVM: call void @llvm.lifetime.end.p0i8({{i[0-9]+}} {{-?[0-9]+}}, [[type]] [[tmp4]])
 
+; CHECK-LLVM-LABEL: @test_array
+; CHECK-LLVM: %[[#ALLOCA:]] = alloca [16 x i8], align 1
+; CHECK-LLVM: %[[#TMP0:]] = bitcast [16 x i8]* %[[#ALLOCA]] to i8*
+; CHECK-LLVM: call void @llvm.lifetime.start.p0i8(i64 -1, i8* %[[#TMP0]])
+; CHECK-LLVM: %[[#TMP1:]] = bitcast [16 x i8]* %[[#ALLOCA]] to i8*
+; CHECK-LLVM: call void @llvm.memcpy.p0i8.p1i8.i32(i8* %[[#TMP1]], i8 addrspace(1)* %out, i32 128, i1 false)
+; CHECK-LLVM: %[[#TMP2:]] = bitcast [16 x i8]* %[[#ALLOCA]] to i8*
+; CHECK-LLVM: call void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* %in, i8* %[[#TMP2]], i32 128, i1 false)
+; CHECK-LLVM: %[[#TMP3:]] = bitcast [16 x i8]* %[[#ALLOCA]] to i8*
+; CHECK-LLVM: call void @llvm.lifetime.end.p0i8(i64 -1, i8* %[[#TMP3]])
+
+
 target datalayout = "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-n8:16:32:64"
 target triple = "spir-unknown-unknown"
 
@@ -81,6 +106,12 @@ define spir_func void @copy_struct(%struct.SomeStruct addrspace(1)* nocapture re
   ret void
 }
 
+; Function Attrs: nounwind
+define spir_kernel void @test_array(i8 addrspace(1)* %in, i8 addrspace(1)* %out) {
+  call void @llvm.memmove.p1i8.p1i8.i32(i8 addrspace(1)* %in, i8 addrspace(1)* %out, i32 128, i1 false)
+  ret void
+}
+
 ; Function Attrs: nounwind
 declare void @llvm.memmove.p1i8.p1i8.i32(i8 addrspace(1)* nocapture, i8 addrspace(1)* nocapture readonly, i32, i1) #1