transpile: Various fixes to type handling for builtins

c2rust-transpile/src/c_ast/mod.rs

@@ -1538,23 +1538,24 @@ impl TypedAstContext {
         }
     }
 
-    /// Bubble types of unary and binary operators up from their args into the expression type.
-    ///
-    /// In Clang 15 and below, the Clang AST resolves typedefs in the expression type of unary and
-    /// binary expressions. For example, a BinaryExpr node adding two `size_t` expressions will be
-    /// given an `unsigned long` type rather than the `size_t` typedef type. This behavior changed
-    /// in Clang 16. This method adjusts AST node types to match those produced by Clang 16 and
-    /// newer; on these later Clang versions, it should have no effect.
+    /// Overrides the result types of certain expressions to one of the `PULLBACK_KINDS` where
+    /// appropriate. Then bubbles those types up to the parent expressions.
     ///
     /// This pass is necessary because we reify some typedef types (such as `size_t`) into their own
     /// distinct Rust types. As such, we need to make sure we know the exact type to generate when
     /// we translate an expr, not just its resolved type (looking through typedefs).
-    pub fn bubble_expr_types(&mut self) {
-        struct BubbleExprTypes<'a> {
+    ///
+    /// Additionally, in Clang 15 and below, the Clang AST resolves typedefs in the expression type
+    /// of unary and binary expressions. For example, a BinaryExpr node adding two `size_t`
+    /// expressions will be given an `unsigned long` type rather than the `size_t` typedef type.
+    /// This behavior changed in Clang 16. This method adjusts AST node types to match those
+    /// produced by Clang 16 and newer.
+    pub fn override_expr_types(&mut self) {
+        struct OverrideExprTypes<'a> {
             ast_context: &'a mut TypedAstContext,
         }
 
-        impl<'a> NodeVisitor for BubbleExprTypes<'a> {
+        impl<'a> NodeVisitor for OverrideExprTypes<'a> {
             fn children(&mut self, id: SomeId) -> Vec<SomeId> {
                 immediate_children_all_types(self.ast_context, id)
             }
@@ -1620,6 +1621,30 @@ impl TypedAstContext {
                         self.ast_context,
                         self.ast_context.c_exprs[&e].kind.get_qual_type().unwrap(),
                     ),
+                    CExprKind::Call(result_type_id, callee_id, _) => {
+                        let CExprKind::ImplicitCast(_, callee_id, CastKind::BuiltinFnToFnPtr, _, _) =
+                            self.ast_context.index_unwrap_parens(callee_id).kind
+                        else {
+                            return;
+                        };
+                        let CExprKind::DeclRef(_, decl_id, _) =
+                            self.ast_context.index_unwrap_parens(callee_id).kind
+                        else {
+                            return;
+                        };
+                        let CDeclKind::Function { ref name, .. } = self.ast_context[decl_id].kind
+                        else {
+                            return;
+                        };
+
+                        match name.as_str() {
+                            "__builtin_object_size" => {
+                                let type_id = self.ast_context.type_for_kind(&CTypeKind::Size);
+                                Some(result_type_id.with_ctype(type_id))
+                            }
+                            _ => None,
+                        }
+                    }
                     CExprKind::Paren(_ty, e) => self.ast_context.c_exprs[&e].kind.get_qual_type(),
                     CExprKind::UnaryType(_, op, _, _) => {
                         // All of these `CUnTypeOp`s should return `size_t`.
@@ -1645,7 +1670,7 @@ impl TypedAstContext {
         }
 
         for decl in self.c_decls_top.clone() {
-            BubbleExprTypes { ast_context: self }.visit_tree(SomeId::Decl(decl));
+            OverrideExprTypes { ast_context: self }.visit_tree(SomeId::Decl(decl));
         }
     }
 

c2rust-transpile/src/translator/functions.rs

@@ -397,7 +397,7 @@ impl<'c> Translation<'c> {
 
             // Builtin function call
             CExprKind::ImplicitCast(_, fexp, CastKind::BuiltinFnToFnPtr, _, _) => {
-                return self.convert_builtin(ctx, fexp, args);
+                return self.convert_builtin(ctx, override_ty, call_expr_ty, fexp, args);
             }
 
             // Function pointer call

c2rust-transpile/src/translator/mod.rs

@@ -924,10 +924,11 @@ pub fn translate(
         t.ast_context
             .prune_unwanted_items(tcfg.preserve_unused_functions);
 
-        // Normalize AST types between Clang < 16 and later versions. Ensures that
+        // Override expression types with `PULLBACK_KINDS` where appropriate.
+        // Also normalize AST types between Clang < 16 and later versions. Ensures that
         // binary and unary operators' expr types agree with their argument types
         // in the presence of typedefs.
-        t.ast_context.bubble_expr_types();
+        t.ast_context.override_expr_types();
 
         // Used for testing; so that we don't overlap with C function names
         if let Some(ref prefix) = t.tcfg.prefix_function_names {

c2rust-transpile/tests/snapshots.rs

@@ -331,6 +331,11 @@ fn test_bool() {
     transpile("bool.c").run();
 }
 
+#[test]
+fn test_builtin_types() {
+    transpile("builtin_types.c").run();
+}
+
 #[test]
 fn test_comments_only() {
     transpile("comments_only.c").run();

c2rust-transpile/tests/snapshots/builtin_types.c

@@ -0,0 +1,16 @@
+#include <stdint.h>
+
+void test_builtin_expected_type(double d, int y) {
+    int32_t ffs = __builtin_ffs(y);
+    int32_t clz = __builtin_clz((unsigned)y);
+    int32_t isnan = __builtin_isnan(d);
+    int32_t isinf_sign = __builtin_isinf_sign(d);
+    int32_t constant_p = __builtin_constant_p(y);
+    int32_t cond = y ? __builtin_ffs(y) : 0;
+}
+
+void test_builtin_object_size(void) {
+    int x = 0;
+    unsigned long n = __builtin_object_size(&x, 1);
+    unsigned long n2 = (unsigned long)__builtin_object_size(&x, 1);
+}

c2rust-transpile/tests/snapshots/snapshots__transpile@builtin_types.c.2021.clang15.snap

@@ -0,0 +1,53 @@
+---
+source: c2rust-transpile/tests/snapshots.rs
+expression: cat tests/snapshots/builtin_types.2021.clang15.rs
+---
+#![allow(
+    clippy::missing_safety_doc,
+    dead_code,
+    non_camel_case_types,
+    non_snake_case,
+    non_upper_case_globals,
+    unused_assignments,
+    unused_mut
+)]
+#![feature(raw_ref_op)]
+pub type int32_t = i32;
+#[no_mangle]
+pub unsafe extern "C" fn test_builtin_expected_type(
+    mut d: ::core::ffi::c_double,
+    mut y: ::core::ffi::c_int,
+) {
+    let mut ffs: int32_t = (if y == 0 { 0 } else { y.trailing_zeros() + 1 }) as int32_t;
+    let mut clz: int32_t = (y as ::core::ffi::c_uint).leading_zeros() as int32_t;
+    let mut isnan: int32_t = d.is_nan() as int32_t;
+    let mut isinf_sign: int32_t = if d.is_infinite() {
+        if d.is_sign_positive() {
+            1 as int32_t
+        } else {
+            -1 as int32_t
+        }
+    } else {
+        0 as int32_t
+    };
+    let mut constant_p: int32_t = 0 as int32_t;
+    let mut cond: int32_t = if y != 0 {
+        (if y == 0 { 0 } else { y.trailing_zeros() + 1 }) as int32_t
+    } else {
+        0 as int32_t
+    };
+}
+#[no_mangle]
+pub unsafe extern "C" fn test_builtin_object_size() {
+    let mut x: ::core::ffi::c_int = 0 as ::core::ffi::c_int;
+    let mut n: ::core::ffi::c_ulong = (if 1 as ::core::ffi::c_int & 2 == 0 {
+        -1isize as usize
+    } else {
+        0usize
+    }) as ::core::ffi::c_ulong;
+    let mut n2: ::core::ffi::c_ulong = (if 1 as ::core::ffi::c_int & 2 == 0 {
+        -1isize as usize
+    } else {
+        0usize
+    }) as ::core::ffi::c_ulong;
+}

c2rust-transpile/tests/snapshots/snapshots__transpile@builtin_types.c.2024.clang15.snap

@@ -0,0 +1,53 @@
+---
+source: c2rust-transpile/tests/snapshots.rs
+expression: cat tests/snapshots/builtin_types.2024.clang15.rs
+---
+#![allow(
+    clippy::missing_safety_doc,
+    dead_code,
+    non_camel_case_types,
+    non_snake_case,
+    non_upper_case_globals,
+    unsafe_op_in_unsafe_fn,
+    unused_assignments,
+    unused_mut
+)]
+pub type int32_t = i32;
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn test_builtin_expected_type(
+    mut d: ::core::ffi::c_double,
+    mut y: ::core::ffi::c_int,
+) {
+    let mut ffs: int32_t = (if y == 0 { 0 } else { y.trailing_zeros() + 1 }) as int32_t;
+    let mut clz: int32_t = (y as ::core::ffi::c_uint).leading_zeros() as int32_t;
+    let mut isnan: int32_t = d.is_nan() as int32_t;
+    let mut isinf_sign: int32_t = if d.is_infinite() {
+        if d.is_sign_positive() {
+            1 as int32_t
+        } else {
+            -1 as int32_t
+        }
+    } else {
+        0 as int32_t
+    };
+    let mut constant_p: int32_t = 0 as int32_t;
+    let mut cond: int32_t = if y != 0 {
+        (if y == 0 { 0 } else { y.trailing_zeros() + 1 }) as int32_t
+    } else {
+        0 as int32_t
+    };
+}
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn test_builtin_object_size() {
+    let mut x: ::core::ffi::c_int = 0 as ::core::ffi::c_int;
+    let mut n: ::core::ffi::c_ulong = (if 1 as ::core::ffi::c_int & 2 == 0 {
+        -1isize as usize
+    } else {
+        0usize
+    }) as ::core::ffi::c_ulong;
+    let mut n2: ::core::ffi::c_ulong = (if 1 as ::core::ffi::c_int & 2 == 0 {
+        -1isize as usize
+    } else {
+        0usize
+    }) as ::core::ffi::c_ulong;
+}

c2rust-transpile/tests/snapshots/snapshots__transpile@f128.c.2021.linux.clang15.snap

@@ -24,12 +24,12 @@ pub unsafe extern "C" fn long_double_test() {
     let mut cast_from_float: ::f128::f128 = ::f128::f128::new(f);
     let mut is_inf: bool = if huge.is_infinite() {
         if huge.is_sign_positive() {
-            1
+            1 as ::core::ffi::c_int
         } else {
-            -1
+            -1 as ::core::ffi::c_int
         }
     } else {
-        0
+        0 as ::core::ffi::c_int
     } != 0;
     if one != ::f128::f128::ZERO {
         let mut dummy: ::core::ffi::c_int = 0;
@@ -48,12 +48,12 @@ pub unsafe extern "C" fn float128_test() {
     let mut ld_from_float128: ::f128::f128 = one;
     let mut is_inf: bool = if huge.is_infinite() {
         if huge.is_sign_positive() {
-            1
+            1 as ::core::ffi::c_int
         } else {
-            -1
+            -1 as ::core::ffi::c_int
         }
     } else {
-        0
+        0 as ::core::ffi::c_int
     } != 0;
     if one != ::f128::f128::ZERO {
         let mut dummy: ::core::ffi::c_int = 0;

c2rust-transpile/tests/snapshots/snapshots__transpile@f128.c.2024.linux.clang15.snap

@@ -24,9 +24,13 @@ pub unsafe extern "C" fn long_double_test() {
     let mut cast_from_int: ::f128::f128 = ::f128::f128::new(i);
     let mut cast_from_float: ::f128::f128 = ::f128::f128::new(f);
     let mut is_inf: bool = if huge.is_infinite() {
-        if huge.is_sign_positive() { 1 } else { -1 }
+        if huge.is_sign_positive() {
+            1 as ::core::ffi::c_int
+        } else {
+            -1 as ::core::ffi::c_int
+        }
     } else {
-        0
+        0 as ::core::ffi::c_int
     } != 0;
     if one != ::f128::f128::ZERO {
         let mut dummy: ::core::ffi::c_int = 0;
@@ -44,9 +48,13 @@ pub unsafe extern "C" fn float128_test() {
     let mut cast_from_float: ::f128::f128 = ::f128::f128::new(f);
     let mut ld_from_float128: ::f128::f128 = one;
     let mut is_inf: bool = if huge.is_infinite() {
-        if huge.is_sign_positive() { 1 } else { -1 }
+        if huge.is_sign_positive() {
+            1 as ::core::ffi::c_int
+        } else {
+            -1 as ::core::ffi::c_int
+        }
     } else {
-        0
+        0 as ::core::ffi::c_int
     } != 0;
     if one != ::f128::f128::ZERO {
         let mut dummy: ::core::ffi::c_int = 0;

c2rust-transpile/tests/snapshots/snapshots__transpile@macros.c.2021.clang15.snap

@@ -119,14 +119,14 @@ pub unsafe extern "C" fn local_muts() {
     let mut str_concatenation_ptr: *const ::core::ffi::c_char = STR_CONCATENATION.as_ptr();
     let mut str_concatenation: [::core::ffi::c_char; 18] = STR_CONCATENATION;
     let mut builtin: ::core::ffi::c_int =
-        (LITERAL_INT as ::core::ffi::c_uint).leading_zeros() as i32;
+        (LITERAL_INT as ::core::ffi::c_uint).leading_zeros() as ::core::ffi::c_int;
     let mut ref_indexing: *const ::core::ffi::c_char = REF_MACRO;
     let mut ref_struct: *const S = REF_LITERAL;
     let mut ternary: ::core::ffi::c_int = TERNARY;
     let mut member: ::core::ffi::c_int = MEMBER;
     let mut stmt_expr: ::core::ffi::c_float = ({
         let mut builtin_0: ::core::ffi::c_int =
-            (LITERAL_INT as ::core::ffi::c_uint).leading_zeros() as i32;
+            (LITERAL_INT as ::core::ffi::c_uint).leading_zeros() as ::core::ffi::c_int;
         let mut indexing_0: ::core::ffi::c_char = INDEXING;
         let mut mixed: ::core::ffi::c_float = MIXED_ARITHMETIC as ::core::ffi::c_float;
         let mut i: ::core::ffi::c_int = 0 as ::core::ffi::c_int;
@@ -166,14 +166,15 @@ pub unsafe extern "C" fn local_consts() {
     let indexing: ::core::ffi::c_char = INDEXING;
     let str_concatenation_ptr: *const ::core::ffi::c_char = STR_CONCATENATION.as_ptr();
     let str_concatenation: [::core::ffi::c_char; 18] = STR_CONCATENATION;
-    let builtin: ::core::ffi::c_int = (LITERAL_INT as ::core::ffi::c_uint).leading_zeros() as i32;
+    let builtin: ::core::ffi::c_int =
+        (LITERAL_INT as ::core::ffi::c_uint).leading_zeros() as ::core::ffi::c_int;
     let ref_indexing: *const ::core::ffi::c_char = REF_MACRO;
     let ref_struct: *const S = REF_LITERAL;
     let ternary: ::core::ffi::c_int = TERNARY;
     let member: ::core::ffi::c_int = MEMBER;
     let stmt_expr: ::core::ffi::c_float = ({
         let mut builtin_0: ::core::ffi::c_int =
-            (LITERAL_INT as ::core::ffi::c_uint).leading_zeros() as i32;
+            (LITERAL_INT as ::core::ffi::c_uint).leading_zeros() as ::core::ffi::c_int;
         let mut indexing_0: ::core::ffi::c_char = INDEXING;
         let mut mixed: ::core::ffi::c_float = MIXED_ARITHMETIC as ::core::ffi::c_float;
         let mut i: ::core::ffi::c_int = 0 as ::core::ffi::c_int;
@@ -219,7 +220,7 @@ static mut global_static_const_str_concatenation_ptr: *const ::core::ffi::c_char
     STR_CONCATENATION.as_ptr();
 static mut global_static_const_str_concatenation: [::core::ffi::c_char; 18] = STR_CONCATENATION;
 static mut global_static_const_builtin: ::core::ffi::c_int =
-    (LITERAL_INT as ::core::ffi::c_uint).leading_zeros() as i32;
+    (LITERAL_INT as ::core::ffi::c_uint).leading_zeros() as ::core::ffi::c_int;
 static mut global_static_const_ref_indexing: *const ::core::ffi::c_char =
     ::core::ptr::null::<::core::ffi::c_char>();
 static mut global_static_const_ref_struct: *const S = REF_LITERAL;
@@ -288,7 +289,7 @@ pub static mut global_const_str_concatenation_ptr: *const ::core::ffi::c_char =
 pub static mut global_const_str_concatenation: [::core::ffi::c_char; 18] = STR_CONCATENATION;
 #[no_mangle]
 pub static mut global_const_builtin: ::core::ffi::c_int =
-    (LITERAL_INT as ::core::ffi::c_uint).leading_zeros() as i32;
+    (LITERAL_INT as ::core::ffi::c_uint).leading_zeros() as ::core::ffi::c_int;
 #[no_mangle]
 pub static mut global_const_ref_indexing: *const ::core::ffi::c_char =
     ::core::ptr::null::<::core::ffi::c_char>();