Merge pull request #785 from hvdijk/pointertype-deprecation

Update to address PointerType deprecation.

Author: hvdijk

examples/refsi/refsi_m1/compiler/refsi_m1/source/refsi_mux_builtin_info.cpp

@@ -61,10 +61,10 @@ static IntegerType *getTransferIDTy(Module &M) {
 // Materialize the address of a DMA memory-mapped register in a basic block.
 static Value *getDmaRegAddress(IRBuilder<> &B, unsigned RegIdx) {
   Type *const DmaRegTy = getDmaRegTy(B.getContext());
-  Type *const DmaRegPtrTy = PointerType::get(DmaRegTy, 0);
+  Type *const PtrTy = B.getPtrTy(/*AddressSpace=*/0);
   Value *const DmaRegAddr = ConstantInt::get(
       DmaRegTy, REFSI_DMA_REG_ADDR(REFSI_DMA_IO_ADDRESS, RegIdx));
-  return B.CreateIntToPtr(DmaRegAddr, DmaRegPtrTy);
+  return B.CreateIntToPtr(DmaRegAddr, PtrTy);
 }
 
 // Convert the value to a format that can be directly written to a DMA register.

modules/compiler/compiler_pipeline/source/add_kernel_wrapper_pass.cpp

@@ -43,7 +43,7 @@ void compiler::utils::AddKernelWrapperPass::createNewFunctionArgTypes(
     StructType *structTy, SmallVectorImpl<KernelArgMapping> &argMappings,
     SmallVectorImpl<Type *> &argTypes) {
   // the first element is our new packed argument struct
-  argTypes.push_back(PointerType::get(structTy, /*AddressSpace=*/0));
+  argTypes.push_back(PointerType::get(M.getContext(), /*AddressSpace=*/0));
 
   uint32_t index = 0;
   // Track which arguments are *not* packed, and which index each corresponds

modules/compiler/compiler_pipeline/source/barrier_regions.cpp

@@ -312,10 +312,6 @@ Value *compiler::utils::Barrier::LiveValuesHelper::getGEP(const Value *live,
   }
 
   Value *gep;
-  Type *data_ty = live->getType();
-  if (auto *AI = dyn_cast<AllocaInst>(live)) {
-    data_ty = AI->getAllocatedType();
-  }
 
   if (auto field_it = barrier.live_variable_index_map_.find(key);
       field_it != barrier.live_variable_index_map_.end()) {
@@ -356,13 +352,6 @@ Value *compiler::utils::Barrier::LiveValuesHelper::getGEP(const Value *live,
     gep = gepBuilder.CreateInBoundsGEP(
         barrier.live_var_mem_ty_, barrier_struct, live_variable_info_idxs,
         Twine("live_gep_scalable_") + live->getName());
-
-    // Cast the pointer to the scalable vector type
-    gep = gepBuilder.CreatePointerCast(
-        gep,
-        PointerType::get(
-            data_ty,
-            cast<PointerType>(barrier_struct->getType())->getAddressSpace()));
   } else {
     // Fall back and see if this live variable is actually a decomposed
     // structure type.
@@ -1071,7 +1060,7 @@ Function *compiler::utils::Barrier::GenerateNewKernel(BarrierRegion &region) {
   const bool hasBarrierStruct = !whole_live_variables_set_.empty() &&
                                 region.schedule != BarrierSchedule::Once;
   if (hasBarrierStruct) {
-    PointerType *pty = PointerType::get(live_var_mem_ty_, 0);
+    PointerType *pty = PointerType::get(context, /*AddressSpace=*/0);
     new_func_params.push_back(pty);
   }
 

modules/compiler/compiler_pipeline/source/cl_builtin_info.cpp

@@ -1295,8 +1295,7 @@ Function *CLBuiltinInfo::getVectorEquivalent(const Builtin &B, unsigned Width,
         if (!FixedVectorType::isValidElementType(PtrRetPointeeTy)) {
           return nullptr;
         }
-        Type *NewEleTy = FixedVectorType::get(PtrRetPointeeTy, Width);
-        Type *NewType = PointerType::get(NewEleTy, OldPtrTy->getAddressSpace());
+        Type *NewType = OldPtrTy;
         TypeQualifiers NewQuals;
         TypeQualifiers EleQuals = OldQuals;
         NewQuals.push_back(EleQuals.pop_front());  // Pointer qualifier
@@ -1413,9 +1412,7 @@ Function *CLBuiltinInfo::getScalarEquivalent(const Builtin &B, Module *M) {
         [[maybe_unused]] auto *OldPointeeTy = BuiltinPointeeTypes[i];
         assert(OldPointeeTy && OldPointeeTy == PtrRetPointeeTy &&
                "Demangling inconsistency");
-        auto *OldVecTy = cast<FixedVectorType>(PtrRetPointeeTy);
-        Type *NewTy = PointerType::get(OldVecTy->getElementType(),
-                                       OldPtrTy->getAddressSpace());
+        Type *NewTy = OldPtrTy;
         TypeQualifiers NewQuals = OldQuals;
         const TypeQualifier PtrQual = NewQuals.pop_front();
         const TypeQualifier VecQual = NewQuals.pop_front();
@@ -2190,8 +2187,7 @@ Value *CLBuiltinInfo::emitBuiltinInlineVLoad(Function *F, unsigned Width,
       Data = B.CreateInsertElement(Data, Lane, Index, "vload_insert");
     }
   } else {
-    Value *VecBase = B.CreateBitCast(GEPBase, PtrTy, "vload_ptr");
-    auto *Load = B.CreateLoad(DataTy, VecBase, false, "vload");
+    auto *Load = B.CreateLoad(DataTy, GEPBase, false, "vload");
 
     const unsigned Align = DataTy->getScalarSizeInBits() / 8;
     Load->setAlignment(MaybeAlign(Align).valueOrOne());
@@ -2250,8 +2246,7 @@ Value *CLBuiltinInfo::emitBuiltinInlineVStore(Function *F, unsigned Width,
       Store = B.CreateStore(Lane, GEP, false);
     }
   } else {
-    Value *VecBase = B.CreateBitCast(GEPBase, PtrTy, "vstore_ptr");
-    Store = B.CreateStore(Data, VecBase, false);
+    Store = B.CreateStore(Data, GEPBase, false);
 
     const unsigned Align = VecDataTy->getScalarSizeInBits() / 8;
     Store->setAlignment(MaybeAlign(Align).valueOrOne());
@@ -2279,12 +2274,10 @@ Value *CLBuiltinInfo::emitBuiltinInlineVLoadHalf(Function *F, IRBuilder<> &B,
     return nullptr;
   }
   Type *U16Ty = B.getInt16Ty();
-  Type *U16PtrTy = PointerType::get(U16Ty, PtrTy->getAddressSpace());
-  Value *DataPtr = B.CreateBitCast(Ptr, U16PtrTy);
 
   // Emit the base pointer.
   Value *Offset = Args[0];
-  DataPtr = B.CreateGEP(U16Ty, DataPtr, Offset, "vload_base");
+  Value *DataPtr = B.CreateGEP(U16Ty, Ptr, Offset, "vload_base");
 
   // Load a ushort.
   Value *Data = B.CreateLoad(B.getInt16Ty(), DataPtr, "vload_half");
@@ -2368,12 +2361,10 @@ Value *CLBuiltinInfo::emitBuiltinInlineVStoreHalf(Function *F, StringRef Mode,
     return nullptr;
   }
   auto U16Ty = B.getInt16Ty();
-  Type *U16PtrTy = PointerType::get(U16Ty, PtrTy->getAddressSpace());
-  Value *DataPtr = B.CreateBitCast(Ptr, U16PtrTy);
 
   // Emit the base pointer.
   Value *Offset = Args[1];
-  DataPtr = B.CreateGEP(U16Ty, DataPtr, Offset, "vstore_base");
+  Value *DataPtr = B.CreateGEP(U16Ty, Ptr, Offset, "vstore_base");
 
   // Store the ushort.
   return B.CreateStore(Data, DataPtr);
@@ -2644,7 +2635,7 @@ Value *CLBuiltinInfo::emitBuiltinInlinePrintf(BuiltinID, IRBuilder<> &B,
   // Declare printf if needed.
   Function *Printf = M.getFunction("printf");
   if (!Printf) {
-    PointerType *PtrTy = PointerType::getUnqual(B.getInt8Ty());
+    PointerType *PtrTy = B.getPtrTy(/*AddressSpace=*/0);
     FunctionType *PrintfTy = FunctionType::get(B.getInt32Ty(), {PtrTy}, true);
     Printf =
         Function::Create(PrintfTy, GlobalValue::ExternalLinkage, "printf", &M);

modules/compiler/compiler_pipeline/source/mangling.cpp

@@ -573,7 +573,7 @@ bool NameMangler::demangleType(Lexer &L, Type *&Ty, Type **PointerEltTy,
       return false;
     }
     Quals.push_back(QualsAS->Qual);
-    return PointerType::get(nullptr, QualsAS->AS);
+    return llvm::PointerType::get(*Context, QualsAS->AS);
   }
 
   // Match scalable vector types.
@@ -620,11 +620,7 @@ bool NameMangler::demangleType(Lexer &L, Type *&Ty, Type **PointerEltTy,
     if (PointerEltTy) {
       *PointerEltTy = ElementType;
     }
-    if (ElementType->isVoidTy()) {
-      Ty = llvm::PointerType::get(Type::getInt8Ty(*Context), QualsAS->AS);
-    } else {
-      Ty = llvm::PointerType::get(ElementType, QualsAS->AS);
-    }
+    Ty = llvm::PointerType::get(*Context, QualsAS->AS);
     return true;
   }
 

modules/compiler/compiler_pipeline/source/mux_builtin_info.cpp

@@ -897,13 +897,7 @@ Type *BIMuxInfoConcept::getRemappedTargetExtTy(Type *Ty, Module &M) {
   // space to the same structure type (i.e., regardless of image dimensions,
   // etc.)
   if (TgtExtTy->getName() == "spirv.Image") {
-    return PointerType::getUnqual([&Ctx]() {
-      const char *MuxImageTyName = "MuxImage";
-      if (auto *STy = StructType::getTypeByName(Ctx, MuxImageTyName)) {
-        return STy;
-      }
-      return StructType::create(Ctx, MuxImageTyName);
-    }());
+    return PointerType::getUnqual(Ctx);
   }
 
   return nullptr;
@@ -1210,7 +1204,7 @@ BIMuxInfoConcept::getMuxSchedulingParameters(Module &M) {
     auto *const WIInfoS = getWorkItemInfoStructTy(M);
     WIInfo.ID = SchedParamIndices::WI;
     WIInfo.ParamPointeeTy = WIInfoS;
-    WIInfo.ParamTy = PointerType::get(WIInfoS, /*AddressSpace=*/0);
+    WIInfo.ParamTy = PointerType::get(Ctx, /*AddressSpace=*/0);
     WIInfo.ParamName = "wi-info";
     WIInfo.ParamDebugName = WIInfoS->getStructName().str();
     WIInfo.PassedExternally = false;
@@ -1226,7 +1220,7 @@ BIMuxInfoConcept::getMuxSchedulingParameters(Module &M) {
     auto *const WGInfoS = getWorkGroupInfoStructTy(M);
     WGInfo.ID = SchedParamIndices::WG;
     WGInfo.ParamPointeeTy = WGInfoS;
-    WGInfo.ParamTy = PointerType::get(WGInfoS, /*AddressSpace=*/0);
+    WGInfo.ParamTy = PointerType::get(Ctx, /*AddressSpace=*/0);
     WGInfo.ParamName = "wg-info";
     WGInfo.ParamDebugName = WGInfoS->getStructName().str();
     WGInfo.PassedExternally = true;

modules/compiler/compiler_pipeline/source/replace_local_module_scope_variables_pass.cpp

@@ -355,7 +355,7 @@ PreservedAnalyses compiler::utils::ReplaceLocalModuleScopeVariablesPass::run(
   // change all our functions to take a pointer to the new structTy we created
   const AttributeSet defaultAttrs;
   addParamToAllRequiredFunctions(
-      M, PointerType::get(structTy, /*AddressSpace=*/0), defaultAttrs);
+      M, PointerType::get(M.getContext(), /*AddressSpace=*/0), defaultAttrs);
 
   // Check if we have debug info, if so we need to fix it up to turn global
   // variable entries into local variable ones.

modules/compiler/compiler_pipeline/source/work_item_loops_pass.cpp

@@ -36,7 +36,6 @@
 
 using namespace llvm;
 
-#define NDEBUG_WI_LOOPS
 #define DEBUG_TYPE "work-item-loops"
 
 namespace compiler {
@@ -99,65 +98,6 @@ class BarrierWithLiveVars : public Barrier {
 }  // namespace compiler
 
 namespace {
-#ifndef NDEBUG_WI_LOOPS
-/// @brief Generate IR level printf function call Debug function only.
-///
-/// @param[in] format Format string string.
-/// @param[in] module Current module.
-/// @param[in] v Value for printing.
-/// @param[in] bb Basic block insertion point for @p v.
-///
-/// @return Return instruction to be checked.
-Instruction *IRPrintf(const std::string format, Module &module, Value *v,
-                      BasicBlock *bb) {
-  LLVMContext &context = module.getContext();
-  PointerType *ptr_type = PointerType::getUnqual(IntegerType::get(context, 8));
-
-  SmallVector<Type *, 16> args;
-  args.push_back(ptr_type);
-  FunctionType *printf_type =
-      FunctionType::get(IntegerType::get(context, 32), args, true);
-
-  bool isDeclared = true;
-  Function *func_printf = module.getFunction("printf");
-  if (!func_printf) {
-    func_printf = Function::Create(printf_type, GlobalValue::ExternalLinkage,
-                                   "printf", &module);
-    isDeclared = false;
-  }
-
-  ArrayType *array_type =
-      ArrayType::get(IntegerType::get(context, 8), format.size() + 1);
-  GlobalVariable *str;
-  if (isDeclared) {
-    str = new GlobalVariable(
-        module, array_type, true, GlobalValue::PrivateLinkage, 0, ".str",
-        nullptr, GlobalValue::ThreadLocalMode::NotThreadLocal, 2, false);
-  } else {
-    str = new GlobalVariable(
-        module, array_type, true, GlobalValue::PrivateLinkage, 0, ".str",
-        nullptr, GlobalValue::ThreadLocalMode::NotThreadLocal, 0, false);
-  }
-  str->setAlignment(MaybeAlign(1));
-
-  Constant *const_array = ConstantDataArray::getString(context, format, true);
-  SmallVector<Constant *, 16> indices;
-  ConstantInt *cst_8 = ConstantInt::get(context, APInt(64, StringRef("0"), 10));
-  indices.push_back(cst_8);
-  indices.push_back(cst_8);
-  Constant *cst_ptr = ConstantExpr::getGetElementPtr(nullptr, str, indices);
-
-  str->setInitializer(const_array);
-
-  SmallVector<Value *, 8> call_params;
-  call_params.push_back(cst_ptr);
-  call_params.push_back(v);
-
-  CallInst *call = CallInst::Create(func_printf, call_params, "", bb);
-
-  return call;
-}
-#endif  // NDEBUG_WI_LOOPS
 
 Value *materializeVF(IRBuilder<> &builder,
                      compiler::utils::VectorizationFactor vf) {
@@ -235,13 +175,6 @@ struct ScheduleGenerator {
       Value *const live_var_mem_idxs[] = {byteOffset};
       live_var_ptr =
           ir.CreateInBoundsGEP(ir.getInt8Ty(), mem_space, live_var_mem_idxs);
-
-      // cast to the live mem type
-      live_var_ptr = ir.CreatePointerCast(
-          live_var_ptr,
-          PointerType::get(
-              barrier.getLiveVarsType(),
-              cast<PointerType>(live_var_ptr->getType())->getAddressSpace()));
     }
 
     return live_var_ptr;
@@ -380,10 +313,6 @@ struct ScheduleGenerator {
     ci->setCallingConv(subkernel.getCallingConv());
     ci->setAttributes(compiler::utils::getCopiedFunctionAttrs(subkernel));
 
-#ifndef NDEBUG_WI_LOOPS
-    IRPrintf(std::string("return.kernel.body=%d\x0A"), module, ci, block);
-#endif  // NDEBUG_WI_LOOPS
-
     // And update the location of where we need to go to next (if we need to)
     const auto &successors = barrier.getSuccessorIds(i);
     if (successors.size() > 1) {

modules/compiler/source/base/source/printf_replacement_pass.cpp

@@ -839,7 +839,7 @@ PreservedAnalyses compiler::PrintfReplacementPass::run(
   // Clone functions and add extra argument for printf(). Only functions
   // directly or indirectly calling printf are given the extra parameter.
   auto new_param_type =
-      PointerType::get(getBufferEltTy(module.getContext()), 1);
+      PointerType::get(module.getContext(), /*AddressSpace=*/1);
   auto param_type_func = [new_param_type](Module &) {
     return compiler::utils::ParamTypeAttrsPair{new_param_type, AttributeSet{}};
   };

modules/compiler/spirv-ll/source/builder_core.cpp

@@ -1781,9 +1781,9 @@ llvm::Error Builder::create<OpFunction>(const OpFunction *op) {
 
         // turn the list of descriptor binding IDs into a sorted list of the
         // interface block types
-        for (auto id : binding_list) {
+        for ([[maybe_unused]] auto _ : binding_list) {
           // Blocks are always passed by pointer
-          llvm::Type *type = llvm::PointerType::get(module.getBlockType(id), 1);
+          llvm::Type *type = IRBuilder.getPtrTy(/*AddressSpace=*/1);
           SPIRV_LL_ASSERT_PTR(type);
 
           arg_types.push_back(type);
@@ -1798,8 +1798,7 @@ llvm::Error Builder::create<OpFunction>(const OpFunction *op) {
         // if this module has used any descriptor bindings add the buffer sizes
         // buffer to the argument list (1 == global address space)
         if (module.hasDescriptorBindings()) {
-          arg_types.push_back(llvm::PointerType::get(
-              getBufferSizeTy(IRBuilder.getContext()), 1));
+          arg_types.push_back(IRBuilder.getPtrTy(/*AddressSpace=*/1));
         }
 
         // create a new function type with the same return type as the original