Move to opaque llvm pointers (#8614)

For a long time llvm has been slowly moving to a model where pointers
are an opaque type, instead of knowing the pointee type. This has been
complete for a while now, so they've started deprecating the APIs for
constructing a pointer with a pointee type (these APIs ignore the
pointee type anyway), or doing pointer casts, which are no-ops. This PR
removes use of those APIs and is a nice simplification of some code.

Author: abadams

src/CodeGen_ARM.cpp

@@ -1500,7 +1500,7 @@ void CodeGen_ARM::visit(const Store *op) {
                   << (t.is_float() ? 'f' : 'i')
                   << t.bits();
             arg_types = vector<llvm::Type *>(num_vecs + 2, intrin_llvm_type);
-            arg_types.front() = PointerType::get(i8_t, 0);
+            arg_types.front() = ptr_t;
             arg_types.back() = i32_t;
         } else {
             if (is_sve) {
@@ -1512,7 +1512,7 @@ void CodeGen_ARM::visit(const Store *op) {
                       << t.bits();
                 arg_types = vector<llvm::Type *>(num_vecs, intrin_llvm_type);
                 arg_types.emplace_back(get_vector_type(i1_t, intrin_type.lanes() / target_vscale(), VectorTypeConstraint::VScale));  // predicate
-                arg_types.emplace_back(PointerType::get(llvm_type_of(intrin_type.element_of()), 0));
+                arg_types.emplace_back(ptr_t);
             } else {
                 instr << "llvm.aarch64.neon.st"
                       << num_vecs
@@ -1522,7 +1522,7 @@ void CodeGen_ARM::visit(const Store *op) {
                       << t.bits()
                       << ".p0";
                 arg_types = vector<llvm::Type *>(num_vecs + 1, intrin_llvm_type);
-                arg_types.back() = PointerType::get(llvm_type_of(intrin_type.element_of()), 0);
+                arg_types.back() = ptr_t;
             }
         }
         llvm::FunctionType *fn_type = FunctionType::get(llvm::Type::getVoidTy(*context), arg_types, false);
@@ -1545,8 +1545,6 @@ void CodeGen_ARM::visit(const Store *op) {
             }
 
             if (target.bits == 32) {
-                // The arm32 versions take an i8*, regardless of the type stored.
-                ptr = builder->CreatePointerCast(ptr, PointerType::get(i8_t, 0));
                 // Set the pointer argument
                 slice_args.insert(slice_args.begin(), ptr);
                 // Set the alignment argument
@@ -1823,7 +1821,7 @@ void CodeGen_ARM::visit(const Load *op) {
                 llvm::Type *elt = llvm_type_of(op->type.element_of());
                 llvm::Type *slice_type = get_vector_type(elt, slice_lanes);
                 StructType *sret_type = StructType::get(module->getContext(), std::vector(stride->value, slice_type));
-                std::vector<llvm::Type *> arg_types{get_vector_type(i1_t, slice_lanes), PointerType::get(elt, 0)};
+                std::vector<llvm::Type *> arg_types{get_vector_type(i1_t, slice_lanes), ptr_t};
                 llvm::FunctionType *fn_type = FunctionType::get(sret_type, arg_types, false);
                 FunctionCallee fn = module->getOrInsertFunction(instr.str(), fn_type);
 

src/CodeGen_Hexagon.cpp

@@ -2228,10 +2228,6 @@ void CodeGen_Hexagon::visit(const Allocate *alloc) {
         Value *args[2] = {get_user_context(), llvm_size};
 
         Value *call = builder->CreateCall(alloc_fn, args);
-
-        // Fix the type to avoid pointless bitcasts later
-        call = builder->CreatePointerCast(
-            call, PointerType::get(llvm_type_of(alloc->type), 0));
         allocation.ptr = call;
 
         // Assert that the allocation worked.

src/CodeGen_Internal.cpp

@@ -723,10 +723,10 @@ void set_function_attributes_from_halide_target_options(llvm::Function &fn) {
 }
 
 void embed_bitcode(llvm::Module *M, const string &halide_command) {
-    // Save llvm.compiler.used and remote it.
+    // Save llvm.compiler.used and remove it.
     SmallVector<Constant *, 2> used_array;
     SmallVector<GlobalValue *, 4> used_globals;
-    llvm::Type *used_element_type = PointerType::get(llvm::Type::getInt8Ty(M->getContext()), 0);
+    llvm::Type *used_element_type = PointerType::get(M->getContext(), 0);
     GlobalVariable *used = collectUsedGlobalVariables(*M, used_globals, true);
     for (auto *GV : used_globals) {
         if (GV->getName() != "llvm.embedded.module" &&

src/CodeGen_LLVM.cpp

@@ -18,6 +18,7 @@ template<typename, typename>
 class IRBuilder;
 class LLVMContext;
 class Type;
+class PointerType;
 class StructType;
 class Instruction;
 class CallInst;
@@ -208,6 +209,7 @@ class CodeGen_LLVM : public IRVisitor {
     /** Some useful llvm types */
     // @{
     llvm::Type *void_t = nullptr, *i1_t = nullptr, *i8_t = nullptr, *i16_t = nullptr, *i32_t = nullptr, *i64_t = nullptr, *f16_t = nullptr, *f32_t = nullptr, *f64_t = nullptr;
+    llvm::PointerType *ptr_t = nullptr;
     llvm::StructType *halide_buffer_t_type = nullptr,
                      *type_t_type,
                      *dimension_t_type,

src/CodeGen_LLVM.h

@@ -138,7 +138,7 @@ void CodeGen_PTX_Dev::add_kernel(Stmt stmt,
     vector<llvm::Type *> arg_types(args.size());
     for (size_t i = 0; i < args.size(); i++) {
         if (args[i].is_buffer) {
-            arg_types[i] = PointerType::get(llvm_type_of(UInt(8)), 0);
+            arg_types[i] = ptr_t;
         } else {
             arg_types[i] = llvm_type_of(args[i].type);
         }
@@ -311,7 +311,7 @@ void CodeGen_PTX_Dev::visit(const Allocate *alloc) {
                                             << "(Memoization is not supported inside GPU kernels at present.)\n";
     if (alloc->memory_type == MemoryType::GPUShared) {
         // PTX uses zero in address space 3 as the base address for shared memory
-        Value *shared_base = Constant::getNullValue(PointerType::get(i8_t, 3));
+        Value *shared_base = Constant::getNullValue(PointerType::get(*context, 3));
         sym_push(alloc->name, shared_base);
     } else {
         debug(2) << "Allocate " << alloc->name << " on device\n";

src/CodeGen_PTX_Dev.cpp

@@ -203,7 +203,7 @@ CodeGen_Posix::Allocation CodeGen_Posix::create_allocation(const std::string &na
             // allocation that occurs conditionally. TODO: Why not
             // just register the destructor at entry?
 
-            builder->CreateStore(builder->CreatePointerCast(slot, PointerType::get(i8_t, 0)), allocation.destructor);
+            builder->CreateStore(slot, allocation.destructor);
             free_stack_allocs.erase(it);
         } else {
             // Stack allocation with a dynamic size
@@ -220,14 +220,11 @@ CodeGen_Posix::Allocation CodeGen_Posix::create_allocation(const std::string &na
 
         llvm::Function::arg_iterator arg_iter = alloc_fn->arg_begin();
         ++arg_iter;  // skip the user context *
-        slot = builder->CreatePointerCast(slot, arg_iter->getType());
         ++arg_iter;  // skip the pointer to the stack slot
         llvm::Type *size_type = arg_iter->getType();
         llvm_size = builder->CreateIntCast(llvm_size, size_type, false);
         Value *args[3] = {get_user_context(), slot, llvm_size};
         Value *call = builder->CreateCall(alloc_fn, args);
-        llvm::Type *ptr_type = PointerType::get(llvm_type_of(type), 0);
-        call = builder->CreatePointerCast(call, ptr_type);
 
         // Figure out how much we need to allocate on the real stack
         Value *returned_non_null = builder->CreateIsNotNull(call);
@@ -240,21 +237,19 @@ CodeGen_Posix::Allocation CodeGen_Posix::create_allocation(const std::string &na
         builder->SetInsertPoint(need_alloca_bb);
 
         // Allocate it. It's zero most of the time.
-        AllocaInst *alloca_inst = builder->CreateAlloca(PointerType::get(i8_t, 0), llvm_size);
+        AllocaInst *alloca_inst = builder->CreateAlloca(ptr_t, llvm_size);
         // Give it the right alignment
         alloca_inst->setAlignment(llvm::Align(native_vector_bits() / 8));
 
         // Set the pseudostack slot ptr to the right thing so we reuse
         // this pointer next time around.
-        Value *stack_ptr = builder->CreatePointerCast(alloca_inst, ptr_type);
-        Value *slot_ptr_ptr = builder->CreatePointerCast(slot, PointerType::get(ptr_type, 0));
-        builder->CreateStore(stack_ptr, slot_ptr_ptr);
+        builder->CreateStore(alloca_inst, slot);
 
         builder->CreateBr(after_bb);
         builder->SetInsertPoint(after_bb);
 
-        PHINode *phi = builder->CreatePHI(ptr_type, 2);
-        phi->addIncoming(stack_ptr, need_alloca_bb);
+        PHINode *phi = builder->CreatePHI(ptr_t, 2);
+        phi->addIncoming(alloca_inst, need_alloca_bb);
         phi->addIncoming(call, here_bb);
 
         allocation.ptr = phi;
@@ -282,9 +277,6 @@ CodeGen_Posix::Allocation CodeGen_Posix::create_allocation(const std::string &na
 
             Value *call = builder->CreateCall(malloc_fn, args);
 
-            // Fix the type to avoid pointless bitcasts later
-            call = builder->CreatePointerCast(call, PointerType::get(llvm_type_of(type), 0));
-
             allocation.ptr = call;
         }
 

src/CodeGen_Posix.cpp

@@ -907,7 +907,7 @@ Func Stage::rfactor(const vector<pair<RVar, Var>> &preserved) {
 
     ReductionDomain rdom{definition.schedule().rvars(), definition.predicate(), true};
     SubstitutionMap rdom_promises;
-    for (int i = 0; i < rdom.domain().size(); i++) {
+    for (int i = 0; i < (int)rdom.domain().size(); i++) {
         const auto &[var, min, extent] = rdom.domain()[i];
         rdom_promises.emplace(var, promise_clamped(RVar(rdom, i), min, min + extent - 1));
     }