Merge pull request #1531 from emilio/ref-layout

Work around a libclang bug / limitation.

Author: emilio

CHANGELOG.md

@@ -92,6 +92,17 @@ Released YYYY/MM/DD
 
 * TODO (or remove section if none)
 
+--------------------------------------------------------------------------------
+
+# 0.48.1
+
+Released 2019/03/06
+
+## Fixed
+
+* Bindgen will properly lay out types that use reference members. [#1531][]
+
+[#1531]: https://github.com/rust-lang-nursery/rust-bindgen/issues/1531
 
 --------------------------------------------------------------------------------
 

Cargo.lock

@@ -14,7 +14,7 @@ readme = "README.md"
 repository = "https://github.com/rust-lang/rust-bindgen"
 documentation = "https://docs.rs/bindgen"
 homepage = "https://rust-lang.github.io/rust-bindgen/"
-version = "0.48.0"
+version = "0.48.1"
 build = "build.rs"
 
 include = [

Cargo.toml

@@ -7,6 +7,7 @@
 use cexpr;
 use clang_sys::*;
 use regex;
+use ir::context::BindgenContext;
 use std::{mem, ptr, slice};
 use std::ffi::{CStr, CString};
 use std::fmt;
@@ -933,35 +934,44 @@ impl Type {
 
     #[inline]
     fn is_non_deductible_auto_type(&self) -> bool {
-        self.kind() == CXType_Auto && self.canonical_type() == *self
+        debug_assert_eq!(self.kind(), CXType_Auto);
+        self.canonical_type() == *self
     }
 
     #[inline]
-    fn clang_size_of(&self) -> c_longlong {
-        if self.is_non_deductible_auto_type() {
-            return -6; // Work-around https://bugs.llvm.org/show_bug.cgi?id=40813
+    fn clang_size_of(&self, ctx: &BindgenContext) -> c_longlong {
+        match self.kind() {
+            // Work-around https://bugs.llvm.org/show_bug.cgi?id=40975
+            CXType_RValueReference |
+            CXType_LValueReference => ctx.target_pointer_size() as c_longlong,
+            // Work-around https://bugs.llvm.org/show_bug.cgi?id=40813
+            CXType_Auto if self.is_non_deductible_auto_type() => return -6,
+            _ => unsafe { clang_Type_getSizeOf(self.x) },
         }
-        unsafe { clang_Type_getSizeOf(self.x) }
     }
 
     #[inline]
-    fn clang_align_of(&self) -> c_longlong {
-        if self.is_non_deductible_auto_type() {
-            return -6; // Work-around https://bugs.llvm.org/show_bug.cgi?id=40813
+    fn clang_align_of(&self, ctx: &BindgenContext) -> c_longlong {
+        match self.kind() {
+            // Work-around https://bugs.llvm.org/show_bug.cgi?id=40975
+            CXType_RValueReference |
+            CXType_LValueReference => ctx.target_pointer_size() as c_longlong,
+            // Work-around https://bugs.llvm.org/show_bug.cgi?id=40813
+            CXType_Auto if self.is_non_deductible_auto_type() => return -6,
+            _ => unsafe { clang_Type_getAlignOf(self.x) },
         }
-        unsafe { clang_Type_getAlignOf(self.x) }
     }
 
     /// What is the size of this type? Paper over invalid types by returning `0`
     /// for them.
-    pub fn size(&self) -> usize {
-        let val = self.clang_size_of();
+    pub fn size(&self, ctx: &BindgenContext) -> usize {
+        let val = self.clang_size_of(ctx);
         if val < 0 { 0 } else { val as usize }
     }
 
     /// What is the size of this type?
-    pub fn fallible_size(&self) -> Result<usize, LayoutError> {
-        let val = self.clang_size_of();
+    pub fn fallible_size(&self, ctx: &BindgenContext) -> Result<usize, LayoutError> {
+        let val = self.clang_size_of(ctx);
         if val < 0 {
             Err(LayoutError::from(val as i32))
         } else {
@@ -971,14 +981,14 @@ impl Type {
 
     /// What is the alignment of this type? Paper over invalid types by
     /// returning `0`.
-    pub fn align(&self) -> usize {
-        let val = self.clang_align_of();
+    pub fn align(&self, ctx: &BindgenContext) -> usize {
+        let val = self.clang_align_of(ctx);
         if val < 0 { 0 } else { val as usize }
     }
 
     /// What is the alignment of this type?
-    pub fn fallible_align(&self) -> Result<usize, LayoutError> {
-        let val = self.clang_align_of();
+    pub fn fallible_align(&self, ctx: &BindgenContext) -> Result<usize, LayoutError> {
+        let val = self.clang_align_of(ctx);
         if val < 0 {
             Err(LayoutError::from(val as i32))
         } else {
@@ -988,10 +998,10 @@ impl Type {
 
     /// Get the layout for this type, or an error describing why it does not
     /// have a valid layout.
-    pub fn fallible_layout(&self) -> Result<::ir::layout::Layout, LayoutError> {
+    pub fn fallible_layout(&self, ctx: &BindgenContext) -> Result<::ir::layout::Layout, LayoutError> {
         use ir::layout::Layout;
-        let size = self.fallible_size()?;
-        let align = self.fallible_align()?;
+        let size = self.fallible_size(ctx)?;
+        let align = self.fallible_align(ctx)?;
         Ok(Layout::new(size, align))
     }
 

src/clang.rs

@@ -1755,7 +1755,7 @@ If you encounter an error missing from this list, please file an issue or a PR!"
                             sub_name,
                             template_decl_cursor
                                 .cur_type()
-                                .fallible_layout()
+                                .fallible_layout(self)
                                 .ok(),
                             sub_kind,
                             false,
@@ -1821,7 +1821,7 @@ If you encounter an error missing from this list, please file an issue or a PR!"
         let name = if name.is_empty() { None } else { Some(name) };
         let ty = Type::new(
             name,
-            ty.fallible_layout().ok(),
+            ty.fallible_layout(self).ok(),
             type_kind,
             ty.is_const(),
         );
@@ -1977,7 +1977,7 @@ If you encounter an error missing from this list, please file an issue or a PR!"
         is_const: bool,
     ) -> TypeId {
         let spelling = ty.spelling();
-        let layout = ty.fallible_layout().ok();
+        let layout = ty.fallible_layout(self).ok();
         let type_kind = TypeKind::ResolvedTypeRef(wrapped_id);
         let ty = Type::new(Some(spelling), layout, type_kind, is_const);
         let item = Item::new(
@@ -2018,7 +2018,7 @@ If you encounter an error missing from this list, please file an issue or a PR!"
             CXType_UShort => TypeKind::Int(IntKind::UShort),
             CXType_WChar => {
                 TypeKind::Int(IntKind::WChar {
-                    size: ty.fallible_size().expect("Couldn't compute size of wchar_t?"),
+                    size: ty.fallible_size(self).expect("Couldn't compute size of wchar_t?"),
                 })
             },
             CXType_Char16 => TypeKind::Int(IntKind::U16),
@@ -2056,7 +2056,7 @@ If you encounter an error missing from this list, please file an issue or a PR!"
 
         let spelling = ty.spelling();
         let is_const = ty.is_const();
-        let layout = ty.fallible_layout().ok();
+        let layout = ty.fallible_layout(self).ok();
         let ty = Type::new(Some(spelling), layout, type_kind, is_const);
         let id = self.next_item_id();
         let item =

src/ir/context.rs

@@ -454,7 +454,7 @@ impl Item {
         ty: &clang::Type,
         ctx: &mut BindgenContext,
     ) -> TypeId {
-        let ty = Opaque::from_clang_ty(ty);
+        let ty = Opaque::from_clang_ty(ty, ctx);
         let kind = ItemKind::Type(ty);
         let parent = ctx.root_module().into();
         ctx.add_item(Item::new(with_id, None, None, parent, kind), None, None);

src/ir/item.rs

@@ -100,8 +100,8 @@ pub struct Opaque(pub Layout);
 
 impl Opaque {
     /// Construct a new opaque type from the given clang type.
-    pub fn from_clang_ty(ty: &clang::Type) -> Type {
-        let layout = Layout::new(ty.size(), ty.align());
+    pub fn from_clang_ty(ty: &clang::Type, ctx: &BindgenContext) -> Type {
+        let layout = Layout::new(ty.size(ctx), ty.align(ctx));
         let ty_kind = TypeKind::Opaque;
         let is_const = ty.is_const();
         Type::new(None, Some(layout), ty_kind, is_const)

src/ir/layout.rs

@@ -730,7 +730,7 @@ impl Type {
             }
         }
 
-        let layout = ty.fallible_layout().ok();
+        let layout = ty.fallible_layout(ctx).ok();
         let cursor = ty.declaration();
         let mut name = cursor.spelling();
 
@@ -780,7 +780,7 @@ impl Type {
                    opaque type instead."
             );
             return Ok(
-                ParseResult::New(Opaque::from_clang_ty(&canonical_ty), None),
+                ParseResult::New(Opaque::from_clang_ty(&canonical_ty, ctx), None),
             );
         }
 
@@ -912,7 +912,7 @@ impl Type {
                                                from class template or base \
                                                specifier, using opaque blob"
                                         );
-                                        let opaque = Opaque::from_clang_ty(ty);
+                                        let opaque = Opaque::from_clang_ty(ty, ctx);
                                         return Ok(
                                             ParseResult::New(opaque, None),
                                         );

src/ir/ty.rs

@@ -0,0 +1,150 @@
+/* automatically generated by rust-bindgen */
+
+#![allow(
+    dead_code,
+    non_snake_case,
+    non_camel_case_types,
+    non_upper_case_globals
+)]
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Foo {
+    _unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Bar {
+    pub f: *const Foo,
+    pub m: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_Bar() {
+    assert_eq!(
+        ::std::mem::size_of::<Bar>(),
+        16usize,
+        concat!("Size of: ", stringify!(Bar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Bar>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Bar))
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<Bar>())).f as *const _ as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(f))
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<Bar>())).m as *const _ as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(Bar), "::", stringify!(m))
+    );
+}
+impl Default for Bar {
+    fn default() -> Self {
+        unsafe { ::std::mem::zeroed() }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Baz {
+    pub f: *mut Foo,
+    pub m: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_Baz() {
+    assert_eq!(
+        ::std::mem::size_of::<Baz>(),
+        16usize,
+        concat!("Size of: ", stringify!(Baz))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Baz>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Baz))
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<Baz>())).f as *const _ as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Baz), "::", stringify!(f))
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<Baz>())).m as *const _ as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(Baz), "::", stringify!(m))
+    );
+}
+impl Default for Baz {
+    fn default() -> Self {
+        unsafe { ::std::mem::zeroed() }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Tar {
+    pub f: *const Foo,
+    pub m: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_Tar() {
+    assert_eq!(
+        ::std::mem::size_of::<Tar>(),
+        16usize,
+        concat!("Size of: ", stringify!(Tar))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Tar>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Tar))
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<Tar>())).f as *const _ as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Tar), "::", stringify!(f))
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<Tar>())).m as *const _ as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(Tar), "::", stringify!(m))
+    );
+}
+impl Default for Tar {
+    fn default() -> Self {
+        unsafe { ::std::mem::zeroed() }
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Taz {
+    pub f: *mut Foo,
+    pub m: ::std::os::raw::c_uint,
+}
+#[test]
+fn bindgen_test_layout_Taz() {
+    assert_eq!(
+        ::std::mem::size_of::<Taz>(),
+        16usize,
+        concat!("Size of: ", stringify!(Taz))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<Taz>(),
+        8usize,
+        concat!("Alignment of ", stringify!(Taz))
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<Taz>())).f as *const _ as usize },
+        0usize,
+        concat!("Offset of field: ", stringify!(Taz), "::", stringify!(f))
+    );
+    assert_eq!(
+        unsafe { &(*(::std::ptr::null::<Taz>())).m as *const _ as usize },
+        8usize,
+        concat!("Offset of field: ", stringify!(Taz), "::", stringify!(m))
+    );
+}
+impl Default for Taz {
+    fn default() -> Self {
+        unsafe { ::std::mem::zeroed() }
+    }
+}

tests/expectations/tests/issue-1443.rs

@@ -0,0 +1,21 @@
+struct Foo;
+
+struct Bar {
+  const Foo& f;
+  unsigned m;
+};
+
+struct Baz {
+  Foo& f;
+  unsigned m;
+};
+
+struct Tar {
+  const Foo&& f;
+  unsigned m;
+};
+
+struct Taz {
+  Foo&& f;
+  unsigned m;
+};