Wip

Author: emilio

src/codegen/mod.rs

@@ -448,20 +448,24 @@ impl<'a> ItemCanonicalName for Vtable<'a> {
     }
 }
 
+impl<'a> ItemToRustTy for Vtable<'a> {
+    fn to_rust_ty(&self, ctx: &BindgenContext) -> P<ast::Ty> {
+        aster::ty::TyBuilder::new().id(self.canonical_name(ctx))
+    }
+}
+
 struct Bitfield<'a> {
     item: &'a Item,
     index: usize,
     fields: Vec<&'a Field>,
-    layout: Layout,
 }
 
 impl<'a> Bitfield<'a> {
-    fn new(item: &'a Item, index: usize, fields: Vec<&'a Field>, layout: Layout) -> Self {
+    fn new(item: &'a Item, index: usize, fields: Vec<&'a Field>) -> Self {
         Bitfield {
             item: item,
             index: index,
             fields: fields,
-            layout: layout,
         }
     }
 
@@ -490,15 +494,24 @@ impl<'a> Bitfield<'a> {
                       fields: &mut Vec<ast::StructField>,
                       methods: &mut Vec<ast::ImplItem>) {
         use aster::struct_field::StructFieldBuilder;
-        let bitfield_type = BlobTyBuilder::new(self.layout).build();
+        use std::cmp;
+        let mut total_width = self.fields.iter()
+                                     .fold(0u32, |acc, f| acc + f.bitfield().unwrap());
+
+        if !total_width.is_power_of_two() || total_width < 8 {
+            total_width = cmp::max(8, total_width.next_power_of_two());
+        }
+        debug_assert_eq!(total_width % 8, 0);
+        let total_width_in_bytes = total_width as usize / 8;
+
+        let bitfield_type =
+            BlobTyBuilder::new(Layout::new(total_width_in_bytes, total_width_in_bytes)).build();
         let field_name = format!("_bitfield_{}", self.index);
+        let field_ident = ctx.ext_cx().ident_of(&field_name);
         let field = StructFieldBuilder::named(&field_name).pub_()
                         .build_ty(bitfield_type.clone());
         fields.push(field);
 
-        let field_ident = ctx.ext_cx().ident_of(&field_name);
-        let total_width = self.fields.iter()
-                                     .fold(0u32, |acc, f| acc + f.bitfield().unwrap());
 
         let mut offset = 0;
         for field in self.fields {
@@ -571,7 +584,15 @@ impl CodeGenerator for CompInfo {
         if let Some(comment) = item.comment() {
             attributes.push(doc!(comment));
         }
-        attributes.push(repr!("C"));
+        if self.packed() {
+            // TODO: reuse the repr! macro?
+            let c_packed =
+                aster::AstBuilder::new().attr().list("repr")
+                    .words(&["C", "packed"]).build();
+            attributes.push(c_packed);
+        } else {
+            attributes.push(repr!("C"));
+        }
 
         let applicable_template_args = item.applicable_template_args(ctx);
         let mut template_args_used = vec![false; applicable_template_args.len()];
@@ -584,21 +605,36 @@ impl CodeGenerator for CompInfo {
         // TODO: I don't know how this could play with virtual methods that are
         // not in the list of methods found by us, we'll see. Also, could the
         // order of the vtable pointers vary?
+        //
+        // FIXME: Once we generate proper vtables, we need to codegen the
+        // vtable, but *not* generate a field for it in the case that
+        // needs_explicit_vtable is false but has_vtable is true.
+        //
+        // Also, we need to generate the vtable in such a way it "inherits" from
+        // the parent too.
         let mut fields = vec![];
-        if self.has_vtable() {
+        if self.needs_explicit_vtable(ctx) {
             let vtable = Vtable::new(item.id(),
                                      self.methods(),
                                      self.base_members());
             vtable.codegen(ctx, result, item);
 
+            let vtable_type = vtable.to_rust_ty(ctx).to_ptr(true, ctx.span());
+
             let vtable_field = StructFieldBuilder::named("vtable_").pub_()
-                                    .ty().id(vtable.canonical_name(ctx));
+                                    .build_ty(vtable_type);
 
             fields.push(vtable_field);
         }
 
         for (i, base) in self.base_members().iter().enumerate() {
             let base_ty = ctx.resolve_type(*base);
+            // NB: We won't include unsized types in our base chain because they
+            // would contribute to our size given the dummy field we insert for
+            // unsized types.
+            if base_ty.expect_comp().is_unsized(ctx) {
+                continue;
+            }
             for (i, ty) in applicable_template_args.iter().enumerate() {
                 if base_ty.signature_contains_named_type(ctx, ctx.resolve_type(*ty)) {
                     template_args_used[i] = true;
@@ -619,12 +655,13 @@ impl CodeGenerator for CompInfo {
         let layout = item.kind().expect_type().layout(ctx);
 
         let mut current_bitfield_width = None;
-        let mut current_bitfield_layout = None;
+        let mut current_bitfield_layout: Option<Layout> = None;
         let mut current_bitfield_fields = vec![];
         let mut bitfield_count = 0;
         let struct_fields = self.fields();
 
         let mut methods = vec![];
+        let mut anonymous_field_count = 0;
         for field in struct_fields {
             debug_assert_eq!(current_bitfield_width.is_some(),
                              current_bitfield_layout.is_some());
@@ -635,8 +672,9 @@ impl CodeGenerator for CompInfo {
 
             // Try to catch a bitfield contination early.
             if let (Some(ref mut bitfield_width), Some(width)) = (current_bitfield_width, field.bitfield()) {
-                let layout = field_ty.layout(ctx)
-                                     .expect("How can a type in a bitfield have no layout?");
+                let layout = current_bitfield_layout.unwrap();
+                debug!("Testing bitfield continuation {} {} {:?}",
+                       *bitfield_width, width, layout);
                  if *bitfield_width + width <= (layout.size * 8) as u32 {
                      *bitfield_width += width;
                      current_bitfield_fields.push(field);
@@ -650,8 +688,7 @@ impl CodeGenerator for CompInfo {
                 let bitfield_fields =
                     mem::replace(&mut current_bitfield_fields, vec![]);
                 bitfield_count += 1;
-                Bitfield::new(item, bitfield_count, bitfield_fields,
-                              current_bitfield_layout.unwrap())
+                Bitfield::new(item, bitfield_count, bitfield_fields)
                     .codegen_fields(ctx, &mut fields, &mut methods);
                 current_bitfield_width = None;
                 current_bitfield_layout = None;
@@ -660,7 +697,7 @@ impl CodeGenerator for CompInfo {
 
             if let Some(width) = field.bitfield() {
                 let layout = field_ty.layout(ctx)
-                                     .expect("How can a type in a bitfield have no layout?");
+                                     .expect("Bitfield type without layout?");
                 current_bitfield_width = Some(width);
                 current_bitfield_layout = Some(layout);
                 current_bitfield_fields.push(field);
@@ -685,8 +722,14 @@ impl CodeGenerator for CompInfo {
             if let Some(comment) = field.comment() {
                 attrs.push(doc!(comment));
             }
-
-            let field = StructFieldBuilder::named(field.name().unwrap()).pub_()
+            let field_name = match field.name() {
+                Some(name) => name.to_owned(),
+                None => {
+                    anonymous_field_count += 1;
+                    format!("__bindgen_anon_{}", anonymous_field_count)
+                }
+            };
+            let field = StructFieldBuilder::named(field_name).pub_()
                                     .with_attrs(attrs)
                                     .build_ty(ty);
             fields.push(field);
@@ -695,12 +738,12 @@ impl CodeGenerator for CompInfo {
         // Flush the last bitfield if any.
         //
         // FIXME: Reduce duplication with the loop above.
+        // FIXME: May need to pass current_bitfield_layout too.
         if current_bitfield_width.is_some() {
             debug_assert!(!current_bitfield_fields.is_empty());
             let bitfield_fields = mem::replace(&mut current_bitfield_fields, vec![]);
             bitfield_count += 1;
-            Bitfield::new(item, bitfield_count, bitfield_fields,
-                          current_bitfield_layout.unwrap())
+            Bitfield::new(item, bitfield_count, bitfield_fields)
                 .codegen_fields(ctx, &mut fields, &mut methods);
         }
         debug_assert!(current_bitfield_fields.is_empty());
@@ -716,6 +759,7 @@ impl CodeGenerator for CompInfo {
         // Yeah, sorry about that.
         if item.opaque(ctx) {
             fields.clear();
+            methods.clear();
             for i in 0..template_args_used.len() {
                 template_args_used[i] = false;
             }
@@ -733,6 +777,18 @@ impl CodeGenerator for CompInfo {
             }
         }
 
+        // C requires every struct to be addressable, so what C compilers do is
+        // making the struct 1-byte sized.
+        //
+        // NOTE: This check is conveniently here to avoid the dummy fields we
+        // may add for unused template parameters.
+        if self.is_unsized(ctx) {
+            let ty = BlobTyBuilder::new(Layout::new(1, 1)).build();
+            let field = StructFieldBuilder::named("_address").pub_()
+                            .build_ty(ty);
+            fields.push(field);
+        }
+
         // Append any extra template arguments that nobody has used so far.
         for (i, ty) in applicable_template_args.iter().enumerate() {
             if !template_args_used[i] {
@@ -781,11 +837,36 @@ impl CodeGenerator for CompInfo {
             ctx.resolve_item(*ty).codegen(ctx, result, &());
         }
 
-        if applicable_template_args.is_empty() {
+        // NOTE: Some unexposed attributes (like alignment attributes) may
+        // affect layout, so we're bad and pray to the gods for avoid sending
+        // all the tests to shit when parsing things like max_align_t.
+        if self.found_unknown_attr() {
+            warn!("Type {} has an unkown attribute that may affect layout", canonical_name);
+        }
+        if applicable_template_args.is_empty() && !self.found_unknown_attr() {
             for var in self.inner_vars() {
                 ctx.resolve_item(*var).codegen(ctx, result, &());
             }
 
+            if let Some(layout) = layout {
+                let fn_name =
+                    ctx.rust_ident_raw(format!("bindgen_test_layout_{}", canonical_name));
+                let ident = ctx.rust_ident_raw(canonical_name);
+                let size_of_expr =
+                    quote_expr!(ctx.ext_cx(), ::std::mem::size_of::<$ident>());
+                let align_of_expr =
+                    quote_expr!(ctx.ext_cx(), ::std::mem::align_of::<$ident>());
+                let size = layout.size;
+                let align = layout.align;
+                let item = quote_item!(ctx.ext_cx(),
+                    #[test]
+                    fn $fn_name() {
+                        assert_eq!($size_of_expr, $size);
+                        assert_eq!($align_of_expr, $align);
+                    }).unwrap();
+                result.push(item);
+            }
+
             for method in self.methods() {
                 if !method.is_virtual() {
                     ctx.resolve_item(method.signature()).codegen(ctx, result, &());