WIP: Handle some C11 atomic types and operations

Author: thedataking

c2rust-transpile/src/c_ast/conversion.rs

@@ -162,6 +162,8 @@ fn parse_cast_kind(kind: &str) -> CastKind {
         "BuiltinFnToFnPtr" => CastKind::BuiltinFnToFnPtr,
         "ConstCast" => CastKind::ConstCast,
         "VectorSplat" => CastKind::VectorSplat,
+        "AtomicToNonAtomic" => CastKind::AtomicToNonAtomic,
+        "NonAtomicToAtomic" => CastKind::NonAtomicToAtomic,
         k => panic!("Unsupported implicit cast: {}", k),
     }
 }
@@ -816,8 +818,11 @@ impl ConversionContext {
                 }
 
                 TypeTag::TagAtomicType => {
-                    // Next step in atomics implementation: Transfer to a CTypeKind
-                    panic!("C11 Atomics are not implemented in C2Rust yet.");
+                    let qt = from_value(ty_node.extras[0].clone()).expect("Inner type not found");
+                    let qt_new = self.visit_qualified_type(qt);
+                    let atomic_ty = CTypeKind::Atomic(qt_new);
+                    self.add_type(new_id, not_located(atomic_ty));
+                    self.processed_nodes.insert(new_id, OTHER_TYPE);
                 }
 
                 t => panic!(
@@ -1761,6 +1766,11 @@ impl ConversionContext {
                     let typ = node.type_id.expect("Expected expression to have type");
                     let typ = self.visit_qualified_type(typ);
 
+                    // Perhaps as an optimization since atomic_init has no order,
+                    // clang stores val1 in the position otherwise used for order
+                    let is_atomic = name == "__c11_atomic_init" || name == "__opencl_atomic_init";
+                    let val1 = if is_atomic { Some(order) } else { val1 };
+
                     let e = CExprKind::Atomic {
                         typ,
                         name,

c2rust-transpile/src/c_ast/iterators.rs

@@ -293,7 +293,8 @@ fn immediate_type_children(kind: &CTypeKind) -> Vec<SomeId> {
         | Reference(qtype)
         | Attributed(qtype, _)
         | BlockPointer(qtype)
-        | Vector(qtype, _) => {
+        | Vector(qtype, _)
+        | Atomic(qtype) => {
             intos![qtype.ctype]
         }
 

c2rust-transpile/src/c_ast/mod.rs

@@ -1214,6 +1214,8 @@ pub enum CastKind {
     BuiltinFnToFnPtr,
     ConstCast,
     VectorSplat,
+    AtomicToNonAtomic,
+    NonAtomicToAtomic,
 }
 
 /// Represents a unary operator in C (6.5.3 Unary operators) and GNU C extensions
@@ -1672,6 +1674,9 @@ pub enum CTypeKind {
 
     Half,
     BFloat16,
+
+    // Atomic types (6.7.2.4)
+    Atomic(CQualTypeId),
 }
 
 impl CTypeKind {

c2rust-transpile/src/convert_type.rs

@@ -380,6 +380,7 @@ impl TypeConverter {
             }
 
             CTypeKind::Attributed(ty, _) => self.convert(ctxt, ty.ctype),
+            CTypeKind::Atomic(ty) => self.convert(ctxt, ty.ctype),
 
             // ANSI/ISO C-style function
             CTypeKind::Function(ret, ref params, is_var, is_noreturn, true) => {

c2rust-transpile/src/translator/atomics.rs

@@ -16,6 +16,19 @@ impl<'c> Translation<'c> {
         let memorder = &self.ast_context[expr];
         let i = match memorder.kind {
             CExprKind::Literal(_, CLiteral::Integer(i, _)) => Some(i),
+            CExprKind::DeclRef(_, decl_id, LRValue::RValue) => {
+                let decl = self.ast_context.get_decl(&decl_id).unwrap();
+                match decl.kind {
+                    CDeclKind::EnumConstant { name: _, value: v } => match v {
+                        ConstIntExpr::I(i) => {
+                            assert!(0 <= i);
+                            Some(i as u64)
+                        }
+                        ConstIntExpr::U(u) => Some(u),
+                    },
+                    _ => unimplemented!(),
+                }
+            }
             _ => None,
         }?;
         use Ordering::*;
@@ -76,7 +89,7 @@ impl<'c> Translation<'c> {
         }
 
         match name {
-            "__atomic_load" | "__atomic_load_n" => ptr.and_then(|ptr| {
+            "__atomic_load" | "__atomic_load_n" | "__c11_atomic_load" => ptr.and_then(|ptr| {
                 let intrinsic_name = format!("atomic_load_{}", order_name(static_order(order)));
 
                 self.use_feature("core_intrinsics");
@@ -105,7 +118,7 @@ impl<'c> Translation<'c> {
                 }
             }),
 
-            "__atomic_store" | "__atomic_store_n" => {
+            "__atomic_store" | "__atomic_store_n" | "__c11_atomic_store" => {
                 let val = val1.expect("__atomic_store must have a val argument");
                 ptr.and_then(|ptr| {
                     val.and_then(|val| {
@@ -131,7 +144,25 @@ impl<'c> Translation<'c> {
                 })
             }
 
-            "__atomic_exchange" | "__atomic_exchange_n" => {
+            // NOTE: there is no corresponding __atomic_init builtin in clang
+            "__c11_atomic_init" => {
+                let val = val1.expect(&format!("__atomic_init must have a val argument"));
+                ptr.and_then(|ptr| {
+                    val.and_then(|val| {
+                        let assignment = mk().assign_expr(
+                            mk().unary_expr(UnOp::Deref(Default::default()), ptr),
+                            val,
+                        );
+                        self.convert_side_effects_expr(
+                            ctx,
+                            WithStmts::new_val(assignment),
+                            "Builtin is not supposed to be used",
+                        )
+                    })
+                })
+            }
+
+            "__atomic_exchange" | "__atomic_exchange_n" | "__c11_atomic_exchange" => {
                 let val = val1.expect("__atomic_store must have a val argument");
                 ptr.and_then(|ptr| {
                     val.and_then(|val| {
@@ -176,10 +207,19 @@ impl<'c> Translation<'c> {
                 })
             }
 
-            "__atomic_compare_exchange" | "__atomic_compare_exchange_n" => {
+            "__atomic_compare_exchange"
+            | "__atomic_compare_exchange_n"
+            | "__c11_atomic_compare_exchange_strong" => {
                 let expected =
                     val1.expect("__atomic_compare_exchange must have a expected argument");
                 let desired = val2.expect("__atomic_compare_exchange must have a desired argument");
+                // Some C11 atomic operations encode the weak property in the name
+                let weak = match (name, weak) {
+                    ("__c11_atomic_compare_exchange_strong", None) => Some(false),
+                    ("__c11_atomic_compare_exchange_weak", None) => Some(true),
+                    _ => weak,
+                };
+
                 ptr.and_then(|ptr| {
                     expected.and_then(|expected| {
                         desired.and_then(|desired| {
@@ -258,7 +298,13 @@ impl<'c> Translation<'c> {
             | "__atomic_fetch_and"
             | "__atomic_fetch_xor"
             | "__atomic_fetch_or"
-            | "__atomic_fetch_nand" => {
+            | "__atomic_fetch_nand"
+            | "__c11_atomic_fetch_add"
+            | "__c11_atomic_fetch_sub"
+            | "__c11_atomic_fetch_and"
+            | "__c11_atomic_fetch_xor"
+            | "__c11_atomic_fetch_or"
+            | "__c11_atomic_fetch_nand" => {
                 let intrinsic_name = if name.contains("_add") {
                     "atomic_xadd"
                 } else if name.contains("_sub") {
@@ -285,7 +331,7 @@ impl<'c> Translation<'c> {
                 })
             }
 
-            _ => unimplemented!("atomic not implemented"),
+            _ => unimplemented!("atomic not implemented: {}", name),
         }
     }
 

c2rust-transpile/src/translator/mod.rs

@@ -4412,6 +4412,8 @@ impl<'c> Translation<'c> {
             CastKind::VectorSplat => Err(TranslationError::generic(
                 "TODO vector splat casts not supported",
             )),
+
+            CastKind::AtomicToNonAtomic | CastKind::NonAtomicToAtomic => Ok(val),
         }
     }
 
@@ -4920,7 +4922,7 @@ impl<'c> Translation<'c> {
             Vector(..) => {
                 // Handled in `import_simd_typedef`
             }
-            TypeOfExpr(_) | BuiltinFn => {}
+            TypeOfExpr(_) | BuiltinFn | Atomic(..) => {}
         }
     }