Fix OpenCL Work-Item function arguments in Polly

[franz]

Summary

Work-Item related OpenCL functions usually return size_t type, which is different for 64bit and 32bit SPIR IR. Polly used i32 type everywhere, causing it to fail on assertions.

Also changes the dimension to be always i32 type.

[philip.pfaffe]

What's the relationship between this and D48774?

[alaindenzler]

Sorry Michal, I already submitted this patch a week ago.. see D48774

Edit: The patch in D48774 is based on this patch, but with testcase and comments

[franz]

Alain, OK i wasn't aware. Apologies for confusion, i'll close this

[grosser]

Sorry guys. Alain just started to look into this last week and we wanted to get him up-to-speed before getting in touch with you. I should have helped to coordinate better. I asked Alain to discuss with you which / what patches are still needed.

lib/CodeGen/PPCGCodeGeneration.cpp

private:
   /// Insert intrinsic functions to obtain thread and block ids.
   ///
   /// @param The kernel to generate the intrinsic functions for.
   void insertKernelIntrinsics(ppcg_kernel *Kernel);
 
   /// Insert function calls to retrieve the SPIR group/local ids.
   ///
   /// @param The kernel to generate the function calls for.
-  void insertKernelCallsSPIR(ppcg_kernel *Kernel);
+  void insertKernelCallsSPIR(ppcg_kernel *Kernel, bool SizeTypeIs64bit);
 
   /// Setup the creation of functions referenced by the GPU kernel.
   ///
   /// 1. Create new function declarations in GPUModule which are the same as
   /// SubtreeFunctions.
   ///
   /// 2. Populate IslNodeBuilder::ValueMap with mappings from
   /// old functions (that come from the original module) to new functions
void GPUNodeBuilder::insertKernelIntrinsics(ppcg_kernel *Kernel) {
   }
 
   for (int i = 0; i < Kernel->n_block; ++i) {
     isl_id *Id = isl_id_list_get_id(Kernel->thread_ids, i);
     addId(Id, IntrinsicsTID[i]);
   }
 }
 
-void GPUNodeBuilder::insertKernelCallsSPIR(ppcg_kernel *Kernel) {
+void GPUNodeBuilder::insertKernelCallsSPIR(ppcg_kernel *Kernel, bool SizeTypeIs64bit) {
   const char *GroupName[3] = {"_Z12get_group_idj",
                               "_Z12get_group_idj",
                               "_Z12get_group_idj"};
 
   const char *LocalName[3] = {"_Z12get_local_idj",
                               "_Z12get_local_idj",
                               "_Z12get_local_idj"};
+  IntegerType *SizeType = SizeTypeIs64bit ? Builder.getInt64Ty() : Builder.getInt32Ty();
 
-  auto createFunc = [this](const char *Name, __isl_take isl_id *Id, int Dim) mutable {
+  auto createFunc = [this](const char *Name, __isl_take isl_id *Id, int Dim, IntegerType *SizeType) mutable {
     Module *M = Builder.GetInsertBlock()->getParent()->getParent();
     Function *FN = M->getFunction(Name);
 
     // If FN is not available, declare it.
     if (!FN) {
       GlobalValue::LinkageTypes Linkage = Function::ExternalLinkage;
       std::vector<Type *> Args;
       Args.push_back(Builder.getInt32Ty());
-      FunctionType *Ty = FunctionType::get(Builder.getInt32Ty(), Args, false);
+      FunctionType *Ty = FunctionType::get(SizeType, Args, false);
       FN = Function::Create(Ty, Linkage, Name, M);
       FN->setCallingConv(CallingConv::SPIR_FUNC);
     }
 
     Value *Val = Builder.CreateCall(FN, {Builder.getInt32(Dim)});
-    Val = Builder.CreateIntCast(Val, Builder.getInt64Ty(), false, Name);
     IDToValue[Id] = Val;
     KernelIDs.insert(std::unique_ptr<isl_id, IslIdDeleter>(Id));
   };
 
   for (int i = 0; i < Kernel->n_grid; ++i)
-    createFunc(GroupName[i], isl_id_list_get_id(Kernel->block_ids, i), i);
+    createFunc(GroupName[i], isl_id_list_get_id(Kernel->block_ids, i), i, SizeType);
 
   for (int i = 0; i < Kernel->n_block; ++i)
-    createFunc(LocalName[i], isl_id_list_get_id(Kernel->thread_ids, i), i);
+    createFunc(LocalName[i], isl_id_list_get_id(Kernel->thread_ids, i), i, SizeType);
 }
 
 void GPUNodeBuilder::prepareKernelArguments(ppcg_kernel *Kernel, Function *FN) {
   auto Arg = FN->arg_begin();
   for (long i = 0; i < Kernel->n_array; i++) {
     if (!ppcg_kernel_requires_array_argument(Kernel, i))
       continue;
 
void GPUNodeBuilder::createKernelFunction(
   prepareKernelArguments(Kernel, FN);
   createKernelVariables(Kernel, FN);
 
   switch (Arch) {
   case GPUArch::NVPTX64:
     insertKernelIntrinsics(Kernel);
     break;
   case GPUArch::SPIR32:
+    insertKernelCallsSPIR(Kernel, false);
+    break;
   case GPUArch::SPIR64:
-    insertKernelCallsSPIR(Kernel);
+    insertKernelCallsSPIR(Kernel, true);
     break;
   }
 }
 
 SmallVector<uint8_t, 1> GPUNodeBuilder::createKernelASM() {
   llvm::Triple GPUTriple;
 
   switch (Arch) {