Fix clippy

Author: LegNeato

crates/cust/src/device.rs

@@ -352,8 +352,7 @@ impl Device {
         unsafe {
             driver_sys::cuDeviceGetUuid(&mut cu_uuid, self.device).to_result()?;
         }
-        #[allow(clippy::unnecessary_cast)]
-        let uuid: [u8; 16] = cu_uuid.bytes.map(|byte| byte as u8);
+        let uuid: [u8; 16] = cu_uuid.bytes;
         Ok(uuid)
     }
 

crates/ptx_compiler/src/lib.rs

@@ -102,11 +102,8 @@ impl CompilerFailure {
                 .to_result()?;
             let size = size.assume_init();
             let mut vec = Vec::with_capacity(size);
-            nvptx_compiler_sys::nvPTXCompilerGetErrorLog(
-                self.handle,
-                vec.as_mut_ptr() as *mut c_char,
-            )
-            .to_result()?;
+            nvptx_compiler_sys::nvPTXCompilerGetErrorLog(self.handle, vec.as_mut_ptr())
+                .to_result()?;
             vec.set_len(size);
             Ok(String::from_utf8_lossy(&vec).to_string())
         }
@@ -138,11 +135,8 @@ impl CompiledProgram {
                 .to_result()?;
             let size = size.assume_init();
             let mut vec = Vec::with_capacity(size);
-            nvptx_compiler_sys::nvPTXCompilerGetInfoLog(
-                self.handle,
-                vec.as_mut_ptr() as *mut c_char,
-            )
-            .to_result()?;
+            nvptx_compiler_sys::nvPTXCompilerGetInfoLog(self.handle, vec.as_mut_ptr())
+                .to_result()?;
             vec.set_len(size);
             Ok(String::from_utf8_lossy(&vec).to_string())
         }

crates/rustc_codegen_nvvm/src/builder.rs

@@ -549,7 +549,7 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         ty: &'ll Type,
         ptr: &'ll Value,
         order: AtomicOrdering,
-        size: Size,
+        _size: Size,
     ) -> &'ll Value {
         // Since for any A, A | 0 = A, and performing atomics on constant memory is UB in Rust, we can abuse or to perform atomic reads.
         self.atomic_rmw(AtomicRmwBinOp::AtomicOr, ptr, self.const_int(ty, 0), order)
@@ -782,7 +782,7 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         val: &'ll Value,
         ptr: &'ll Value,
         order: AtomicOrdering,
-        size: Size,
+        _size: Size,
     ) {
         // We can exchange *ptr with val, and then discard the result.
         self.atomic_rmw(AtomicRmwBinOp::AtomicXchg, ptr, val, order);
@@ -1164,8 +1164,7 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
                 // We pack the result, to match the behaviour of proper atomics / emulated thread-local atomics.
                 let res = builder.const_undef(res_type);
                 let res = builder.insert_value(res, load, 0);
-                let res = builder.insert_value(res, compare, 1);
-                res
+                builder.insert_value(res, compare, 1)
             },
         );
         // Unpack the result
@@ -1190,7 +1189,7 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
                 unsafe {
                     llvm::LLVMBuildAtomicRMW(
                         builder.llbuilder,
-                        op,
+                        op.into(),
                         dst,
                         src,
                         crate::llvm::AtomicOrdering::from_generic(order),

crates/rustc_codegen_nvvm/src/llvm.rs

@@ -1960,7 +1960,7 @@ unsafe extern "C" {
 
     pub fn LLVMBuildAtomicRMW<'a>(
         B: &Builder<'a>,
-        Op: AtomicRmwBinOp,
+        Op: LLVMAtomicRmwBinOp,
         LHS: &Value,
         RHS: &Value,
         Order: AtomicOrdering,
@@ -1994,3 +1994,38 @@ impl AtomicOrdering {
         }
     }
 }
+
+/// FFI-safe mirror of LLVMAtomicRMWBinOp from the LLVM C API.
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub enum LLVMAtomicRmwBinOp {
+    AtomicXchg = 0,
+    AtomicAdd = 1,
+    AtomicSub = 2,
+    AtomicAnd = 3,
+    AtomicNand = 4,
+    AtomicOr = 5,
+    AtomicXor = 6,
+    AtomicMax = 7,
+    AtomicMin = 8,
+    AtomicUMax = 9,
+    AtomicUMin = 10,
+}
+
+impl From<AtomicRmwBinOp> for LLVMAtomicRmwBinOp {
+    fn from(op: AtomicRmwBinOp) -> Self {
+        match op {
+            AtomicRmwBinOp::AtomicXchg => Self::AtomicXchg,
+            AtomicRmwBinOp::AtomicAdd => Self::AtomicAdd,
+            AtomicRmwBinOp::AtomicSub => Self::AtomicSub,
+            AtomicRmwBinOp::AtomicAnd => Self::AtomicAnd,
+            AtomicRmwBinOp::AtomicNand => Self::AtomicNand,
+            AtomicRmwBinOp::AtomicOr => Self::AtomicOr,
+            AtomicRmwBinOp::AtomicXor => Self::AtomicXor,
+            AtomicRmwBinOp::AtomicMax => Self::AtomicMax,
+            AtomicRmwBinOp::AtomicMin => Self::AtomicMin,
+            AtomicRmwBinOp::AtomicUMax => Self::AtomicUMax,
+            AtomicRmwBinOp::AtomicUMin => Self::AtomicUMin,
+        }
+    }
+}