AMDGPU: Fix assert on alloca of array of struct

[kzhuravl]

LGTM

[arsenm]

r313282

lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp

Value *AMDGPUPromoteAlloca::getWorkitemID(IRBuilder<> &Builder, unsigned N) {
 
   Function *WorkitemIdFn = Intrinsic::getDeclaration(Mod, IntrID);
   CallInst *CI = Builder.CreateCall(WorkitemIdFn);
   ST.makeLIDRangeMetadata(CI);
 
   return CI;
 }
 
-static VectorType *arrayTypeToVecType(Type *ArrayTy) {
-  return VectorType::get(ArrayTy->getArrayElementType(),
-                         ArrayTy->getArrayNumElements());
+static VectorType *arrayTypeToVecType(ArrayType *ArrayTy) {
+  return VectorType::get(ArrayTy->getElementType(),
+                         ArrayTy->getNumElements());
 }
 
 static Value *
 calculateVectorIndex(Value *Ptr,
                      const std::map<GetElementPtrInst *, Value *> &GEPIdx) {
   GetElementPtrInst *GEP = cast<GetElementPtrInst>(Ptr);
 
   auto I = GEPIdx.find(GEP);
static bool tryPromoteAllocaToVector(AllocaInst *Alloca, AMDGPUAS AS) {
 
   DEBUG(dbgs() << "Alloca candidate for vectorization\n");
 
   // FIXME: There is no reason why we can't support larger arrays, we
   // are just being conservative for now.
   // FIXME: We also reject alloca's of the form [ 2 x [ 2 x i32 ]] or equivalent. Potentially these
   // could also be promoted but we don't currently handle this case
   if (!AllocaTy ||
-      AllocaTy->getElementType()->isVectorTy() ||
-      AllocaTy->getElementType()->isArrayTy() ||
       AllocaTy->getNumElements() > 4 ||
-      AllocaTy->getNumElements() < 2) {
+      AllocaTy->getNumElements() < 2 ||
+      !VectorType::isValidElementType(AllocaTy->getElementType())) {
     DEBUG(dbgs() << "  Cannot convert type to vector\n");
     return false;
   }
 
   std::map<GetElementPtrInst*, Value*> GEPVectorIdx;
   std::vector<Value*> WorkList;
   for (User *AllocaUser : Alloca->users()) {
     GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(AllocaUser);

test/CodeGen/AMDGPU/promote-alloca-array-aggregate.ll

 ; RUN: opt -S -mtriple=amdgcn-amd-amdhsa -amdgpu-promote-alloca < %s | FileCheck --check-prefix=OPT %s
 
 ; Make sure that array alloca loaded and stored as multi-element aggregates are handled correctly
 ; Strictly the promote-alloca pass shouldn't have to deal with this case as it is non-canonical, but
 ; the pass should handle it gracefully if it is
 ; The checks look for lines that previously caused issues in PromoteAlloca (non-canonical). Opt
 ; should now leave these unchanged
 
 ; OPT-LABEL: @promote_1d_aggr(
 ; OPT: store [1 x float] %tmp3, [1 x float]* %f1
 
 %Block = type { [1 x float], i32 }
 %gl_PerVertex = type { <4 x float>, float, [1 x float], [1 x float] }
+%struct = type { i32, i32 }
 
 @block = external addrspace(1) global %Block
 @pv = external addrspace(1) global %gl_PerVertex
 
 define amdgpu_vs void @promote_1d_aggr() #0 {
   %i = alloca i32
   %f1 = alloca [1 x float]
   %tmp = getelementptr %Block, %Block addrspace(1)* @block, i32 0, i32 1
define amdgpu_ps void @promote_double_aggr() #0 {
   %tmp17 = fptrunc double %tmp16 to float
   %tmp18 = insertelement <4 x float> undef, float %tmp17, i32 0
   %tmp19 = insertelement <4 x float> %tmp18, float %tmp17, i32 1
   %tmp20 = insertelement <4 x float> %tmp19, float %tmp17, i32 2
   %tmp21 = insertelement <4 x float> %tmp20, float %tmp17, i32 3
   store <4 x float> %tmp21, <4 x float> addrspace(1)* @frag_color
   ret void
 }
+
+; Don't crash on a type that isn't a valid vector element.
+; OPT-LABEL: @alloca_struct(
+define amdgpu_kernel void @alloca_struct() #0 {
+entry:
+  %alloca = alloca [2 x %struct], align 4
+  ret void
+}