clippy fixes + added an assertion to ensure typed pointers are *NOT* used

Author: FractalFir

crates/rustc_codegen_nvvm/src/abi.rs

@@ -4,7 +4,7 @@ use libc::c_uint;
 use rustc_abi::BackendRepr::Scalar;
 use rustc_abi::CanonAbi;
 use rustc_abi::Size;
-use rustc_abi::{HasDataLayout, Primitive, Reg, RegKind};
+use rustc_abi::{Primitive, Reg, RegKind};
 use rustc_codegen_ssa::mir::operand::OperandRef;
 use rustc_codegen_ssa::mir::operand::OperandValue;
 use rustc_codegen_ssa::mir::place::{PlaceRef, PlaceValue};
@@ -305,7 +305,7 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
             PassMode::Cast { cast, .. } => cast.llvm_type(cx),
             PassMode::Indirect { .. } => {
                 idx += 1;
-                llargument_tys.push(cx.type_ptr_to(self.ret.memory_ty(cx)));
+                llargument_tys.push(cx.type_i8p());
                 cx.type_void()
             }
         };
@@ -353,7 +353,7 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
                     attrs: _,
                     meta_attrs: None,
                     on_stack: _,
-                } => cx.type_ptr_to(arg.memory_ty(cx)),
+                } => cx.type_i8p(),
             };
             let (new, changed) = get_transformed_type(cx, llarg_ty);
             if changed {
@@ -564,7 +564,6 @@ impl<'tcx> AbiBuilderMethods for Builder<'_, '_, 'tcx> {
 }
 
 pub(crate) trait ArgAbiExt<'ll, 'tcx> {
-    fn memory_ty(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Type;
     fn store(
         &self,
         bx: &mut Builder<'_, 'll, 'tcx>,
@@ -580,12 +579,6 @@ pub(crate) trait ArgAbiExt<'ll, 'tcx> {
 }
 
 impl<'ll, 'tcx> ArgAbiExt<'ll, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
-    /// Gets the LLVM type for a place of the original Rust type of
-    /// this argument/return, i.e., the result of `type_of::type_of`.
-    fn memory_ty(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Type {
-        self.layout.llvm_type(cx)
-    }
-
     /// Stores a direct/indirect value described by this ArgAbi into a
     /// place for the original Rust type of this argument/return.
     /// Can be used for both storing formal arguments into Rust variables

crates/rustc_codegen_nvvm/src/builder.rs

@@ -4,7 +4,7 @@ use std::ptr;
 
 use libc::{c_char, c_uint};
 use rustc_abi as abi;
-use rustc_abi::{AddressSpace, Align, HasDataLayout, Size, TargetDataLayout, WrappingRange};
+use rustc_abi::{Align, HasDataLayout, Size, TargetDataLayout, WrappingRange};
 use rustc_codegen_ssa::MemFlags;
 use rustc_codegen_ssa::common::{AtomicRmwBinOp, IntPredicate, RealPredicate, TypeKind};
 use rustc_codegen_ssa::mir::operand::{OperandRef, OperandValue};
@@ -720,7 +720,7 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         flags: MemFlags,
     ) -> &'ll Value {
         assert_eq!(self.cx.type_kind(self.cx.val_ty(ptr)), TypeKind::Pointer);
-        let ptr = self.check_store(val, ptr);
+
         let address_space = unsafe { llvm::LLVMGetPointerAddressSpace(self.val_ty(ptr)) };
         let store_pointer_ty = unsafe { llvm::LLVMPointerType(self.val_ty(val), address_space) };
 
@@ -784,7 +784,7 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
                 UNNAMED,
             );
             self.pointercast(
-                ptr,
+                res,
                 self.type_i8p_ext(rustc_abi::AddressSpace(address_space)),
             )
         }
@@ -809,7 +809,7 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
                 UNNAMED,
             );
             self.pointercast(
-                ptr,
+                res,
                 self.type_i8p_ext(rustc_abi::AddressSpace(address_space)),
             )
         }
@@ -917,20 +917,20 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
 
     fn bitcast(&mut self, mut val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {
         trace!("Bitcast `{:?}` to ty `{:?}`", val, dest_ty);
-        unsafe {
-            let ty = self.val_ty(val);
-            let kind = llvm::LLVMRustGetTypeKind(ty);
-            if kind == llvm::TypeKind::Pointer {
-                let element = self.element_type(ty);
-                let addrspace = llvm::LLVMGetPointerAddressSpace(ty);
-                let new_ty = self.type_ptr_to_ext(element, AddressSpace::ZERO);
-                if addrspace != 0 {
-                    trace!("injecting addrspace cast for `{:?}` to `{:?}`", ty, new_ty);
-                    val = llvm::LLVMBuildAddrSpaceCast(self.llbuilder, val, new_ty, UNNAMED);
-                }
+
+        let ty = self.val_ty(val);
+        let kind = unsafe { llvm::LLVMRustGetTypeKind(ty) };
+
+        if kind == llvm::TypeKind::Pointer {
+            let element = self.element_type(ty);
+            let addrspace = unsafe { llvm::LLVMGetPointerAddressSpace(ty) };
+            let new_ty = unsafe { llvm::LLVMPointerType(element, 0) };
+            if addrspace != 0 {
+                trace!("injecting addrspace cast for `{:?}` to `{:?}`", ty, new_ty);
+                val = unsafe { llvm::LLVMBuildAddrSpaceCast(self.llbuilder, val, new_ty, UNNAMED) };
             }
-            llvm::LLVMBuildBitCast(self.llbuilder, val, dest_ty, UNNAMED)
         }
+        unsafe { llvm::LLVMBuildBitCast(self.llbuilder, val, dest_ty, UNNAMED) }
     }
 
     fn intcast(&mut self, val: &'ll Value, dest_ty: &'ll Type, is_signed: bool) -> &'ll Value {
@@ -1198,7 +1198,7 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         let res = self.atomic_op(
             dst,
             tuple,
-            |builder, dst, ty| {
+            |builder, dst, _| {
                 let address_space =
                     unsafe { llvm::LLVMGetPointerAddressSpace(builder.val_ty(dst)) };
                 let dst_ty = unsafe { llvm::LLVMPointerType(builder.val_ty(cmp), address_space) };
@@ -1216,7 +1216,7 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
                     )
                 }
             },
-            |builder, dst, ty| {
+            |builder, dst, _| {
                 let dst = builder.pointercast(dst, unsafe {
                     llvm::LLVMPointerType(
                         builder.val_ty(cmp),
@@ -1698,20 +1698,6 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
 
     fn noundef_metadata(&mut self, _load: &'ll Value) {}
 
-    fn check_store(&mut self, val: &'ll Value, ptr: &'ll Value) -> &'ll Value {
-        let dest_ptr_ty = self.cx.val_ty(ptr);
-        let stored_ty = self.cx.val_ty(val);
-        let stored_ptr_ty = self.cx.type_ptr_to(stored_ty);
-
-        assert_eq!(self.cx.type_kind(dest_ptr_ty), TypeKind::Pointer);
-
-        if dest_ptr_ty == stored_ptr_ty {
-            ptr
-        } else {
-            self.bitcast(ptr, stored_ptr_ty)
-        }
-    }
-
     fn check_call<'b>(
         &mut self,
         typ: &str,

crates/rustc_codegen_nvvm/src/const_ty.rs

@@ -1,5 +1,5 @@
 use crate::llvm::{self, Bool, False, True, Type, Value};
-use crate::{consts::const_alloc_to_llvm, context::CodegenCx, ty::LayoutLlvmExt};
+use crate::{consts::const_alloc_to_llvm, context::CodegenCx};
 use libc::c_uint;
 use rustc_abi as abi;
 use rustc_abi::Primitive::Pointer;
@@ -11,7 +11,6 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_hashes::Hash128;
 use rustc_middle::bug;
 use rustc_middle::mir::interpret::{ConstAllocation, GlobalAlloc, Scalar};
-use rustc_middle::ty::layout::LayoutOf;
 use tracing::trace;
 
 impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> {
@@ -99,7 +98,7 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> {
                 g
             });
         let len = s.len();
-        let ty = self.type_ptr_to(self.layout_of(self.tcx.types.str_).llvm_type(self));
+        let ty = self.type_i8p();
         let cs = unsafe { llvm::LLVMConstPointerCast(val, ty) };
         (cs, self.const_usize(len as u64))
     }

crates/rustc_codegen_nvvm/src/ty.rs

@@ -55,9 +55,7 @@ impl Type {
 
 impl<'ll> CodegenCx<'ll, '_> {
     pub(crate) fn voidp(&self) -> &'ll Type {
-        // llvm uses i8* for void ptrs, void* is invalid
-        let i8_ty = self.type_i8();
-        self.type_ptr_to_ext(i8_ty, AddressSpace::ZERO)
+        self.type_i8p()
     }
 
     pub(crate) fn type_named_struct(&self, name: &str) -> &'ll Type {
@@ -116,11 +114,15 @@ impl<'ll> CodegenCx<'ll, '_> {
             "don't call ptr_to on function types, use ptr_to_llvm_type on FnAbi instead or explicitly specify an address space if it makes sense"
         );
 
-        unsafe { self.type_ptr_to_ext(ty, AddressSpace::ZERO) }
+        self.type_ptr_to_ext(ty, AddressSpace::ZERO)
     }
     #[track_caller]
     pub(crate) fn type_ptr_to_ext(&self, ty: &'ll Type, address_space: AddressSpace) -> &'ll Type {
-        //assert_eq!(ty,self.type_ix(8),"rustc_codegen_nvvm uses opaque pointers - specifying pointer type other than `i8` is not valid!");
+        assert_eq!(
+            ty,
+            self.type_ix(8),
+            "rustc_codegen_nvvm uses opaque pointers - specifying pointer type other than `i8` is not valid!"
+        );
         unsafe { llvm::LLVMPointerType(self.type_ix(8), address_space.0) }
     }
 
@@ -134,11 +136,6 @@ impl<'ll> CodegenCx<'ll, '_> {
         }
     }
 
-    pub(crate) fn type_pointee_for_align(&self, align: Align) -> &'ll Type {
-        let ity = Integer::approximate_align(self, align);
-        self.type_from_integer(ity)
-    }
-
     /// Return a LLVM type that has at most the required alignment,
     /// and exactly the required size, as a best-effort padding array.
     pub(crate) fn type_padding_filler(&self, size: Size, align: Align) -> &'ll Type {
@@ -341,12 +338,8 @@ impl<'tcx> LayoutLlvmExt<'tcx> for TyAndLayout<'tcx> {
             }
 
             let llty = match *self.ty.kind() {
-                ty::Ref(_, ty, _) | ty::RawPtr(ty, _) => {
-                    cx.type_ptr_to(cx.layout_of(ty).llvm_type(cx))
-                }
-                ty::Adt(def, _) if def.is_box() => {
-                    cx.type_ptr_to(cx.layout_of(self.ty.expect_boxed_ty()).llvm_type(cx))
-                }
+                ty::Ref(_, _, _) | ty::RawPtr(_, _) => cx.type_i8p(),
+                ty::Adt(def, _) if def.is_box() => cx.type_i8p(),
                 ty::FnPtr(sig, hdr) => {
                     cx.fn_ptr_backend_type(cx.fn_abi_of_fn_ptr(sig.with(hdr), ty::List::empty()))
                 }
@@ -427,17 +420,14 @@ impl<'tcx> LayoutLlvmExt<'tcx> for TyAndLayout<'tcx> {
             Float(f) => cx.type_from_float(f),
             Pointer(address_space) => {
                 // If we know the alignment, pick something better than i8.
-                let (pointee, address_space) = if let Some(PointeeInfo {
-                    safe: Some(_),
-                    align,
-                    ..
-                }) = self.pointee_info_at(cx, Size::ZERO)
+                let address_space = if let Some(PointeeInfo { safe: Some(_), .. }) =
+                    self.pointee_info_at(cx, Size::ZERO)
                 {
-                    (cx.type_pointee_for_align(align), address_space)
+                    address_space
                 } else {
-                    (cx.type_i8(), AddressSpace::ZERO)
+                    AddressSpace::ZERO
                 };
-                cx.type_ptr_to_ext(pointee, address_space)
+                cx.type_i8p_ext(address_space)
             }
         }
     }