Translate alignof and alignas (#344)

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -790,7 +790,7 @@ void Converter::EmitRustStructOrUnion(clang::RecordDecl *decl) {
 
   // Derived traits
   if (EmitsReprCForRecords()) {
-    StrCat("#[repr(C)]");
+    EmitReprC(decl);
   }
   auto attrs = GetStructAttributes(decl);
   Mapper::SetDerives(ctx_.getCanonicalTagType(decl),
@@ -892,8 +892,17 @@ std::string Converter::DestroyMembers(const clang::CXXRecordDecl *decl) {
   return out;
 }
 
-void Converter::EmitRustUnion(clang::RecordDecl *decl) {
+void Converter::EmitReprC(clang::RecordDecl *decl) {
+  if (decl->hasAttr<clang::AlignedAttr>()) {
+    StrCat(std::format("#[repr(C, align({}))]",
+                       ctx_.getTypeAlign(ctx_.getCanonicalTagType(decl)) / 8));
+    return;
+  }
   StrCat("#[repr(C)]");
+}
+
+void Converter::EmitRustUnion(clang::RecordDecl *decl) {
+  EmitReprC(decl);
   auto attrs = GetStructAttributes(decl);
   Mapper::SetDerives(ctx_.getCanonicalTagType(decl),
                      std::vector<std::string>(attrs.begin(), attrs.end()));
@@ -3400,6 +3409,15 @@ bool Converter::VisitUnaryExprOrTypeTraitExpr(
                                   : expr->getArgumentExpr()->getType())));
     computed_expr_type_ = ComputedExprType::FreshValue;
     break;
+  case clang::UnaryExprOrTypeTrait::UETT_AlignOf:
+  case clang::UnaryExprOrTypeTrait::UETT_PreferredAlignOf:
+    StrCat(std::format(
+        "::std::mem::align_of::<{}>()",
+        GetUnsafeTypeAsString(expr->isArgumentType()
+                                  ? expr->getArgumentType()
+                                  : expr->getArgumentExpr()->getType())));
+    computed_expr_type_ = ComputedExprType::FreshValue;
+    break;
   default:
     // FIXME: improve error handling
     log() << "unsupported unary expr or type trait expr\n";

cpp2rust/converter/converter.h

@@ -120,6 +120,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual void EmitRustStructOrUnion(clang::RecordDecl *decl);
 
+  void EmitReprC(clang::RecordDecl *decl);
   virtual void EmitRustUnion(clang::RecordDecl *decl);
 
   virtual bool EmitsReprCForRecords() const { return true; }

cpp2rust/converter/models/converter_refcount.cpp

@@ -1402,14 +1402,28 @@ bool ConverterRefCount::VisitExplicitCastExpr(clang::ExplicitCastExpr *expr) {
 
 bool ConverterRefCount::VisitUnaryExprOrTypeTraitExpr(
     clang::UnaryExprOrTypeTraitExpr *expr) {
-  if (expr->getKind() == clang::UnaryExprOrTypeTrait::UETT_SizeOf) {
-    auto arg_type = expr->isArgumentType() ? expr->getArgumentType()
-                                           : expr->getArgumentExpr()->getType();
+  auto arg_type = expr->isArgumentType() ? expr->getArgumentType()
+                                         : expr->getArgumentExpr()->getType();
+  switch (expr->getKind()) {
+  case clang::UnaryExprOrTypeTrait::UETT_SizeOf:
+    // TODO: Once Values are dropped from fields, precomputation should be gone
     if (RustSizeDivergesFromC(arg_type)) {
       StrCat(std::format("{}usize", ctx_.getTypeSize(arg_type) / 8));
       computed_expr_type_ = ComputedExprType::FreshValue;
       return false;
     }
+    break;
+  case clang::UnaryExprOrTypeTrait::UETT_AlignOf:
+  case clang::UnaryExprOrTypeTrait::UETT_PreferredAlignOf:
+    // TODO: Once Values are dropped from fields, precomputation should be gone
+    if (RustSizeDivergesFromC(arg_type)) {
+      StrCat(std::format("{}usize", ctx_.getTypeAlign(arg_type) / 8));
+      computed_expr_type_ = ComputedExprType::FreshValue;
+      return false;
+    }
+    break;
+  default:
+    break;
   }
   return Converter::VisitUnaryExprOrTypeTraitExpr(expr);
 }

tests/unit/out/refcount/unary_expr_or_type_trait.rs

@@ -0,0 +1,71 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive(Default)]
+pub struct S {
+    pub c: Value<u8>,
+    pub x: Value<i64>,
+}
+impl Clone for S {
+    fn clone(&self) -> Self {
+        let __this: Value<S> = Rc::new(RefCell::new(Self {
+            c: Rc::new(RefCell::new((*self.c.borrow()))),
+            x: Rc::new(RefCell::new((*self.x.borrow()))),
+        }));
+        let this: Ptr<S> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl ByteRepr for S {
+    fn byte_size() -> usize {
+        16
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.c.borrow()).to_bytes(&mut buf[0..1]);
+        (*self.x.borrow()).to_bytes(&mut buf[8..16]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            c: Rc::new(RefCell::new(<u8>::from_bytes(&buf[0..1]))),
+            x: Rc::new(RefCell::new(<i64>::from_bytes(&buf[8..16]))),
+        }
+    }
+}
+pub fn pack_size_0() -> u64 {
+    return ((0 as usize).wrapping_add((0 as usize)) as u64);
+}
+pub fn pack_size_1(args_0: i32, args_1: f64) -> u64 {
+    let args_0: Value<i32> = Rc::new(RefCell::new(args_0));
+    let args_1: Value<f64> = Rc::new(RefCell::new(args_1));
+    return ((2 as usize).wrapping_add((2 as usize)) as u64);
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let arr: Value<Box<[i64]>> = Rc::new(RefCell::new(Box::new([
+        <i64>::default(),
+        <i64>::default(),
+        <i64>::default(),
+        <i64>::default(),
+    ])));
+    let s: Value<S> = Rc::new(RefCell::new(S {
+        c: Rc::new(RefCell::new(<u8>::default())),
+        x: Rc::new(RefCell::new(<i64>::default())),
+    }));
+    assert!((::std::mem::size_of::<i32>() == 4_usize));
+    assert!((::std::mem::size_of::<[i64; 4]>() == 32_usize));
+    assert!((16usize == 16_usize));
+    assert!((::std::mem::align_of::<i32>() == 4_usize));
+    assert!((16usize == 16_usize));
+    assert!((::std::mem::align_of::<[i64; 4]>() == 8_usize));
+    assert!((16usize == 16_usize));
+    assert!((({ pack_size_0() }) == 0_u64));
+    assert!((({ pack_size_1(1, 2.0E+0,) }) == 4_u64));
+    return 0;
+}

tests/unit/out/unsafe/unary_expr_or_type_trait.rs

@@ -0,0 +1,42 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+#[repr(C, align(16))]
+#[derive(Copy, Clone, Default)]
+pub struct S {
+    pub c: libc::c_char,
+    pub x: i64,
+}
+pub unsafe fn pack_size_0() -> u64 {
+    return ((0 as usize).wrapping_add((0 as usize)) as u64);
+}
+pub unsafe fn pack_size_1(mut args_0: i32, mut args_1: f64) -> u64 {
+    return ((2 as usize).wrapping_add((2 as usize)) as u64);
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut arr: [i64; 4] = [0_i64, 0_i64, 0_i64, 0_i64];
+    let mut s: S = S {
+        c: (0 as libc::c_char),
+        x: 0_i64,
+    };
+    assert!(((::std::mem::size_of::<i32>()) == (4_usize)));
+    assert!(((::std::mem::size_of::<[i64; 4]>()) == (32_usize)));
+    assert!(((::std::mem::size_of::<S>()) == (16_usize)));
+    assert!(((::std::mem::align_of::<i32>()) == (4_usize)));
+    assert!(((::std::mem::align_of::<S>()) == (16_usize)));
+    assert!(((::std::mem::align_of::<[i64; 4]>()) == (8_usize)));
+    assert!(((::std::mem::align_of::<S>()) == (16_usize)));
+    assert!(((unsafe { pack_size_0() }) == (0_u64)));
+    assert!(((unsafe { pack_size_1(1, 2.0E+0,) }) == (4_u64)));
+    return 0;
+}

tests/unit/unary_expr_or_type_trait.cpp

@@ -0,0 +1,30 @@
+#include <cassert>
+#include <cstdint>
+
+struct alignas(16) S {
+  char c;
+  int64_t x;
+};
+
+template <typename... Args> unsigned long pack_size(Args... args) {
+  return sizeof...(args) + sizeof...(Args);
+}
+
+int main() {
+  int64_t arr[4] = {};
+  S s{};
+
+  assert(sizeof(int32_t) == 4);
+  assert(sizeof(arr) == 32);
+  assert(sizeof(s) == 16);
+
+  assert(alignof(int32_t) == 4);
+  assert(alignof(S) == 16);
+
+  assert(__alignof(arr) == 8);
+  assert(__alignof(s) == 16);
+
+  assert(pack_size() == 0);
+  assert(pack_size(1, 2.0) == 4);
+  return 0;
+}