Switch char to i8 (#452)

Fixes #246

Author: nunoplopes

cpp2rust/converter/models/converter_refcount.cpp

@@ -1252,19 +1252,25 @@ bool ConverterRefCount::VisitStringLiteral(clang::StringLiteral *expr) {
   }
 
   if (IsArrayInitContext()) {
+    // The array may have a different element type than the literal, e.g.,
+    // unsigned char s[] = "abc".
+    auto elem_ty =
+        ctx_.getAsArrayType(curr_init_type_.back())->getElementType();
+    std::string elem(Trim(ToStringBase(elem_ty.getUnqualifiedType())));
     uint64_t pad = 1;
     if (auto *arr_ty = ctx_.getAsConstantArrayType(curr_init_type_.back())) {
       uint64_t arr_size = arr_ty->getSize().getZExtValue();
       if (expr->getString().empty()) {
-        StrCat(std::format("vec![0u8; {}].into_boxed_slice()", arr_size));
+        StrCat(std::format("vec![0{}; {}].into_boxed_slice()", elem, arr_size));
         computed_expr_type_ = ComputedExprType::FreshValue;
         return false;
       }
       pad = arr_size > expr->getString().size()
                 ? arr_size - expr->getString().size()
                 : 0;
     }
-    StrCat(std::format("Box::from(*b{})", GetEscapedStringLiteral(expr, pad)));
+    StrCat(std::format("{}::array_from_literal(b{})", elem,
+                       GetEscapedStringLiteral(expr, pad)));
     computed_expr_type_ = ComputedExprType::FreshValue;
     return false;
   }
@@ -2669,7 +2675,7 @@ bool ConverterRefCount::ConvertCXXOperatorCallExpr(
 void ConverterRefCount::ConvertFunctionParameters(clang::FunctionDecl *decl) {
   PushConversionKind push(*this, ConversionKind::Unboxed);
   if (decl->isMain() && (decl->getNumParams() != 0U)) {
-    StrCat(std::format("{}: i32, {}: Ptr<Ptr<u8>>",
+    StrCat(std::format("{}: i32, {}: Ptr<Ptr<i8>>",
                        GetNamedDeclAsString(decl->getParamDecl(0)),
                        GetNamedDeclAsString(decl->getParamDecl(1))));
   } else {
@@ -2812,10 +2818,10 @@ void ConverterRefCount::ConvertFunctionMain(
   if (decl->getNumParams() != 0U) {
     StrCat(std::format(R"(
 pub fn main() {{
-    let argv: Vec<Value<Vec<u8>>> = ::std::env::args()
-        .map(|x| Rc::new(RefCell::new(x.as_bytes().to_vec())))
+    let argv: Vec<Value<Vec<i8>>> = ::std::env::args()
+        .map(|x| Rc::new(RefCell::new(x.bytes().map(|c| c as i8).collect())))
         .collect();
-    let mut argv: Value<Vec<Ptr<u8>>> = Rc::new(RefCell::new(
+    let mut argv: Value<Vec<Ptr<i8>>> = Rc::new(RefCell::new(
         argv.iter().map(|x| {{ x.borrow_mut().push(0); x.as_pointer() }}).collect(),
     ));
     (*argv.borrow_mut()).push(Ptr::null());

cpp2rust/converter/models/converter_refcount.h

@@ -35,8 +35,7 @@ class ConverterRefCount final : public Converter {
 
   bool EmitsReprCForRecords() const override { return false; }
 
-  const char *CharRustType() const override { return "u8"; }
-  bool CharRustTypeIsSigned() const override { return false; }
+  const char *CharRustType() const override { return "i8"; }
 
   std::string GetComparisonReferenceArg(const clang::CXXRecordDecl *decl,
                                         std::string_view value) override;

libcc2rs/src/alloc.rs

@@ -30,7 +30,7 @@ pub fn calloc_refcount(a0: usize, a1: usize) -> AnyPtr {
     Ptr::alloc_array(vec![0u8; a0 * a1].into_boxed_slice()).to_any()
 }
 
-pub fn strdup_refcount(a0: Ptr<u8>) -> Ptr<u8> {
+pub fn strdup_refcount(a0: Ptr<i8>) -> Ptr<i8> {
     let mut bytes = a0.to_c_bytes();
     bytes.push(0);
     Ptr::alloc_array(bytes.into_boxed_slice())

libcc2rs/src/cstr.rs

@@ -8,14 +8,100 @@ use std::rc::Rc;
 
 use crate::CStringIterator;
 use crate::rc::{Ptr, PtrKind};
+use crate::reinterpret::{ByteRepr, with_scratch};
 
-impl fmt::Display for Ptr<u8> {
+// The element types of C strings: `char` and `signed char` map to `i8`,
+// `unsigned char` to `u8`.
+pub trait CChar: Copy + Default + PartialEq + ByteRepr + 'static {
+    fn to_byte(self) -> u8;
+    fn from_byte(b: u8) -> Self;
+    // Calls `f` with `buf` viewed as a slice of `Self`; changes are copied back.
+    fn with_bytes_mut<R>(buf: &mut [u8], f: impl FnOnce(&mut [Self]) -> R) -> R;
+    // Calls `f` with `s` viewed as bytes. Free for u8; i8 needs a copy, which
+    // lives on the stack for short slices.
+    fn with_u8_slice<R>(s: &[Self], f: impl FnOnce(&[u8]) -> R) -> R;
+    // Conversions between vectors of Self and of bytes, without reallocating.
+    fn into_byte_vec(v: Vec<Self>) -> Vec<u8>;
+    fn from_byte_vec(v: Vec<u8>) -> Vec<Self>;
+
+    // The array initialized by a narrow string literal, e.g., char s[] = "abc".
+    fn array_from_literal<const N: usize>(s: &[u8; N]) -> Box<[Self]> {
+        Box::new(s.map(Self::from_byte))
+    }
+}
+
+impl CChar for u8 {
+    #[inline(always)]
+    fn to_byte(self) -> u8 {
+        self
+    }
+    #[inline(always)]
+    fn from_byte(b: u8) -> Self {
+        b
+    }
+    #[inline(always)]
+    fn with_bytes_mut<R>(buf: &mut [u8], f: impl FnOnce(&mut [Self]) -> R) -> R {
+        f(buf)
+    }
+    #[inline(always)]
+    fn with_u8_slice<R>(s: &[Self], f: impl FnOnce(&[u8]) -> R) -> R {
+        f(s)
+    }
+    #[inline(always)]
+    fn into_byte_vec(v: Vec<Self>) -> Vec<u8> {
+        v
+    }
+    #[inline(always)]
+    fn from_byte_vec(v: Vec<u8>) -> Vec<Self> {
+        v
+    }
+}
+
+impl CChar for i8 {
+    #[inline(always)]
+    fn to_byte(self) -> u8 {
+        self as u8
+    }
+    #[inline(always)]
+    fn from_byte(b: u8) -> Self {
+        b as i8
+    }
+    fn with_bytes_mut<R>(buf: &mut [u8], f: impl FnOnce(&mut [Self]) -> R) -> R {
+        with_scratch(buf.len(), |chars: &mut [i8]| {
+            for (c, &b) in chars.iter_mut().zip(buf.iter()) {
+                *c = b as i8;
+            }
+            let r = f(chars);
+            for (b, &c) in buf.iter_mut().zip(chars.iter()) {
+                *b = c as u8;
+            }
+            r
+        })
+    }
+    fn with_u8_slice<R>(s: &[Self], f: impl FnOnce(&[u8]) -> R) -> R {
+        with_scratch(s.len(), |buf: &mut [u8]| {
+            for (b, &c) in buf.iter_mut().zip(s) {
+                *b = c as u8;
+            }
+            f(buf)
+        })
+    }
+    // Both collects reuse the allocation, as i8 and u8 have the same layout.
+    fn into_byte_vec(v: Vec<Self>) -> Vec<u8> {
+        v.into_iter().map(|c| c as u8).collect()
+    }
+    fn from_byte_vec(v: Vec<u8>) -> Vec<Self> {
+        v.into_iter().map(|b| b as i8).collect()
+    }
+}
+
+impl<T: CChar> fmt::Display for Ptr<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match &self.kind {
             PtrKind::Null => write!(f, "NULL"),
             _ => {
                 for value in self {
-                    let ch = value.read();
+                    let ch = value.read().to_byte();
                     if ch == 0 {
                         break;
                     }
@@ -62,7 +148,35 @@ impl_string_literal!(u16, STRING_LITERALS_U16);
 impl_string_literal!(u32, STRING_LITERALS_U32);
 impl_string_literal!(i32, STRING_LITERALS_I32);
 
-impl Ptr<u8> {
+thread_local! {
+    static STRING_LITERALS_I8: RefCell<HashMap<&'static [u8], Rc<RefCell<Box<[i8]>>>>> =
+        RefCell::new(HashMap::new());
+}
+
+impl Ptr<i8> {
+    // Narrow string literals are emitted as byte strings (b"..."), as Rust has
+    // no literal syntax for `[i8]`.
+    #[inline]
+    pub fn from_string_literal(s: &'static [u8]) -> Self {
+        STRING_LITERALS_I8.with(|literals| {
+            let mut literals = literals.borrow_mut();
+            let weak = Rc::downgrade(literals.entry(s).or_insert_with(|| {
+                Rc::new(RefCell::new(
+                    s.iter()
+                        .map(|&c| c as i8)
+                        .chain(std::iter::once(0))
+                        .collect(),
+                ))
+            }));
+            Ptr {
+                offset: 0,
+                kind: PtrKind::StackArray(weak),
+            }
+        })
+    }
+}
+
+impl<T: CChar> Ptr<T> {
     #[allow(clippy::explicit_counter_loop)]
     pub fn memcpy(&self, src: &Self, len: usize) {
         if *self > *src {
@@ -89,7 +203,7 @@ impl Ptr<u8> {
     }
 
     #[allow(clippy::explicit_counter_loop)]
-    pub fn memset(&self, value: u8, num: usize) {
+    pub fn memset(&self, value: T, num: usize) {
         let mut dst = self.clone();
         for _ in 0..num {
             dst.write(value);
@@ -102,8 +216,9 @@ impl Ptr<u8> {
         let mut a = self.clone();
         let mut b = other.clone();
         for _ in 0..len {
-            let va = a.read();
-            let vb = b.read();
+            // Bytes compare as unsigned char.
+            let va = a.read().to_byte();
+            let vb = b.read().to_byte();
             if va != vb {
                 return (va as i32).wrapping_sub(vb as i32);
             }
@@ -113,15 +228,15 @@ impl Ptr<u8> {
         0
     }
 
-    pub fn to_c_string_iterator(&self) -> CStringIterator {
+    pub fn to_c_string_iterator(&self) -> CStringIterator<T> {
         CStringIterator { ptr: self.clone() }
     }
 
     // Calls `f` with the bytes of the C string, excluding the terminating NUL.
     // The bytes are borrowed from the allocation, so `f` must not write to it.
-    pub fn with_c_str<R>(&self, f: impl FnOnce(&[u8]) -> R) -> R {
-        fn until_nul(tail: &[u8]) -> &[u8] {
-            match tail.iter().position(|&b| b == 0) {
+    pub fn with_c_str<R>(&self, f: impl FnOnce(&[T]) -> R) -> R {
+        fn until_nul<T: CChar>(tail: &[T]) -> &[T] {
+            match tail.iter().position(|&b| b == T::default()) {
                 Some(len) => &tail[..len],
                 None => panic!("ub: unterminated string"),
             }
@@ -146,10 +261,10 @@ impl Ptr<u8> {
             }
             PtrKind::Field(root) => {
                 let root = crate::field::upgrade(root);
-                let b = Ptr::<u8>::borrow_field(&*root, self.offset);
+                let b = Ptr::<T>::borrow_field(&*root, self.offset);
                 f(until_nul(std::slice::from_ref(&*b)))
             }
-            PtrKind::Reinterpreted(_) => f(&self.to_c_string_iterator().collect::<Vec<u8>>()),
+            PtrKind::Reinterpreted(_) => f(&self.to_c_string_iterator().collect::<Vec<T>>()),
         }
     }
 
@@ -161,16 +276,46 @@ impl Ptr<u8> {
     // Copies the C string, excluding the terminating NUL, using a single
     // allocation. The vector has room for one more byte, which is what callers
     // usually append (a NUL or a newline).
-    pub fn to_c_bytes(&self) -> Vec<u8> {
+    pub fn to_c_bytes(&self) -> Vec<T> {
         self.with_c_str(|s| {
             let mut bytes = Vec::with_capacity(s.len() + 1);
             bytes.extend_from_slice(s);
             bytes
         })
     }
 
+    // Copies `bytes` to the buffer pointed to, without adding a NUL.
+    pub fn write_c_bytes(&self, bytes: &[u8]) {
+        self.with_slice_mut(bytes.len(), |s| {
+            for (d, &b) in s.iter_mut().zip(bytes) {
+                *d = T::from_byte(b);
+            }
+        })
+    }
+
+    // Allocates a heap copy of `bytes` followed by a NUL, like `strdup`.
+    pub fn alloc_c_str(bytes: &[u8]) -> Self {
+        Ptr::alloc_array(
+            bytes
+                .iter()
+                .map(|&b| T::from_byte(b))
+                .chain(std::iter::once(T::default()))
+                .collect(),
+        )
+    }
+
+    // Like `with_c_str`, with the C string viewed as bytes.
+    pub fn with_c_bytes<R>(&self, f: impl FnOnce(&[u8]) -> R) -> R {
+        self.with_c_str(|s| T::with_u8_slice(s, f))
+    }
+
+    // Like `to_c_bytes`, as bytes.
+    pub fn to_c_u8_bytes(&self) -> Vec<u8> {
+        T::into_byte_vec(self.to_c_bytes())
+    }
+
     pub fn to_rust_string(&self) -> String {
-        self.with_c_str(|s| String::from_utf8_lossy(s).into_owned())
+        self.with_c_bytes(|s| String::from_utf8_lossy(s).into_owned())
     }
 }
 
@@ -228,6 +373,24 @@ mod tests {
         assert_eq!(p.to_rust_string(), "");
     }
 
+    #[test]
+    fn signed_char_strings() {
+        let p = Ptr::<i8>::from_string_literal(b"\xe9a");
+        assert_eq!(p.read(), -23);
+        assert_eq!(p.c_str_len(), 2);
+        assert_eq!(p.to_c_bytes(), [-23, b'a' as i8]);
+        assert_eq!(p.to_c_u8_bytes(), b"\xe9a");
+        // memcmp compares bytes as unsigned char.
+        let q = Ptr::<i8>::from_string_literal(b"a");
+        assert!(p.memcmp(&q, 1) > 0);
+
+        let buf = Ptr::<i8>::alloc_c_str(b"xyz");
+        buf.write_c_bytes(b"\xff");
+        assert_eq!(buf.read(), -1);
+        assert_eq!(buf.to_c_u8_bytes(), b"\xffyz");
+        buf.delete();
+    }
+
     #[test]
     #[should_panic(expected = "ub: unterminated string")]
     fn unterminated_string_panics() {

libcc2rs/src/format.rs

@@ -68,7 +68,7 @@ pub fn format_c(fmt: &str, va: &[VaArg]) -> String {
                 },
                 ConversionType::Char => Arg::Char(i32::get(arg) as u8 as char),
                 ConversionType::String => match arg {
-                    VaArg::Ptr(v) => Arg::Str(v.reinterpret_cast::<u8>().to_rust_string()),
+                    VaArg::Ptr(v) => Arg::Str(v.reinterpret_cast::<i8>().to_rust_string()),
                     _ => panic!("format_c: %s expects a string argument"),
                 },
                 ConversionType::DecFloatLower
@@ -95,7 +95,7 @@ mod tests {
     use crate::Ptr;
 
     fn s(lit: &'static [u8]) -> VaArg {
-        Ptr::<u8>::from_string_literal(lit).into()
+        Ptr::<i8>::from_string_literal(lit).into()
     }
 
     #[test]