feat: integer cast

Author: Wybxc

crates/rustc_codegen_c/src/builder.rs

@@ -12,8 +12,9 @@ use rustc_middle::ty::{ParamEnv, Ty, TyCtxt};
 use rustc_target::abi::call::FnAbi;
 use rustc_target::spec::{HasTargetSpec, Target};
 
+use crate::c_expr;
 use crate::context::{CFunctionBuilder, CodegenCx};
-use crate::module::{CExpr, CStmt};
+use crate::module::{CDecl, CExpr, CStmt, CType};
 use crate::utils::slab::Id;
 
 mod abi;
@@ -127,13 +128,13 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
     }
 
     fn ret_void(&mut self) {
-        let mut fuctions = self.cx.functions.borrow_mut();
-        fuctions[self.bb].push_stmt(CStmt::Return(None));
+        let mut functions = self.cx.functions.borrow_mut();
+        functions[self.bb].push_stmt(CStmt::Return(None));
     }
 
     fn ret(&mut self, v: Self::Value) {
-        let mut fuctions = self.cx.functions.borrow_mut();
-        fuctions[self.bb].push_stmt(CStmt::Return(Some(Box::new(CExpr::Value(v)))));
+        let mut functions = self.cx.functions.borrow_mut();
+        functions[self.bb].push_stmt(CStmt::Return(Some(Box::new(CExpr::Value(v)))));
     }
 
     fn br(&mut self, dest: Self::BasicBlock) {
@@ -495,8 +496,48 @@ impl<'a, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'tcx> {
         todo!()
     }
 
+    /// Performs cast between integers, x as ty in Rust.
+    ///
+    /// If the bit width is different, a truncation or extension is required.
+    /// The type of extension—sign-extension or zero-extension—depends on the
+    /// signedness of the source type.
+    ///
+    /// According to the C17 standard, section "6.3.1.3 Signed and unsigned
+    /// integers", casting to an unsigned integer behaves the same as in Rust.
+    /// However, casting to a signed integer is implementation-defined.
+    ///
+    /// Therefore, a two-step cast is necessary. First, cast to an unsigned
+    /// integer via explicit conversion. Then, use a helper function to cast the
+    /// result to a signed integer.
     fn intcast(&mut self, val: Self::Value, dest_ty: Self::Type, is_signed: bool) -> Self::Value {
-        todo!()
+        let mut functions = self.cx.functions.borrow_mut();
+        let function = &mut functions[self.bb];
+        let ret = function.next_value();
+
+        let dest = if let CType::Primitive(ty) = dest_ty { ty } else { unreachable!() };
+        let cast = if !dest.is_signed() {
+            CExpr::Cast { ty: CType::Primitive(dest), expr: Box::new(CExpr::Value(val)) }
+        } else {
+            let cast = CExpr::Cast {
+                ty: CType::Primitive(dest.to_unsigned()),
+                expr: Box::new(CExpr::Value(val)),
+            };
+            CExpr::Call {
+                callee: c_expr!("__rust_utos"),
+                args: vec![
+                    c_expr!(dest.to_unsigned().to_string()),
+                    c_expr!(dest.to_string()),
+                    cast,
+                    c_expr!(dest.max_value()),
+                ],
+            }
+        };
+        function.push_stmt(CStmt::Decl(Box::new(CDecl::Var {
+            name: ret,
+            ty: dest_ty,
+            init: Some(cast),
+        })));
+        ret
     }
 
     fn pointercast(&mut self, val: Self::Value, dest_ty: Self::Type) -> Self::Value {

crates/rustc_codegen_c/src/builder/abi.rs

@@ -9,7 +9,7 @@ use crate::module::CValue;
 impl<'tcx> AbiBuilderMethods<'tcx> for Builder<'_, 'tcx> {
     fn get_param(&mut self, index: usize) -> Self::Value {
         // Params are first n variables in the function
-        CValue::Var(index)
+        CValue::Local(index)
     }
 }
 

crates/rustc_codegen_c/src/context.rs

@@ -117,27 +117,21 @@ pub struct CFunctionBuilder {
     pub ty: CType,
     pub params: Vec<(CType, CValue)>,
     pub body: Vec<CStmt>,
-    pub var_names: FxHashMap<CValue, String>,
+
     var_counter: usize,
 }
 
 impl CFunctionBuilder {
     pub fn new(name: String, ty: CType, params: Vec<CType>) -> Self {
         let params: Vec<_> =
-            params.into_iter().enumerate().map(|(i, ty)| (ty, CValue::Var(i))).collect();
+            params.into_iter().enumerate().map(|(i, ty)| (ty, CValue::Local(i))).collect();
         let var_counter = params.len();
 
-        Self { name, ty, params, body: Vec::new(), var_counter, var_names: FxHashMap::default() }
+        Self { name, ty, params, body: Vec::new(), var_counter }
     }
 
     pub fn build(self) -> CFunction {
-        CFunction {
-            name: self.name,
-            ty: self.ty,
-            params: self.params,
-            body: self.body,
-            var_names: self.var_names,
-        }
+        CFunction { name: self.name, ty: self.ty, params: self.params, body: self.body }
     }
 
     pub fn decl(&self) -> CDecl {
@@ -149,7 +143,7 @@ impl CFunctionBuilder {
     }
 
     pub fn next_value(&mut self) -> CValue {
-        let val = CValue::Var(self.var_counter);
+        let val = CValue::Local(self.var_counter);
         self.var_counter += 1;
         val
     }

crates/rustc_codegen_c/src/helper.h

@@ -0,0 +1,5 @@
+/** cast from unsigned to signed
+  * example: `__rust_utos(uint32_t, int32_t, x, INT32_MAX)`
+  */
+#define __rust_utos(u, s, v, m) \
+    ((v) <= (m) ? ((s)v) : ((s)((u)(v) - (u)(m) - 1)))