[Polly] [PPCGCodeGeneration] Compute element size in bytes for arrays correctly.

[bollu]

Summary

Previously, we used to compute this with elementSizeInBits / 8. This
would yield an element size of 0 when the array had element size < 8 in
bits.

To fix this, ask data layout what the size in bytes should be.

[bollu]

• [NFC] add bugpoint reduced test case

[bollu]

• [PPCGCodeGeneration] Compute element size in bytes for arrays correctly.

[bollu]

Review, please.

[bollu]

• [NFC] explain why we choose to abort if size is computed to be 0

[philip.pfaffe]

LGTM

[grosser]

LGTM. Thank you!

[singam-sanjay]

test/GPGPU/array-with-elem-type-smaller-than-byte.ll

15

const int niters

lib/CodeGen/PPCGCodeGeneration.cpp

for (int i = 0; i < Prog->n_array; ++i) {
 
     Value *ArraySize = getArraySize(Array);
     Value *Offset = getArrayOffset(Array);
     if (Offset)
       ArraySize = Builder.CreateSub(
           ArraySize,
           Builder.CreateMul(Offset,
                             Builder.getInt64(ScopArray->getElemSizeInBytes())));
+    const SCEV *SizeSCEV = SE.getSCEV(ArraySize);
+    // It makes no sense to have an array of size 0. The CUDA API will
+    // throw an error anyway if we invoke `cuMallocManaged` with size `0`. We
+    // choose to be defensive and catch this at the compile phase. It is
+    // most likely that we are doing something wrong with size computation.
+    if (SizeSCEV->isZero()) {
+      errs() << getUniqueScopName(&S)
+             << " has computed array size 0: " << *ArraySize
+             << " | for array: " << *(ScopArray->getBasePtr())
+             << ". This is illegal, exiting.\n";
+      report_fatal_error("array size was computed to be 0");
+    }
+
     Value *DevArray = createCallAllocateMemoryForDevice(ArraySize);
     DevArray->setName(DevArrayName);
     DeviceAllocations[ScopArray] = DevArray;
   }
 
   isl_ast_build_free(Build);
 }
 
for (auto &Array : ValidSAIs) {
 
       OS << *Array->getElementType();
       TypeName = OS.str();
 
       gpu_array_info &PPCGArray = PPCGProg->array[i];
 
       PPCGArray.space = Array->getSpace().release();
       PPCGArray.type = strdup(TypeName.c_str());
-      PPCGArray.size = Array->getElementType()->getPrimitiveSizeInBits() / 8;
+      PPCGArray.size = DL->getTypeAllocSize(Array->getElementType());
       PPCGArray.name = strdup(Array->getName().c_str());
       PPCGArray.extent = nullptr;
       PPCGArray.n_index = Array->getNumberOfDimensions();
       PPCGArray.extent = getExtent(Array);
       PPCGArray.n_ref = 0;
       PPCGArray.refs = nullptr;
       PPCGArray.accessed = true;
       PPCGArray.read_only_scalar =

test/GPGPU/array-with-elem-type-smaller-than-byte.ll

+; RUN: opt %loadPolly -S -polly-codegen-ppcg \
+; RUN: -polly-use-llvm-names < %s
+; ModuleID = 'test/GPGPU/zero-size-array.ll'
+source_filename = "bugpoint-output-135b6ca.bc"
+target datalayout = "e-p:64:64:64-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f16:16:16-f32:32:32-f64:64:64-f128:128:128-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
+target triple = "x86_64-unknown-linux-gnu"
+
+
+; We used to divide the element size by 8 to arrive at the 'actual' size
+; of an array element. This used to cause arrays that have an element size
+; of less than 8 to collapse to size 0. This test makes sure that it does
+; not happen anymore.
+
+; f(int *niters_ptr, int *arr[0]) {
+;     const int inters = *niters_ptr;
+;     for(int i = 0; i < niters; i++) {
+;       arr[0][i + 1] = 0
+;     }
+; }
+
+; Function Attrs: nounwind uwtable
+define void @f(i32* noalias %niters.ptr, [0 x i32]* noalias %arr) #0 {
+entry:
+  %niters = load i32, i32* %niters.ptr, align 4
+  br label %loop.body
+
+loop.body:                                             ; preds = %loop.body, %entry
+  %indvar = phi i32 [ %indvar.next, %loop.body ], [ 1, %entry ]
+  %indvar.sext = sext i32 %indvar to i64
+  %arr.slot = getelementptr [0 x i32], [0 x i32]* %arr, i64 0, i64 %indvar.sext
+  store i32 0, i32* %arr.slot, align 4
+  %tmp8 = icmp eq i32 %indvar, %niters
+  %indvar.next = add i32 %indvar, 1
+  br i1 %tmp8, label %loop.exit, label %loop.body
+
+loop.exit:                                    ; preds = %loop.body
+  %tmp10 = icmp sgt i32 undef, 0
+  br label %auxiliary.loop
+
+auxiliary.loop:                                            ; preds = %"101", %loop.exit
+  %tmp11 = phi i1 [ %tmp10, %loop.exit ], [ undef, %auxiliary.loop ]
+  br i1 undef, label %auxiliary.loop, label %exit
+
+exit:                              ; preds = %auxiliary.loop
+  ret void
+}
+
+attributes #0 = { nounwind uwtable }