make memcmp return a value of c_int_width instead of i32

Author: drmorr0

compiler/rustc_codegen_gcc/src/common.rs

@@ -91,6 +91,10 @@ impl<'gcc, 'tcx> ConstMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         self.const_uint(self.type_i1(), val as u64)
     }
 
+    fn const_i16(&self, i: i16) -> RValue<'gcc> {
+        self.const_int(self.type_i16(), i as i64)
+    }
+
     fn const_i32(&self, i: i32) -> RValue<'gcc> {
         self.const_int(self.type_i32(), i as i64)
     }

compiler/rustc_codegen_llvm/src/common.rs

@@ -147,6 +147,10 @@ impl<'ll, 'tcx> ConstMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         self.const_uint(self.type_i1(), val as u64)
     }
 
+    fn const_i16(&self, i: i16) -> &'ll Value {
+        self.const_int(self.type_i16(), i as i64)
+    }
+
     fn const_i32(&self, i: i32) -> &'ll Value {
         self.const_int(self.type_i32(), i as i64)
     }

compiler/rustc_codegen_llvm/src/context.rs

@@ -859,7 +859,10 @@ impl<'ll> CodegenCx<'ll, '_> {
 
         // This isn't an "LLVM intrinsic", but LLVM's optimization passes
         // recognize it like one and we assume it exists in `core::slice::cmp`
-        ifn!("memcmp", fn(i8p, i8p, t_isize) -> t_i32);
+        match self.sess().target.arch.as_str() {
+            "avr" | "msp430" => ifn!("memcmp", fn(i8p, i8p, t_isize) -> t_i16),
+            _ => ifn!("memcmp", fn(i8p, i8p, t_isize) -> t_i32),
+        }
 
         // variadic intrinsics
         ifn!("llvm.va_start", fn(i8p) -> void);

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -329,7 +329,10 @@ impl<'ll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                     let b_ptr = self.bitcast(b, i8p_ty);
                     let n = self.const_usize(layout.size().bytes());
                     let cmp = self.call_intrinsic("memcmp", &[a_ptr, b_ptr, n]);
-                    self.icmp(IntPredicate::IntEQ, cmp, self.const_i32(0))
+                    match self.cx.sess().target.arch.as_str() {
+                        "avr" | "msp430" => self.icmp(IntPredicate::IntEQ, cmp, self.const_i16(0)),
+                        _ => self.icmp(IntPredicate::IntEQ, cmp, self.const_i32(0)),
+                    }
                 }
             }
 

compiler/rustc_codegen_ssa/src/traits/consts.rs

@@ -13,6 +13,7 @@ pub trait ConstMethods<'tcx>: BackendTypes {
     fn const_uint(&self, t: Self::Type, i: u64) -> Self::Value;
     fn const_uint_big(&self, t: Self::Type, u: u128) -> Self::Value;
     fn const_bool(&self, val: bool) -> Self::Value;
+    fn const_i16(&self, i: i16) -> Self::Value;
     fn const_i32(&self, i: i32) -> Self::Value;
     fn const_u32(&self, i: u32) -> Self::Value;
     fn const_u64(&self, i: u64) -> Self::Value;

library/core/src/ffi/mod.rs

@@ -57,6 +57,9 @@ type_alias! { "c_schar.md", c_schar = i8, NonZero_c_schar = NonZeroI8; }
 type_alias! { "c_uchar.md", c_uchar = u8, NonZero_c_uchar = NonZeroU8; }
 type_alias! { "c_short.md", c_short = i16, NonZero_c_short = NonZeroI16; }
 type_alias! { "c_ushort.md", c_ushort = u16, NonZero_c_ushort = NonZeroU16; }
+#[cfg(any(target_arch = "avr", target_arch = "msp430"))]
+type_alias! { "c_int.md", c_int = i16, NonZero_c_int = NonZeroI16; }
+#[cfg(not(any(target_arch = "avr", target_arch = "msp430")))]
 type_alias! { "c_int.md", c_int = i32, NonZero_c_int = NonZeroI32; }
 type_alias! { "c_uint.md", c_uint = u32, NonZero_c_uint = NonZeroU32; }
 type_alias! { "c_long.md", c_long = i32, NonZero_c_long = NonZeroI32;

library/core/src/slice/cmp.rs

@@ -1,6 +1,7 @@
 //! Comparison traits for `[T]`.
 
 use crate::cmp::{self, Ordering};
+use crate::ffi;
 use crate::mem;
 
 use super::from_raw_parts;
@@ -13,8 +14,7 @@ extern "C" {
     ///
     /// Returns 0 for equal, < 0 for less than and > 0 for greater
     /// than.
-    // FIXME(#32610): Return type should be c_int
-    fn memcmp(s1: *const u8, s2: *const u8, n: usize) -> i32;
+    fn memcmp(s1: *const u8, s2: *const u8, n: usize) -> ffi::c_int;
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]